Knight's Order Block Processing Pipeline

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Conventional block processing methods in video encoding pipelines face delays due to dependencies between blocks, leading to inefficient data processing and increased memory storage requirements, as blocks are processed in scan order, causing downstream stages to wait for upstream stages to complete operations on neighboring blocks.

Innovation Solution

Implementing a 'knight's order' processing method where blocks are input and processed in a pipeline according to a specific order that provides spacing between adjacent blocks, allowing for feedback from downstream stages to upstream stages, and using quadrow constraints to maintain locality of neighbor data, facilitating local caching and reducing memory access.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Productivity

If blocks are processed in scan order in a block processing pipeline, then the processing follows a simple sequential pattern, but downstream stages must wait for upstream stages to complete operations on neighboring blocks, causing delays

Engineering Contradiction:
Improveprocessing efficiencyVSAvoidwaiting delay
Core Design Contradiction:
ProductivityVSLoss of time

Solution Approach 1:

The patent applies inversion by reversing the conventional scan order (left-to-right, top-to-bottom) to a reverse scan order (right-to-left, bottom-to-top). This allows downstream stages to access previously processed neighboring blocks without waiting, as those blocks have already been processed in the reverse sequence, thereby eliminating pipeline stalls and improving throughput.

Inventive Principle:
Principle #13The other way round (Inversion)

2Device complexity

If blocks are processed in scan order, then the processing sequence is simple to implement, but memory storage requirements increase to store intermediate results of neighboring blocks

Engineering Contradiction:
Improveprocessing sequence complexityVSAvoidmemory storage requirement
Core Design Contradiction:
Device complexityVSQuantity of substance

Solution Approach 1:

By processing blocks in reverse scan order, the patent eliminates the need to store intermediate results of neighboring blocks in memory, as they are already processed and available when needed. This reduces memory storage requirements while maintaining a simple processing sequence that follows the same sequential logic, just in reverse direction.

Inventive Principle:
Principle #13The other way round (Inversion)

3Productivity

If conventional scan order processing is used, then adjacent blocks are processed consecutively, but this causes dependencies where downstream stages must wait for upstream stages

Engineering Contradiction:
Improvepipeline throughputVSAvoiddata availability for dependent operations
Core Design Contradiction:
ProductivityVSReliability

Solution Approach 1:

The reverse scan order ensures that when a block reaches a downstream stage, its neighboring blocks have already been processed by upstream stages, guaranteeing data availability for dependent operations. This eliminates pipeline stalls and ensures reliable data flow throughout the processing pipeline.

Inventive Principle:
Principle #13The other way round (Inversion)

Data Source

PatentUS9218639B2Processing order in block processing pipelines
Publication Date: 2015.12.22 APPLE INC
  • US9218639B2 patent drawing
  • US9218639B2 patent drawing
  • US9218639B2 patent drawing

AI summary

A knight's order processing method for block processing pipelines in which the next block input to the pipeline is taken from the row below and one or more columns to the left in the frame. The knight's order method may provide spacing between adjacent blocks in the pipeline to facilitate feedback of data from a downstream stage to an upstream stage. The rows of blocks in the input frame may be divided into sets of rows that constrain the knight's order method to maintain locality of neighbor block data. Invalid blocks may be input to the pipeline at the left of the first set of rows and at the right of the last set of rows, and the sets of rows may be treated as if they are horizontally arranged rather than vertically arranged, to maintain continuity of the knight's order algorithm.