Video Encoder Scheduler for Parallel Chunk Processing

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing video coding methods face inefficiencies in processor utilization and synchronization overhead due to operation serialization and data dependencies, particularly in slice-based and function-based threading approaches, which lead to underutilization of resources and unnecessary stalling.

Innovation Solution

A method for scheduling data processing that determines a coding order for data blocks, merging blocks with similar dependencies and scheduling independent blocks for parallel processing using a scheduler and multiple processors, while managing dependencies to optimize resource utilization and reduce overhead.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Productivity

If slice-based threading is used to process multiple slices in parallel, then processor utilization is improved, but threads must wait for completion of all threads before proceeding to the next picture, resulting in underutilized computational resources and significant wait times

Engineering Contradiction:
Improveprocessor utilizationVSAvoidwait times
Core Design Contradiction:
ProductivityVSLoss of time

Solution Approach 1:

The patent segments the video data into smaller units called chunks, which can be processed independently. This allows threads to process chunks without waiting for the entire picture to be processed, eliminating the serialization bottleneck in slice-based threading while maintaining parallel processing efficiency.

Inventive Principle:
Principle #1Segmentation

2Productivity

If function-based threading is used to process stages in a pipeline fashion, then processing stages can be allocated to processors, but the number of stages limits scalability and significant data dependencies among stages result in synchronization overhead

Engineering Contradiction:
Improveprocessing throughputVSAvoidsynchronization overhead
Core Design Contradiction:
ProductivityVSDevice complexity

Solution Approach 1:

The patent divides the video processing task into independent chunks that can be processed in any order, eliminating the rigid pipeline stages. This segmentation approach reduces synchronization overhead by removing data dependencies between stages while maintaining processing throughput.

Inventive Principle:
Principle #1Segmentation

3Productivity

If picture-based threading is used to process multiple pictures in parallel, then independent processing is achieved, but the approach is coarse grained in synchronization among threads, which may incur unnecessary stalling of threads

Engineering Contradiction:
Improveparallel processing capabilityVSAvoidthread stalling
Core Design Contradiction:
ProductivityVSLoss of time

Solution Approach 1:

The patent segments pictures into smaller chunks that can be processed independently and in any order. This fine-grained segmentation allows threads to process smaller units without waiting for entire pictures, reducing thread stalling while maintaining parallel processing capability.

Inventive Principle:
Principle #1Segmentation

Data Source

PatentUS8340194B2High-yield multi-threading method and apparatus for video encoders/transcoders/decoders with dynamic video reordering and multi-level video coding dependency management
Publication Date: 2012.12.25 APPLE INC
  • US8340194B2 patent drawing
  • US8340194B2 patent drawing
  • US8340194B2 patent drawing

AI summary

Disclosed is an exemplary video coder and video coding method according to an embodiment of the present invention. The exemplary video coder includes a scheduler, a plurality of processors and a multiplexer. The scheduler can examine processing units in an input buffer to determine an order for the processing unit to be coded by a processor. If the processing unit under examination depends on a processing unit not yet processed, the processing unit under examination can be merged with other processing units, if any, that share a similar dependency. If the processing unit under examination does not depend on any processing units not yet processed, it can be sent to a next available processor for coding. When a processing unit is sent to a processor, any merged processing units that depend on sent processing unit can also be sent to a next available processor.