MathewSachin/Captura

Captura is a screen and audio recording application for Windows that captures video, audio, and webcam feeds using multiple backend engines including FFmpeg, Media Foundation, and Windows Desktop Duplication. The system supports diverse output formats such as MP4, AVI, GIF, and PNG, with options to save locally, copy to the clipboard, or upload to services like Imgur and YouTube. It features a modular architecture with a command-line interface, global hotkey support, and customizable overlays for mouse and keyboard events.

24 changes.

The project underwent a significant architectural overhaul, migrating to .NET Standard and adopting a modular, dependency-injection-based design. This period focused on replacing legacy UI and settings systems with modern, extensible components, while introducing new features like webcam support, command-line interfaces, and flexible image output options.

35 changes.

This period focused on a comprehensive architectural overhaul, introducing a dependency injection system, modularizing the build process, and establishing a robust interface-based design for core components like video, audio, and overlays. Simultaneously, the project expanded its feature set with new recording modes, FFmpeg integration, and a modernized user interface with localization support.

13 changes.

This period focused on modernizing the Windows screen capture engine by replacing legacy methods with the Desktop Duplication API and integrating Direct2D and GDI-based imaging subsystems. It also introduced comprehensive webcam support, hardware-accelerated video encoding via Media Foundation and FFmpeg, and new overlay features for visualizing user interactions.

A new 'Preview Only' recording option has been added to the application, allowing users to run the screen capture pipeline in a test mode where video frames are discarded rather than saved to disk. This mode, implemented via the new DiscardWriter classes, automatically displays the preview window and is explicitly described as being 'For testing purposes' in the user interface.

src/Captura.Core/Models/Discard · high confidence

A new Chocolatey installation script (chocolateyinstall.ps1) has been added to the choco/tools directory. This script configures the installation of Captura by specifying the download URL, extraction location, and SHA256 checksum verification, enabling users to install the software via Chocolatey.

choco/tools · high confidence

A new Chocolatey package definition (captura.nuspec) has been added to the repository, enabling users to install the application via the Chocolatey package manager. The manifest includes metadata such as the version (8.0.0), author, project URLs, and links to the Gitter community, facilitating automated distribution and installation for Windows users.

choco · high confidence

The application now supports recording video and audio using the Windows Media Foundation hardware encoder. This adds a new 'MF' writer option that encodes video as H.264 and audio as AAC, producing MP4 files. The implementation includes new components for audio handling (MfAudioItem, MfAudioWriter), color conversion (MfColorConverter), and the main video writer (MfWriter), enabling hardware-accelerated recording with improved performance and stability.

src/Captura.Windows/MediaFoundation · high confidence

The application now includes a new AVI video writer backed by the SharpAvi library. This adds support for uncompressed, Motion JPEG, Lagarith, and various MPEG-4 VfW codecs. Users can select these formats via the CLI or the standard video writer selection interface, with quality settings applied to the encoding process.

src/Captura.SharpAvi · high confidence

The application now includes a new Captura.MouseKeyHook module that provides a unified interface for capturing mouse and keyboard events. This enables visual overlays for mouse clicks, scroll wheel activity, and key presses during screen capture. Users can configure the appearance of these overlays, including colors, font sizes, and positioning. Additionally, the system supports mapping key names via JSON keymap files and offers an option to export recorded keystrokes to a separate text file.

src/Captura.MouseKeyHook · high confidence

The project now includes a Code of Conduct, a Contributing guide, and a Support document to define community expectations and how users can get help. Additionally, the build system has been modernized with a new Cake build script and AppVeyor CI configuration, which automate the build, test, and packaging of the application.

(repo-wide) · high confidence

The application now includes a new Direct2D-based imaging subsystem, introducing classes for rendering and editing frames (Direct2DEditor, Direct2DEditorSession, Direct2DImage, Direct2DFont). This infrastructure supports drawing operations (lines, shapes, text) and provides a mechanism to copy frame data, including a new method to convert textures to the NV12 format for downstream processing.

src/Captura.Windows/Imaging/Direct2D · high confidence

