rapidshot 1.0.0__tar.gz

rapidshot-1.0.0/.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: [Zaatra]

rapidshot-1.0.0/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.

rapidshot-1.0.0/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

rapidshot-1.0.0/.gitignore

@@ -0,0 +1,132 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Local tests
+.test/

rapidshot-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Rain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rapidshot-1.0.0/PKG-INFO

@@ -0,0 +1,409 @@
+Metadata-Version: 2.4
+Name: rapidshot
+Version: 1.0.0
+Summary: A high-performance screencapture library for Windows using Desktop Duplication API
+Home-page: https://github.com/Zaatra/Rapidshot
+Author: Rapidshot Contributors
+Author-email: RapidShot Contributors <example@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Zaatra/Rapidshot
+Project-URL: Bug Reports, https://github.com/Zaatra/Rapidshot/issues
+Project-URL: Source, https://github.com/Zaatra/Rapidshot
+Project-URL: Documentation, https://github.com/Zaatra/Rapidshot
+Keywords: screencapture,desktop-duplication,screen-recorder,windows
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Multimedia :: Graphics :: Capture
+Classifier: Topic :: Multimedia :: Graphics :: Capture :: Screen Capture
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.19.0
+Requires-Dist: comtypes>=1.1.0
+Provides-Extra: cv2
+Requires-Dist: opencv-python>=4.5.0; extra == "cv2"
+Provides-Extra: gpu
+Requires-Dist: cupy-cuda11x>=11.0.0; extra == "gpu"
+Requires-Dist: opencv-python>=4.5.0; extra == "gpu"
+Provides-Extra: pil
+Requires-Dist: pillow>=8.0.0; extra == "pil"
+Provides-Extra: all
+Requires-Dist: numpy>=1.19.0; extra == "all"
+Requires-Dist: comtypes>=1.1.0; extra == "all"
+Requires-Dist: opencv-python>=4.5.0; extra == "all"
+Requires-Dist: pillow>=8.0.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: black>=22.3.0; extra == "dev"
+Requires-Dist: isort>=5.10.1; extra == "dev"
+Requires-Dist: mypy>=0.950; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: flake8>=4.0.1; extra == "dev"
+Requires-Dist: tox>=3.24.5; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=4.5.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.0.0; extra == "docs"
+Requires-Dist: myst-parser>=0.18.0; extra == "docs"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# RapidShot
+
+A high-performance screencapture library for Windows using the Desktop Duplication API. This is a merged version combining features from multiple DXCam forks, designed to deliver ultra-fast capture capabilities with advanced functionality.
+
+## Features
+
+- **Ultra-fast capture**: 240Hz+ capturing capability
+- **Multi-backend support**: NumPy, PIL, and CUDA/CuPy backends
+- **Cursor capture**: Capture mouse cursor position and shape
+- **Direct3D support**: Capture Direct3D exclusive full-screen applications without interruption
+- **NVIDIA GPU acceleration**: GPU-accelerated processing using CuPy
+- **Multi-monitor setup**: Support for multiple GPUs and monitors
+- **Flexible output formats**: RGB, RGBA, BGR, BGRA, and grayscale support
+- **Region-based capture**: Efficient capture of specific screen regions
+- **Rotation handling**: Automatic handling of rotated displays
+
+## Installation
+
+> **Note:** The package is installed as `rapidshot` and imported as `import rapidshot`.
+
+### Basic Installation
+
+```bash
+pip install rapidshot
+```
+
+### With OpenCV Support (recommended)
+
+```bash
+pip install rapidshot[cv2]
+```
+
+### With NVIDIA GPU Acceleration
+
+```bash
+pip install rapidshot[gpu]
+```
+
+### With All Dependencies
+
+```bash
+pip install rapidshot[all]
+```
+
+## Quick Start
+
+### Basic Screencapture
+
+```python
+import rapidshot
+
+# Create a ScreenCapture instance on the primary monitor
+screencapture = rapidshot.create()
+
+# Take a screencapture
+frame = screencapture.grab()
+
+# Display the screencapture
+from PIL import Image
+Image.fromarray(frame).show()
+```
+
+### Region-based Capture
+
+```python
+# Define a specific region
+left, top = (1920 - 640) // 2, (1080 - 640) // 2
+right, bottom = left + 640, top + 640
+region = (left, top, right, bottom)
+
+# Capture only this region
+frame = screencapture.grab(region=region)  # 640x640x3 numpy.ndarray
+```
+
+### Continuous Capture
+
+```python
+# Start capturing at 60 FPS
+screencapture.start(target_fps=60)
+
+# Get the latest frame
+for i in range(1000):
+    image = screencapture.get_latest_frame()  # Blocks until new frame is available
+    # Process the frame...
+
+# Stop capturing
+screencapture.stop()
+```
+
+### Video Recording
+
+```python
+import rapidshot
+import cv2
+
+# Create a ScreenCapture instance with BGR color format for OpenCV
+screencapture = rapidshot.create(output_color="BGR")
+
+# Start capturing at 30 FPS in video mode
+screencapture.start(target_fps=30, video_mode=True)
+
+# Create a video writer
+writer = cv2.VideoWriter(
+    "video.mp4", cv2.VideoWriter_fourcc(*"mp4v"), 30, (1920, 1080)
+)
+
+# Record for 10 seconds (300 frames at 30 FPS)
+for i in range(300):
+    writer.write(screencapture.get_latest_frame())
+
+# Clean up
+screencapture.stop()
+writer.release()
+```
+
+### NVIDIA GPU Acceleration
+
+```python
+# Create a ScreenCapture instance with NVIDIA GPU acceleration
+screencapture = rapidshot.create(nvidia_gpu=True)
+
+# Screenshots will be processed on the GPU for improved performance
+frame = screencapture.grab()
+```
+
+### Cursor Capture
+
+RapidShot provides comprehensive cursor capture capabilities, allowing you to track cursor position, visibility, and shape in your screen captures.
+
+```python
+# Take a screenshot
+frame = screencapture.grab()
+
+# Get cursor information
+cursor = screencapture.grab_cursor()
+
+# Check if cursor is visible in the capture area
+if cursor.PointerPositionInfo.Visible:
+    # Get cursor position
+    x, y = cursor.PointerPositionInfo.Position.x, cursor.PointerPositionInfo.Position.y
+    print(f"Cursor position: ({x}, {y})")
+    
+    # Cursor shape information is also available
+    if cursor.Shape is not None:
+        width = cursor.PointerShapeInfo.Width
+        height = cursor.PointerShapeInfo.Height
+        print(f"Cursor size: {width}x{height}")
+```
+
+#### Advanced Cursor Handling
+
+The cursor information provided by RapidShot can be used in various ways:
+
+1. **Overlay cursor on captured image:**
+
+```python
+import numpy as np
+import cv2
+
+def overlay_cursor(frame, cursor):
+    """Overlay cursor on captured frame."""
+    if not cursor.PointerPositionInfo.Visible or cursor.Shape is None:
+        return frame
+    
+    # Create an overlay from cursor shape data
+    shape_type = cursor.PointerShapeInfo.Type
+    width = cursor.PointerShapeInfo.Width
+    height = cursor.PointerShapeInfo.Height
+    
+    # Different processing based on cursor type (monochrome, color, or masked)
+    if shape_type & DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME:
+        # Process monochrome cursor
+        # ...
+    elif shape_type & DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR:
+        # Process color cursor
+        # ...
+    elif shape_type & DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR:
+        # Process masked color cursor
+        # ...
+    
+    # Position the cursor on the frame at its current coordinates
+    x, y = cursor.PointerPositionInfo.Position.x, cursor.PointerPositionInfo.Position.y
+    
+    # Ensure cursor is within frame boundaries
+    # ...
+    
+    # Blend cursor with frame
+    # ...
+    
+    return frame_with_cursor
+
+# Usage example
+frame = screencapture.grab()
+cursor = screencapture.grab_cursor()
+composite_image = overlay_cursor(frame, cursor)
+```
+
+2. **Track cursor movements:**
+
+```python
+import time
+
+# Record cursor positions over time
+positions = []
+screencapture = rapidshot.create()
+
+for i in range(100):
+    cursor = screencapture.grab_cursor()
+    if cursor.PointerPositionInfo.Visible:
+        positions.append((
+            time.time(),
+            cursor.PointerPositionInfo.Position.x,
+            cursor.PointerPositionInfo.Position.y
+        ))
+    time.sleep(0.05)  # Sample at 20Hz
+
+# Analyze cursor movement
+# ...
+```
+
+## Multiple Monitors / GPUs
+
+```python
+# Show available devices and outputs
+print(rapidshot.device_info())
+print(rapidshot.output_info())
+
+# Create ScreenCapture instances for specific devices/outputs
+capture1 = rapidshot.create(device_idx=0, output_idx=0)  # First monitor on first GPU
+capture2 = rapidshot.create(device_idx=0, output_idx=1)  # Second monitor on first GPU
+capture3 = rapidshot.create(device_idx=1, output_idx=0)  # First monitor on second GPU
+```
+
+## Advanced Usage
+
+### Custom Buffer Size
+
+```python
+# Create a ScreenCapture instance with a larger frame buffer
+screencapture = rapidshot.create(max_buffer_len=256)
+```
+
+### Different Color Formats
+
+```python
+# RGB (default)
+screencapture_rgb = rapidshot.create(output_color="RGB")
+
+# RGBA (with alpha channel)
+screencapture_rgba = rapidshot.create(output_color="RGBA")
+
+# BGR (OpenCV format)
+screencapture_bgr = rapidshot.create(output_color="BGR")
+
+# Grayscale
+screencapture_gray = rapidshot.create(output_color="GRAY")
+```
+
+### Resource Management
+
+```python
+# Release resources when done
+screencapture.release()
+
+# Or automatically released when object is deleted
+del screencapture
+
+# Clean up all resources
+rapidshot.clean_up()
+
+# Reset the library completely
+rapidshot.reset()
+```
+
+## Benchmarks and Performance Comparison
+
+RapidShot includes benchmark utilities to compare its performance against other popular screen capture libraries. The benchmark scripts are located in the `benchmarks/` directory and are designed to provide objective performance measurements.
+
+### Benchmark Structure
+
+- **FPS Benchmarks**: Measure the maximum frame rate achievable by each library
+  - `rapidshot_max_fps.py` - Tests RapidShot's maximum FPS
+  - `bettercam_max_fps.py` - Tests BetterCam's maximum FPS
+  - `dxcam_max_fps.py` - Tests DXCam's maximum FPS
+  - `d3dshot_max_fps.py` - Tests D3DShot's maximum FPS
+  - `mss_max_fps.py` - Tests MSS's maximum FPS
+
+- **Capture Benchmarks**: Test the continuous capture performance
+  - `rapidshot_capture.py` - Tests RapidShot's continuous capture
+  - `bettercam_capture.py` - Tests BetterCam's continuous capture
+  - `dxcam_capture.py` - Tests DXCam's continuous capture
+
+### Running Benchmarks
+
+To run a benchmark comparison:
+
+```bash
+# Run RapidShot benchmark
+python benchmarks/rapidshot_max_fps.py
+
+# Run with GPU acceleration
+python benchmarks/rapidshot_max_fps.py --gpu
+
+# Test with different color formats
+python benchmarks/rapidshot_max_fps.py --color BGRA
+```
+
+### Benchmark Results
+
+The table below shows typical performance results across different libraries:
+
+| Library         | Average FPS | GPU-accelerated FPS |
+|-----------------|-------------|---------------------|
+| RapidShot       | 240+        | 300+                |
+| Original DXCam  | 210         | N/A                 |
+| Python-MSS      | 75          | N/A                 |
+| D3DShot         | 118         | N/A                 |
+
+## System Requirements
+
+- **Operating System:** Windows 10 or newer
+- **Python:** 3.7+
+- **GPU:** Compatible GPU for NVIDIA acceleration (for GPU features)
+- **RAM:** 8 GB+ (depending on the resolution and number of screencapture instances used)
+
+### Troubleshooting
+
+- **ImportError with CuPy:** Ensure you have compatible CUDA drivers installed.
+- **Black screens when capturing:** Verify the application isn't running in exclusive fullscreen mode.
+- **Low performance:** Experiment with different backends (NUMPY vs. CUPY) to optimize performance.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request
+
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Acknowledgments
+
+RapidShot is a merged version of the following projects:
+
+- Original DXcam by ra1nty
+- dxcampil - PIL-based version
+- DXcam-AI-M-BOT - Cursor support version
+- BetterCam - GPU acceleration version