Inspiration
A viewing preference is only useful while the player continues to honor it. A title-level warning cannot identify the exact scene that needs attention. A skipped scene can remove the information that makes the story understandable. After an interruption, restoring a timestamp alone cannot establish that the intended captions, audio selection and media edition survived.
FireShield brings these concerns into one publisher-controlled workflow. Our goal is a TV experience that preserves a viewer's place, their context and the editorial decisions made for that exact media edition.
What it does
FireShield connects three technologies:
Visual screening analyzes decoded SDR frames for luminance flashes, saturated-red transitions and spatial patterns. It produces candidate intervals for editorial review. The operator can inspect the interval, its measured signals and the surrounding subtitle cues. A finding requires a decision; zero findings does not constitute a safety certificate.
Synaptic Shield carries approved story context into the player. An editor reviews a note grounded in the publisher's WebVTT cues and approves the release. An Ed25519 contract binds the source revision, approved intervals, context and rendition playlist identity. In the native Kotlin player, the gate can pause and blank the surface before an interval, present the approved context, and verify an asynchronous bypass into the calm portion of the scene.
FireTrace checks continuity after interruption. It compares an atomic checkpoint with observed player position, caption selection, audio selection, presentation mode and playlist identity. A mismatch holds playback paused and blanked and produces a bounded diagnostic receipt. The incident console exposes the mismatch and runs a reference-model retest of that failure class.
The result is a working publisher operator console and a native Media3 TV player, connected by explicit review decisions and verifiable media identities.
How we built it
The backend uses Python and NumPy for deterministic frame analysis, FFmpeg for headless decoding and HLS packaging, WebVTT for context grounding, and the cryptography library for Ed25519 signatures. The browser console connects catalog ingestion, screening, context approval, editorial review, release publication and incident investigation.
The TV application uses Kotlin and AndroidX Media3 ExoPlayer. Its gate keeps asynchronous seek completion separate from permission to resume. FireTrace uses atomic checkpoints and bounded readiness checks before evaluating recovery. The release build ignores external debug trust-root overrides.
The exact-media demonstration encodes a publisher-owned synthetic scene, screens its actual segment bytes and signs its matching playlist. The exported native handoff contains the media, subtitles, contract and public verification data. It contains no signing seed. A dedicated Android TV emulator exercises the native path. Fault injection is confined to the debug harness.
Our demonstration runs without AWS credentials. Subtitle extraction reports that no language model was invoked. The optional Bedrock adapter remains outside the verified demonstration.
Challenges we worked through
The difficult part was maintaining one identity across the workflow. Screening a reference array is insufficient evidence for an unrelated encoded playlist. We added an exact-media path and checks that reject media changes after import or screening.
Native recovery also required more than a ready callback. Seek confirmation, track availability, decoder readiness and a rendered-frame signal arrive separately. We introduced a bounded recovery gate, then tested successful recreation, deliberately dropped captions and a stale edition.
We also separated the operator's inspection surface from the TV viewer's controls. The console exposes detailed evidence. The native player presents the approved context and a clear action to skip the moment, while diagnostic controls remain available for inspection.
Accomplishments we are proud of
Three researched components now form a concrete prototype spanning media analysis, editorial publication and native playback continuity. The encoded-media path binds screening and publication to actual bytes instead of substituting a different fixture. The project includes 113 passing Python tests and a native Kotlin test suite, with revision-specific build and emulator evidence on GitHub. The demonstration includes working behavior and controlled failure cases, with original captures and fresh incident data. The source is public under Apache 2.0, with setup instructions and reproducible verification tools.
What we learned
We learned to define what each signal proves. A valid signature establishes contract authenticity under a trusted key. A matching playlist identifies an edition. A selected caption track does not establish that every intended caption was rendered. A model retest does not establish that a native defect was repaired.
Making those distinctions explicit improved both the engineering and the product. It gave us clearer states, stronger checks and a more credible demonstration.
What's next
Our next steps are physical Fire TV testing, a broader authorized-media evaluation set, more complete caption and audio presentation checks, production key distribution, and refinement of remote-first viewer interactions. The prototype currently targets publisher-controlled media and applications. It does not inspect protected third-party streaming apps and makes no medical or broadcast-certification claim.
Test the prototype
Source and setup: https://github.com/Syedsaadhhh/FireShield
APK, original native recordings, receipts and run metadata: https://github.com/Syedsaadhhh/FireShield/releases/tag/prototype-2026-10-23
For the operator console, use Python 3.10 or later, install requirements-demo.txt, then run python api_adapter.py and open http://127.0.0.1:8000/operator. Install FFmpeg on PATH for the actual encoded-media drill. No AWS credentials are required. The console is a local demo tenant, not a production identity service.
For native playback, install the released debug APK on a dedicated Android TV emulator. The source includes build instructions and controlled fault-verification utilities. The demo uses owned synthetic media; hazardous screening fixtures are analyzed headlessly and are not previewed in the recording.
Verification evidence records 113 Python tests and 25 Kotlin tests, plus native playback, recovery, caption-loss and stale-edition cases. The exact-media drill links the screened source, signed release and fresh native incident to the same playlist identity. These results establish controlled prototype behavior, not physical Fire TV performance or general screening accuracy.
AI assistance and runtime boundaries
AI-assisted development supported research synthesis, implementation, debugging, testing and preparation of the demonstration. The demonstrated context path extracts subtitle-grounded text without calling a language model (model_invoked=false). The optional Bedrock adapter is not presented as a live integration. Screening boundaries and release approval are not delegated to a language model.
Log in or sign up for Devpost to join the conversation.