Added a set of new files in the Captura.Native namespace, including P/Invoke wrappers for user32.dll, gdi32.dll, and shell32.dll, along with supporting enums, structs, and helper classes. These additions provide the low-level Windows API access required for screen capture and cursor handling, such as GetCursorPos, DrawIconEx, and file operation flags.

src/Captura.Windows/Native · high confidence

Users can now upload videos directly to YouTube. This change introduces the necessary interfaces and implementations for YouTube authentication, upload requests, and privacy status handling within the Captura.Base and Captura.YouTube namespaces.

src/Captura.Base · high confidence

The Captura.Fakes module now provides fake implementations for key interfaces including IAudioPlayer, IFFmpegLogRepository, IFFmpegViewsProvider, IMessageProvider, IPreviewWindow, IRegionProvider, ISystemTray, IVideoSourcePicker, and IMainWindow. These fakes are registered in the dependency injection container via FakesModule, enabling headless or test environments to run without actual hardware or UI dependencies.

src/Captura.Fakes · high confidence

Users can now choose to save captured steps as individual PNG images in a folder or as a video file. The new ImageFolderWriter saves each frame as a separate PNG file, while the StepsVideoWriter allows for video output with a fixed frame rate of 1 FPS. Both are available as writer options in the application.

src/Captura.Core/Models/StepWriters · high confidence

The application now supports capturing video from webcams. This change introduces the \Captura.Webcam\ namespace, which includes components for enumerating video input devices, managing the DirectShow filter graph, and handling the preview and frame capture. Users can now select and record from webcam sources in addition to screen or window capture.

src/Captura.Windows/Webcam · high confidence

The recording engine now visualizes mouse interactions during screen capture. A new \StepsRecorder\ coordinates the rendering of \IRecordStep\ implementations, which include \KeyStep\ for keystrokes, \MouseClickStep\ for clicks (showing a circle with click count), \MouseDragBeginStep\ and \MouseDragStep\ for drag-and-drop actions (showing an arrow), and \ScrollStep\ for scroll wheel activity (showing an arrow indicating direction). These steps are merged or drawn as frames in the final video output.

src/Captura.MouseKeyHook/Steps · high confidence

Users can now encode audio using FFmpeg with support for AAC, MP3, Vorbis, and Opus formats. The new FFmpegAudioItem class provides a unified interface for selecting audio codecs and quality levels, allowing the application to generate appropriate FFmpeg command-line arguments for each format. This change introduces the FFmpegAudioArgsProvider delegate and FFmpegAudioWriter implementation to handle the actual audio writing process, enabling higher quality audio exports with configurable quality settings for each supported codec.

src/Captura.FFmpeg/Audio · high confidence

The application now uses a new FFmpegArgsBuilder to construct FFmpeg command-line arguments. This builder provides a fluent API for adding inputs (files, stdin, or named pipes) and outputs (files, stdout, or named pipes), each with methods to set video size, frame rate, format, and audio codecs. This change replaces the previous method of manually constructing FFmpeg argument strings, making the process of building FFmpeg commands more structured and maintainable.

src/Captura.FFmpeg/ArgsBuilder · high confidence

The Captura.Console project now provides a full command-line interface for recording, screenshots, and FFmpeg management. Users can start and stop recordings, take screenshots, list available audio/video sources, and install FFmpeg via the console. The console application supports options for video and audio quality, frame rate, delay, and file overwriting, mirroring the capabilities of the GUI. The console also handles DPI awareness and integrates with the core recording and screenshot models.

src/Captura.Console · high confidence

The console application now includes an AssemblyInfo.cs file that defines standard metadata such as the title, description, company, and version (0.0.0). Additionally, a launchSettings.json file has been added to configure default command-line arguments for development, specifically enabling screen capture with the 'mf' encoder, 20-second replay, and audio from speaker 0.

src/Captura.Console/Properties · high confidence

