How ggarra13/mrv2 works
Main Components
• Core Playback Engine – Include the custom media processing layer (tlRender integration) and media I/O (handling movie files, image sequences, audio, etc.). This component interacts with external libraries like FFmpeg (compiled with different license modes) and image format handlers.
• User Interface Layer – Capture the UI framework areas, such as:
– mrvWidgets: for all custom UI widgets (buttons, tables, panels, menus).
– mrvUI: which binds everything together, including the main window, docking, and panelling.
– mrvPanels: dedicated to specific UI panels such as annotations, media info, timelines, logs, preferences, etc.
– mrvFLU/mrvFl/mrvFlmm: these modules integrate with the underlying FLTK-like libraries and help build the GUI.
• Plugin & Python API – Highlight the role of the Python API (src/mrvPy and associated demos) that allows for extending functionality and scripting. Emphasize the demo and plug-in directories.
• Network & Communication Modules – Include mrvNetwork, which handles client/server communication, file model synchronization, and other network-based interactions.
• Auxiliary Tools & Build Scripts – Although not part of runtime architecture, include a representation of the build system (CMake configuration scripts in the cmake/ directory, runme.sh family scripts), translation tools (src/po and bin/po scripts), and packaging utilities.
• External Dependencies – Represent external tools like FFmpeg (with toggle for GPL vs. LGPL builds) and integrated third-party libraries (as built via custom cmake modules) and also the core dependency on tlRender.
Establish Relationships and Interactions
• That the plugin system (Python API) acts as an extensibility point: plugins may intercept editing events or augment the UI functionality.
• That the build system (CMake plus shell scripts) orchestrates the integration of all submodules, linking libraries like mrvCore, mrvApp, mrvDraw, etc., and also packaging them into the final executable.
• Communication between the network layer and the UI/core components, where network messages (for file paths, timelines, etc.) flow from mrvNetwork modules to relevant components.
Architectural Patterns and Design Principles
• A layered architecture is visible: lower-level core processing and media handling libraries (mrvCore, mrvDraw, mrvNetwork) feed into higher-level application logic (mrvApp, mrvUI) which then interface with the user via the widget layers (mrvWidgets, mrvPanels).
• There is also a clear separation of concerns: dedicated modules for media, UI, networking, and configuration (including translation and packaging).
• Integration with continuous integration workflows, and multiple platform-specific build scripts, also suggests that the platform abstraction and portability are important architectural concerns.
Relevant Technologies, Frameworks, and Libraries
• Mention C++20 as the language and CMake as the build system.
• Third-party libraries such as FFmpeg, OpenEXR, and the custom tlRender engine.
• Use of FLTK (or a derivative like pyFLTK/mrvFLU) for building the GUI.
• Python’s role within the plugin system and for automation scripts.
• That translations (via gettext) and documentation (using Doxygen and Sphinx) are part of the ecosystem.