Video Frame Rendering Timing Control via Kernel Interrupts

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Computing devices with mobile operating systems face challenges in timely video frame rendering, leading to frame jumps due to processor overload and delays in render function calls from the application layer to the kernel layer, resulting in non-smooth video playback.

Innovation Solution

A method involving initializing a system reference time, waiting for an interrupt signal, and determining whether to update the reference time based on render function calls from the application layer, with video frames rendered in the kernel layer according to the determined time, using a hybrid approach that combines tunnel mode and user-space API rendering functions to control timing.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If the processor handles multiple computing threads simultaneously, then the device can run various applications, but the video frame rendering timing becomes inaccurate causing frame jumps

Engineering Contradiction:
Improveapplication running capabilityVSAvoidvideo frame rendering timing accuracy
Core Design Contradiction:
Adaptability or versatilityVSManufacturing precision

Solution Approach 1:

The patent segments the video rendering process into distinct phases: tunnel mode rendering for initial frame processing and user-space API rendering for subsequent frames. This segmentation allows different rendering strategies to be applied at different times, ensuring timing accuracy is maintained even when multiple applications are running. The tunnel mode operates in kernel space with direct timing control, while user-space rendering handles flexibility requirements.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent implements dynamic switching between tunnel mode and user-space API rendering based on timing conditions. When the application can meet critical timing requirements, user-space rendering is used for flexibility; when timing constraints cannot be met, the system switches to tunnel mode to ensure accurate frame rendering timing. This dynamic adaptation resolves the contradiction between versatility and timing precision.

Inventive Principle:
Principle #15Dynamics

2Adaptability or versatility

If the application layer sends render function calls to the kernel layer, then the application has flexibility in video processing, but the rendering delays cause frames to miss their timing requirements

Engineering Contradiction:
Improvevideo processing flexibilityVSAvoidrender function call delay
Core Design Contradiction:
Adaptability or versatilityVSLoss of time

Solution Approach 1:

The patent performs preliminary rendering actions in tunnel mode before the application layer processes video frames. By pre-rendering frames in the kernel space with direct timing control, the system ensures that timing-critical operations complete before user-space processing begins. This preliminary action prevents timing delays caused by application layer processing while maintaining flexibility for non-critical operations.

Inventive Principle:
Principle #10Preliminary action

Solution Approach 2:

The patent introduces an intermediary timing control mechanism that coordinates between the application layer and kernel layer. The tunnel mode acts as an intermediary that buffers and synchronizes rendering operations, allowing the application layer to operate with flexibility while the kernel layer maintains precise timing control. This intermediary layer resolves the timing delay issue by decoupling the flexible application processing from the time-critical rendering operations.

Inventive Principle:
Principle #24Intermediary (Mediator)

3Productivity

If the processor decodes and renders video frames at high speed, then smooth video playback is achieved, but the processor becomes overloaded and cannot meet rendering deadlines

Engineering Contradiction:
Improvevideo frame processing speedVSAvoidrendering deadline fulfillment
Core Design Contradiction:
ProductivityVSReliability

Solution Approach 1:

The patent segments video frame processing into two pathways: tunnel mode rendering for frames requiring strict deadline fulfillment, and user-space API rendering for frames with more flexible timing requirements. This segmentation allows the system to maintain high overall processing speed while ensuring that critical frames meet their deadlines. The tunnel mode handles time-sensitive frames with dedicated kernel-space resources, preventing processor overload from affecting deadline-critical operations.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent applies different quality levels of processing to different video frames based on their timing requirements. Frames that must meet strict deadlines receive premium processing through tunnel mode with direct kernel-space access and optimized rendering paths. Other frames can use standard user-space rendering with less intensive processing. This local differentiation of processing quality allows the system to maintain high productivity overall while ensuring reliability for critical frames.

Inventive Principle:
Principle #3Local quality

Data Source

PatentUS9564108B2Video frame processing on a mobile operating system
Publication Date: 2017.02.07 AMLOGIC
  • US9564108B2 patent drawing
  • US9564108B2 patent drawing
  • US9564108B2 patent drawing

AI summary

A method for rendering video frames by a computing device having a software stack with an application layer and a kernel layer comprises various steps. First, a system reference time is initialized. A triggering of an interrupt signal in the kernel layer is waited for. Next, it is determined whether to update the system reference time as a function of a render function from the application layer. A next video frame in the kernel layer is rendered by the computing device as a function of the determined system reference time and the next video frame. The steps after the initializing step and starting at the waiting step are recursively performed.