Added new classes to handle specific capture sources: FullScreenItem and ScreenItem for full-screen and individual screen recording, WindowItem for specific window capture (including a check for closed windows), and WaveItem for audio recording. These classes implement the IVideoItem and IAudioWriterItem interfaces, delegating to IPlatformServices to obtain the appropriate image or audio providers.

src/Screna/VideoItems · high confidence

Added new interfaces and classes to support a recent items feature: IRecentItem and IRecentList define the contract for individual items and their collection, while RecentAction encapsulates the name, icon, and click behavior for each action.

src/Captura.Base/Recent · high confidence

The application now uses a new \IKeyRecord\ interface and \KeyRecord\ implementation to represent captured keystrokes, including modifier states (Control, Shift, Alt) and timestamp. A \RepeatKeyRecord\ wrapper tracks repeated key presses, with an option to display or hide the repeat counter in the overlay. A \KeyRecords\ collection manages a fixed-size buffer of recent key records, and a \DummyKeyRecord\ provides a minimal implementation for testing or fallback scenarios.

src/Captura.MouseKeyHook/KeyRecord · high confidence

Added support for censoring, custom images, custom text, elapsed time, and mouse pointer overlays in the video capture module. Users can now configure and display these overlays during recording, with settings for positioning, sizing, opacity, and styling.

src/Screna/Overlays · high confidence

The application now uses a centralized service provider and a Ninject-based dependency injection system to manage application components. This change introduces a new \ServiceProvider\ class and associated interfaces (such as \IBinder\, \IModule\, and various service interfaces like \IAudioPlayer\ and \IClipboardService\) to handle object creation and lifecycle management, replacing previous instantiation patterns.

src/Captura.Base/Services · high confidence

The \src/Captura.Base/Images\ directory now contains a comprehensive set of new interfaces that define the core image handling contract for the application. This includes \IBitmapFrame\ and \IBitmapImage\ to represent raw and formatted image data, \IEditableFrame\ to support drawing operations (lines, shapes, text), and \IImageProvider\ to supply image data. Additionally, a \RepeatFrame\ class is introduced, which implements these interfaces to provide a reusable, singleton instance of an empty or placeholder frame, likely used to handle edge cases or default states in the imaging pipeline.

src/Captura.Base/Images · high confidence

Added new WPF presentation components to support image cropping and overlay positioning. This includes CroppingAdorner for interactive crop selection with draggable handles and a confirmation button, OverlayPositionAdorner for resizing and moving overlay elements, and a PuncturedRect shape to render the cropped region. These components provide the underlying UI controls for the image editor and overlay positioning features.

src/Captura/Presentation · high confidence

The video encoding module has been refactored to introduce a new set of FFmpeg-based video codecs. This includes support for hardware-accelerated encoding via NVIDIA NVenc (H.264 and HEVC) and Intel QuickSync (HEVC), as well as software-based encoders for H.264, VP8, VP9, and Xvid. Additionally, new streaming codecs have been added for Twitch and YouTube Live, alongside generic custom and temporary file codecs.

src/Captura.FFmpeg/Video/Codecs · high confidence

The FFmpeg video subsystem has been restructured with new implementations for video writing, replay recording, and GIF conversion. The FFmpegWriter class now handles video and audio streams via named pipes, supporting hardware encoders (NVENC, QSV) and custom codecs. A new FFmpegReplayWriter enables temporary file splitting and concatenation for replay functionality, while FFmpegGifConverter and FFmpegVideoConverter provide dedicated paths for GIF and standard video conversions. The FFmpegWriterProvider and StreamingWriterProvider expose these options to the UI, allowing users to select FFmpeg-based encoding for all video and streaming tasks.

src/Captura.FFmpeg/Video · high confidence

Added a new set of classes in the Captura.Windows.Gdi namespace to handle image rendering and editing. This includes DrawingFrame for frame data with timestamp support, GraphicsEditor for drawing operations (lines, shapes, text, images), and supporting types like DrawingFont, DrawingImage, and DrawingImagingSystem. The implementation uses System.Drawing (GDI+) to provide a concrete backend for the IEditableFrame and IBitmapFrame interfaces, enabling visual annotations and frame generation within the Windows application.

src/Captura.Windows/Imaging/Drawing · high confidence

The application now features dedicated pages for configuring audio sources and quality, managing FFmpeg codec and log settings, and viewing application about information. The Audio page allows users to select microphones and speakers, adjust recording quality, and configure separate file outputs. The FFmpeg section provides controls for downloading the binary, setting folder paths, resizing, and managing streaming keys for Twitch, YouTube, and custom URLs. Additionally, the About page displays version details, donation links, and access to crash logs and licenses.

src/Captura/Pages · high confidence

The application introduces several new ViewModels to support updated UI features. An AboutViewModel displays the current application version. An ExceptionViewModel provides a dialog to view and copy unhandled exception details to the clipboard. A new RegionSelectorViewModel manages the selection and resizing of screen regions, including keyboard-based movement and snapping capabilities. A ScreenPickerViewModel handles the display of screen thumbnails for selection. Finally, a TrimmerViewModel manages video trimming functionality, including playback controls and time selection.

src/Captura/ViewModels · high confidence

Added new classes for Windows screen capture, including DxgiTargetDeviceContext and GdiTargetDeviceContext to handle DirectX and GDI-based capture respectively. Introduced a new ITargetDeviceContext interface and related providers (RegionProvider, WindowProvider) that utilize these backends. Also added MouseCursor overlay support and ScreenShot functionality for capturing transparent window images.

src/Captura.Windows/Capture · high confidence

Users can now record from a webcam or capture audio without video. The new WebcamSourceProvider and WebcamVideoItem classes enable webcam recording, while the NoVideoSourceProvider and NoVideoItem classes allow for audio-only capture. Additionally, an AroundMouseSourceProvider and AroundMouseItem have been added to capture the region surrounding the mouse cursor, and an EditorWriter has been introduced to open images in an external editor after saving.

src/Captura.Core/Models · high confidence

The console application now supports a structured command-line interface with dedicated verbs for starting recordings, taking screenshots, managing FFmpeg, listing available sources, and uploading files. Users can control recording parameters such as cursor, keystrokes, audio sources, and output file paths directly from the command line. The interface also includes an upload command for services like Imgur and a list command to display available video and audio sources.

src/Captura.Console/CmdOptions · high confidence

The application now features dedicated UI windows for displaying error and exception details, including a simplified ErrorWindow and a detailed ExceptionWindow that allows users to view stack traces, inner exceptions, and other diagnostic information. Additionally, a new FFmpegDownloaderWindow has been introduced to manage the download and installation of FFmpeg dependencies, providing progress tracking and folder selection. These changes improve the user experience by offering clearer feedback on errors and a more robust way to manage external media dependencies.

src/Captura/Windows · high confidence

Users can now save screenshots to the system clipboard, to a local disk file, or upload them to a remote service. Each destination is represented by a new writer class (ClipboardWriter, DiskWriter, ImageUploadWriter) that implements IImageWriterItem, allowing the application to route captured images to different storage or sharing endpoints.

src/Captura.Core/Models/ImageWriterItems · high confidence

Added AroundMouseImageProvider to capture a screen region that follows the mouse cursor, with configurable margin and cursor inclusion. Added OverlayedImageProvider to apply a set of IOverlay elements to the captured image, supporting repeat frames and point transformation. These new providers expand the screen capture capabilities by enabling dynamic region tracking and compositing overlays.

src/Screna/ImageProviders · medium confidence

The application now uses a new \ILocalizationProvider\ interface and \LanguageManager\ to manage translations. This change introduces a JSON-based localization system that loads language files from a 'Languages' directory, falling back to English (en) if a specific translation is missing. Users will see the interface in their selected language, with the system automatically reverting to English for any untranslated strings.

src/Captura.Loc · high confidence

The application now includes new model classes to support audio playback, global hotkey listening, and system information gathering. The AudioPlayer class handles sound effects, while HotkeyListener and HotkeySetup manage global hotkey registration and event handling. Additionally, SingleInstanceManager ensures only one instance of the application runs, and SystemInfo provides detailed system diagnostics. These models are registered in the DI container via MainModule, enabling the UI and other components to use these capabilities.

src/Captura/Models · high confidence

The recent items list now uses a pluggable serialization system to persist different types of recent items. A new FileRecentItem model handles local file records, supporting actions like copy to clipboard, upload to Imgur, edit, trim, and delete. An UploadRecentItem model handles remote upload records, allowing users to open, copy, or delete uploaded links. Both are managed by a new RecentListRepository that loads and saves a JSON file, using separate serializers (FileRecentSerializer, UploadRecentSerializer) that can be extended for other item types.

src/Captura.Core/Models/Recents · high confidence

Added FileSaveNotification and ImageUploadNotification classes to manage user-facing status updates for file saving and image uploading processes. FileSaveNotification tracks saving, converting, and saved states, including a delete action for saved files. ImageUploadNotification tracks upload progress, success, and failure states, providing options to view or copy the upload link.

src/Captura.Core/Models/Notifications · high confidence

Added new ViewModels (CensorOverlayReactor, ImageOverlayReactor, PositionOverlayReactor, TextOverlayReactor, and WebcamOverlayReactor) that expose reactive properties for overlay configuration, including size, position, opacity, and styling. These classes bridge the existing overlay settings to the UI layer, enabling dynamic updates to overlay appearance and placement.

src/Captura/ViewModels/Overlays · high confidence

The application introduces a new settings infrastructure centered on a generic PropertyStore base class that manages key-value storage with change notification. This enables the addition of several new configuration models: VideoSettings for recording parameters (writer, quality, frame rate, webcam), AudioSettings for microphone/speaker capture and separate file output, TextOverlaySettings for font and color customization, MouseOverlaySettings for cursor visibility and styling, and PositionedOverlaySettings for alignment and coordinates. Additionally, ProxySettings are added to configure system or manual proxy connections, and StepsSettings control screen recording metadata. A new Alignment enum and PropertyStore implementation support these changes.

src/Captura.Base/Settings · high confidence

The application introduces dedicated settings models to configure various user-facing options. VisualSettings now manages the dark theme, accent color, window position, and language. WebcamOverlaySettings allows users to adjust the webcam overlay's opacity, scale, and position, including maintaining aspect ratio. TraySettings controls the system tray behavior, such as minimizing to the tray on startup, close, or capture start, and configures the left-click action. Additionally, new models are introduced for AroundMouse (margin), ScreenShot (image format, save targets, external editor), and Sound (audio feedback).

src/Captura.Core/Settings/Models · high confidence

The application introduces a new set of value converters in the \src/Captura/ValueConverters\ directory to support various UI updates. These include converters for mapping recorder states to button geometries and tray icons, converting time spans for display, handling language localization strings, and managing boolean/visibility states. This refactoring centralizes data binding logic for the interface, enabling features like dynamic icon updates based on recording status and improved time formatting.

src/Captura/ValueConverters · high confidence

The Screna application now includes dedicated providers for capturing the entire screen, specific monitors, selected regions, and individual windows. Each provider implements the IVideoSourceProvider interface, supporting CLI arguments, serialization, and dynamic selection via the UI. This change introduces a modular architecture for video sources, allowing users to choose their preferred capture method with consistent behavior across all options.

src/Screna/VideoSourceProviders · high confidence

The application introduces a suite of new custom WPF controls including ModernButton, ModernToggleButton, and ModernPasswordBox, which provide a consistent, icon-based visual style across the interface. A new CollapsedBar control offers a compact view for video and audio toggles, while the notification system is rebuilt with a dedicated NotificationStack and NotificationBalloon controls that support sliding animations, progress bars, and action buttons. Additionally, new controls for font selection, hotkey configuration, and screenshot previews are added to enhance user interaction and settings management.

src/Captura/Controls · high confidence

The ViewCore project now contains a broader set of view-models and supporting models, including FFmpegLog, HotkeyActor, RememberByName, and SoundsViewModelItem. This consolidation brings previously scattered UI logic and state management into a single core module, making it easier to maintain and extend features like hotkey handling, audio source selection, and FFmpeg logging.

src/Captura.ViewCore · high confidence

The core application logic has been restructured to use a Ninject-based dependency injection container. New classes like CoreModule, ApiKeys, and various model binders now explicitly register services such as image writers, video source providers, and update checkers. This change improves modularity and allows for easier testing and maintenance of the application's internal components.

src/Captura.Core · high confidence

The solution file (Captura.sln) has been moved to the src folder and updated to reflect the new project structure, including the Tests, Captura.Console, and other sub-projects. Additionally, new build configuration files (Directory.Build.props and PostBuild.targets) have been added to the src directory to manage C\# language versioning and post-build tasks like copying license files and organizing output libraries.

src · high confidence

A new AssemblyInfo.cs file was added to the Captura project's Properties folder, establishing default assembly metadata including the title, description, company, product name, copyright, and an initial version number of 0.0.0.

src/Captura/Properties · high confidence

The application now features a centralized error handling mechanism that catches unhandled exceptions from both the UI thread and the main application domain, logging crash details to a 'Crashes' directory and displaying a dedicated error window to the user. Additionally, the app startup process has been refactored to explicitly load core and view-core dependency injection modules, parse command-line arguments, and initialize the UI theme and language settings before the main window is shown.

src/Captura · high confidence

The audio subsystem has been completely redesigned, introducing a new set of interfaces (IAudioFileWriter, IAudioItem, IAudioProvider, IAudioSource, IAudioWriterItem) and a custom WaveFormat model to abstract audio handling. The NAudio library is now used to implement these interfaces, providing support for microphone and speaker capture, loopback audio, and audio mixing. This change also adds peak level monitoring for microphones and handles cases where default audio devices are not present.

src/Captura.NAudio · medium confidence

The application's configuration system has been refactored into a centralized \Settings\ class that groups related options (such as \Video\, \Audio\, \Tray\, and \MousePointerOverlay\) into dedicated sub-settings classes. This change introduces support for custom text and image overlays, configurable filename formats with environment variable substitution (e.g., \%computer%\, \%user%\), and a fallback mechanism for the output directory path. Users benefit from a more organized and persistent configuration structure that supports advanced features like clipboard copying of output paths and pre-start countdowns.

src/Captura.Core/Settings · high confidence

The FFmpeg module has been restructured to include a dedicated download and extraction workflow, allowing the application to automatically fetch and install FFmpeg binaries. This change introduces a new logging system that captures FFmpeg's standard error output, exposing command-line arguments and real-time progress updates to the user. Additionally, the module registers providers for video and audio writing, as well as video conversion, within the application's dependency injection container.

src/Captura.FFmpeg · high confidence

The hotkey system has been restructured to improve maintainability and localization. A new \Hotkey\ class now encapsulates the registration and unregistration of Windows hotkeys, while \HotKeyManager\ handles the collection of hotkeys, persistence to JSON, and dispatching of hotkey events to registered \IHotkeyActor\ implementations. The \Service\ class now provides localized descriptions for each \ServiceName\ (such as Recording, Pause, and various screenshot types), and the \ServiceName\ enum has been expanded to include new actions like \ShowMainWindow\ and \ToggleRegionPicker\.

src/Captura.Hotkeys · medium confidence

The mouse pointer is now rendered using a new set of classes (ColorPointerShape, MaskedColorPointerShape, MonochromePointerShape, etc.) that handle different pointer shape types (color, masked color, monochrome) via the Windows Desktop Duplication API. This change ensures the mouse pointer updates correctly and is drawn with proper transparency and color depth, fixing issues where the pointer might not update or appear incorrectly.

src/Captura.Windows/DesktopDuplication/MousePointer · high confidence

The application now uses a dedicated notification system featuring an INotification interface and a TextNotification implementation that supports primary and secondary text, progress tracking, and clickable actions. This provides a standardized way to display and interact with notifications within the core application.

Captura.Core, src/Captura.Base/Notification · medium confidence

Adds a new set of XAML resource dictionaries in the Themes folder, defining custom styles for WPF controls including Expander, Button, ToggleButton, and Slider. These templates implement a 'Modern' visual style with specific hover, pressed, and disabled states, alongside a virtualizing items control template to improve list performance.

src/Captura/Presentation/Themes · high confidence

The application now uses a new FFmpeg settings model that supports portable paths via the %CAPTURA\_PATH% environment variable, allowing codec and streaming configurations to be stored in the application directory rather than the local app data folder. This change introduces new settings classes (FFMpegSettings, FFmpegCodecSettings, X264Settings) that define default values for codec arguments, presets, and pixel formats, enabling more flexible and portable deployment of the capture functionality.

src/Captura.FFmpeg/Settings · medium confidence

The video capture and processing subsystem has been refactored to use new abstractions: IVideoSourceProvider for managing video sources, IVideoFileWriter for writing video files, IVideoConverter for post-processing, and IVideoWriterItem/IVideoWriterProvider for selecting writers. A new RecorderMode enum adds support for Steps and Replay recording modes alongside standard Video capture.

src/Captura.Base/Video · medium confidence

The audio subsystem has been redesigned to provide a dedicated AudioSourceViewModel that manages microphone and speaker selection, including live peak level monitoring that updates every 50ms. This new model allows users to see real-time audio levels for selected devices. The RecordingViewModel has been updated to integrate with this new audio model, ensuring that audio recording is enabled or disabled based on the new audio source configuration. Additionally, the UI now displays peak levels for the selected microphone and speaker, providing immediate visual feedback on audio input levels during recording.

src/Captura.ViewCore/ViewModels · high confidence

The Imgur upload functionality has been refactored to support dependency injection. A new \IImgurApiKeys\ interface is introduced to provide API credentials, and the \ImgurUploader\ class now implements the \IImageUploader\ interface. This change improves testability and modularity by decoupling the uploader from direct instantiation of settings and credentials.

src/Captura.Imgur · high confidence

The recording engine has been restructured with new classes to handle media capture more robustly. Audio recording is now managed by AudioRecorder and AudioFileWriter, supporting separate file output. Video recording utilizes a new Recorder class that writes at most one duplicate frame at a time to prevent stuttering, alongside a MultiRecorder to handle concurrent recording tasks. Utility classes like MultiDisposeFrame for memory management and Timing for frame rate management have been introduced to improve stability and reduce memory leaks.

src/Screna · high confidence

The monolithic build script has been split into separate, reusable Cake script files (apikeys, backup, choco, constants, version) to improve maintainability and separation of concerns. This refactoring introduces dedicated modules for managing API key injection, file backups, Chocolatey package creation, path constants, and version updates, allowing each build step to be tested and modified independently.

scripts · high confidence

The application's core logic for recording and screenshots has been restructured. The previous monolithic RecordingViewModel has been split into separate, focused classes: RecordingModel handles the core recording state and logic, TimerModel manages countdowns and durations, and ScreenShotModel handles screenshot capture and saving. This separation isolates responsibilities, making the codebase more modular and easier to maintain.

src/Captura.Core/ViewModels · high confidence

The application has removed the legacy \Properties/AssemblyInfo.cs\, \Properties/Settings.Designer.cs\, and \Properties/Settings.settings\ files. This eliminates the use of the .NET Framework 4.5 application settings system for storing user preferences such as output paths, cursor visibility, and UI theme colors, likely as part of a migration to a newer .NET version or project structure.

Properties · high confidence

The Presentation layer has been stripped of several legacy WPF user controls and settings pages, including About, ColorPickerBox, Home, NumericBox, Recent, RegionSelector, and all sub-pages under Settings (Appearance, Audio, Gif, ScreenShot). These files and their associated code-behind files have been deleted, indicating a removal of the old UI implementation in favor of a new architecture.

Presentation · high confidence

The desktop capture functionality in the Windows application has been replaced with a new implementation using the Windows Desktop Duplication API. This change introduces a new set of classes (including DesktopDuplicator, DuplCapture, and FrameGrabber) that handle screen capture, including support for multi-monitor setups and optional cursor rendering. This new provider is now the default method for capturing the desktop on Windows 8 and above, offering a more robust and modern approach to screen recording compared to the previous method.

src/Captura.Windows/DesktopDuplication · high confidence

The Windows capture module has been restructured to use the Windows Desktop Duplication API by default on Windows 8 and newer, with a new setting to force GDI capture if needed. This change introduces new services for clipboard, dialogs, and platform-specific window/screen enumeration, while also integrating Media Foundation for audio and webcam support.

src/Captura.Windows · medium confidence

Added test fixtures for UI automation and mocking; Added unit tests for core recording and utility components.

The project has been refactored from the legacy .csproj format to the modern SDK-style, enabling cross-platform compatibility via .NET Standard 2.0 for core libraries and .NET Framework 4.7.2 for UI and console applications. This migration introduces explicit package references for dependencies such as Newtonsoft.Json (13.0.1), NAudio (1.10.0), and Ninject (3.3.4), while removing the single-file project structure in favor of a modular architecture.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 57 → 55 (-1.8)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 58 → 56 (-2.7)
• Architecture 98 → 98 (+0.0)
• Maturity 66 → 66 (+0.0)
• Readiness 44 → 44 (+0.0)
• Security 96 → 81 (-14.6)

• Bounded contexts not declared
• Duplicated block (14 lines × 2) (src/Captura.Windows/MediaFoundation/MfAudioWriter.cs)
• Duplicated block (16 lines × 2) (src/Captura.FFmpeg/Video/FFmpegWriterProvider.cs)
• Duplicated block (6 lines × 2) (src/Captura.MouseKeyHook/ScrollOverlay.cs)
• LLM evaluation failed
• LLM evaluation failed
• No exposed public API
• Test runner surfaced no tests
• The interface IVideoWriterItem is used as a parameter name in multiple methods, but the parameter name itself is inconsistent (M vs WriterItem).
• dormant codebase — no living knowledge left to concentrate

• Documentation: no installation or build instructions (README.md)
• Documentation: no licence statement (README.md)
• Duplicated block (10 lines × 2) (src/Captura.MouseKeyHook/KeyOverlay.cs)
• Duplicated block (17 lines × 2) (src/Captura.FFmpeg/Video/FFmpegWriterProvider.cs)
• Duplicated block (18 lines × 2) (src/Captura.Windows/MediaFoundation/MfAudioWriter.cs)
• Duplicated block (6 lines × 2) (src/Captura.MouseKeyHook/ScrollOverlay.cs)
• Duplicated block (9 lines × 2) (src/Captura.Windows/Imaging/Drawing/GraphicsExtensions.cs)
• Fixed-sleep synchronisation: StartSharpAvi (src/Tests/ConsoleStartTests.cs)
• Inconsistent naming for localization-related members: LanguageManager uses the plural noun AvailableCultures to expose localization data, while LanguageFields uses singular nouns (e.g., TrayIcon, Notifications) for specific string keys. This mixes a collection-oriented name with individual field names without a clear semantic distinction in the naming convention itself.
• MethodTooLong: OverlayPositionAdorner.HandleDrag (src/Captura/Presentation/OverlayPositionAdorner.cs)
• No SBOM
• No artifact signing
• No build provenance
• No dependency advisory monitoring
• WriteOnlyPrivateField (src/Captura/Models/SingleInstanceManager.cs)
• WriteOnlyPrivateField (src/Captura/Models/SingleInstanceManager.cs)
• XML-doc coverage: Captura (src/Captura/Captura.csproj)
• XML-doc coverage: Captura.Audio (src/Captura.Audio/Captura.Audio.csproj)
• XML-doc coverage: Captura.Base (src/Captura.Base/Captura.Base.csproj)
• XML-doc coverage: Captura.Console (src/Captura.Console/Captura.Console.csproj)
• …and 14 more

• Unchanged — 2 containers · 1 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

MathewSachin/Captura was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.