CONTEXT-BASED RESHAPING ALGORITHMS FOR ENCODING VIDEO DATA

Abstract

Systems and methods for context-based encoding of video data using reshaping algorithms. One method includes receiving the video data, the video data composed of a plurality of image frames, each image frame including a plurality of pixel blocks. The method includes determining, for each pixel block, a luma bin index, determining, for each luma bin, a banding risk value, and determining Gaussian function parameters based on the banding risk value. The method includes generating a differential reshaping function using the Gaussian function parameters, computing a luma-based forward reshaping function based on the differential reshaping function, and generating an output image for each image frame by applying the luma-based forward reshaping function to the respective image frame.

Description

2. FIELD OF THE DISCLOSURE

This application relates generally to systems and methods of encoding high dynamic range (HDR) video content using reshaping algorithms.

3. BACKGROUND

As used herein, the term ‘dynamic range’ (DR) may relate to a capability of the human visual system (HVS) to perceive a range of intensity (e.g., luminance, luma) in an image, e.g., from darkest grays (blacks) to brightest whites (highlights). In this sense, DR relates to a ‘scene-referred’ intensity. DR may also relate to the ability of a display device to adequately or approximately render an intensity range of a particular breadth. In this sense, DR relates to a ‘display-referred’ intensity. Unless a particular sense is explicitly specified to have particular significance at any point in the description herein, it should be inferred that the term may be used in either sense, e.g. interchangeably.

As used herein, the term high dynamic range (HDR) relates to a DR breadth that spans some 14-15 orders of magnitude of the human visual system (HVS). In practice, the DR over which a human may simultaneously perceive an extensive breadth in intensity range may be somewhat truncated, in relation to HDR. As used herein, the terms enhanced dynamic range (EDR) or visual dynamic range (VDR) may individually or interchangeably relate to the DR that is perceivable within a scene or image by a human visual system (HVS) that includes eye movements, allowing for some light adaptation changes across the scene or image.

In practice, images comprise one or more color components (e.g., luma Y and chroma Cb and Cr) wherein each color component is represented by a precision of n-bits per pixel (e.g., n=8). Using linear luminance coding, images where n<8 are considered images of standard dynamic range, while images where n>8 (e.g., color 24-bit JPEG images) may be considered images of enhanced dynamic range. EDR and HDR images may also be stored and distributed using high-precision (e.g., 16-bit) floating-point formats, such as the OpenEXR file format developed by Industrial Light and Magic.

As used herein, the term “metadata” relates to any auxiliary information that is transmitted as part of the coded bitstream and assists a decoder to render a decoded image. Such metadata may include, but are not limited to, color space or gamut information, reference display parameters, and auxiliary signal parameters, as those described herein.

Most consumer desktop displays currently support luminance of 200 to 300 cd/m² or nits. Most consumer HDTVs range from 300 to 500 nits with new models reaching 1000 nits (cd/m²). Such conventional displays thus typify a lower dynamic range (LDR), also referred to as a standard dynamic range (SDR), in relation to HDR or EDR. As the availability of HDR content grows due to advances in both capture equipment (e.g., cameras) and HDR displays (e.g., the PRM-4200 professional reference monitor from Dolby Laboratories), HDR content may be color graded and displayed on HDR displays that support higher dynamic ranges (e.g., from 1,000 nits to 5,000 nits or more).

Gadgil, Neeraj J. et al.: “Efficient Banding-Alleviating Inverse Tone Mapping for High Dynamic Range Video”, 53^rd Asilomar Conference on Signals, Systems, and Computers, IEEE, 3 Nov. 2019, pages 1885-1889, XP033750575, discloses an approach to constructing an HDR image from a standard dynamic range (SDR) image is to use inverse tone mapping (iTM). However, it can create or amplify visual artifacts such as banding/false contouring in the resulting HDR images. To address this, a novel method is proposed to efficiently construct iTM to reduce banding in the highlight regions of HDR images. The proposed approach uses a given iTM curve to estimate the banding-risk in each luminance range, based on the input SDR image properties. Then, the risk measure is used to adjust the local slope of the iTM to avoid banding in the resulting HDR images. Experimental results exhibit that the proposed method is highly effective in reducing banding in the HDR images.

WO 2020/033573 A1 discloses methods and systems for reducing banding artifacts when displaying high-dynamic-range images. Given an input image in a first dynamic range, and an input backward reshaping function mapping codewords from the first dynamic range to a second dynamic range, wherein the second dynamic range is equal or higher than the first dynamic range, statistical data based on the input image and the input backward reshaping function are generated to estimate the risk of banding artifacts in a target image in the second dynamic range generated by applying the input backward reshaping function to the input image. Separate banding alleviation algorithms are applied in the darks and highlights parts of the first dynamic range to generate a modified backward reshaping function, which when applied to the input image to generate the target image eliminates or reduces banding in the target image.

WO 2020/072651 A1 discloses methods and systems for reducing banding artifacts when displaying high-dynamic-range images reconstructed from coded reshaped images. Given an input image in a high dynamic range (HDR) which is mapped to a second image in a second dynamic range, banding artifacts in a reconstructed HDR image generated using the second image are reduced by a) in darks and mid-tone regions of the input image, adding noise to the input image before being mapped to the second image, and b) in highlights regions of the input image, modifying an input backward reshaping function, wherein the modified backward reshaping function will be used by a decoder to map a decoded version of the second image to the reconstructed HDR image. An example noise generation technique using simulated film-grain noise is provided.

EP 3 203 442 A1 discloses a processor for signal reshaping that receives an input image with an input bit depth. Block-based standard deviations are computed. The input codewords are divided into codeword bins and each bin is assigned a standard deviation value. For each bin, a standard deviation to bit-depth function is applied to the bin values to generate minimal bit depth values for each codeword bin. An output codeword mapping function is generated based on the input bit depth, a target bit depth, and the minimal bit depth values. The codeword mapping function is applied to the input image to generate an output image in the target bit depth.

BRIEF SUMMARY OF THE DISCLOSURE

The invention is defined by the independent claims. The dependent claims concern optional features of some embodiments of the invention. In growing uses for HDR content, such as cloud-based gaming, there is a need to transmit HDR video data to target display devices (e.g., a TV) using encoding, such as 8-bit base layer (BL) that has minimum latency. For cloud gaming cases specifically, 8-bit advanced video coding (AVC) BL may be needed. Accordingly, encoders for such cases need to transfer HDR content to a lower bit-depth-domain and provide metadata for the receiving decoder such that the decoder reconstructs the HDR content from the decompressed BL.

Additionally, for cloud-based gaming and other real-time uses of HDR content, there is a need for low latency and lightweight computations. Accordingly, feature-based efficient reshaping algorithms for converting HDR content to BL and generating backwards reshaping metadata for reconstructing the HDR content may be used. Bitstreams may be generated that allows for an eight-piece polynomial function for luma reshaping and two-piece polynomials for chroma reshaping. This avoids heavy computation, reducing latency.

Additionally, 8-bit BL may experience banding artifacts in the reconstructed HDR content. Banding generally exhibits in the smoother regions of an image. The visibility of banding is dependent on how large (e.g., how many pixels) the affected region is relative to the image as a whole. By having a content-adaptive non-linear reshaping function, banding is minimized.

Proposed systems and methods collect and use block-based image statistics, such as the standard deviation and histogram image statistics in the luma channel. These statistics are used to construct an image-feature as a function of discrete luma codeword-ranges (known as “bins”). The value of this binwise-feature indicates which bin has the greatest need for codewords. The identified bin is assigned as the “peak” bin for a functional curve (e.g., a Gaussian curve, a parabolic curve, or the like) that encompasses the entire luma codeword range. The shape of the curve is determined by the relative values of the feature. This functional curve is used to compute a forward reshaping function for the image. The forward reshaping function is used to compress the HDR video data, as described in more detail below. Additionally, to improve banding reduction performance, synthetically-generated film-grain noise of a fixed maximum strength can be injected to the HDR luma channel prior to reshaping. Accordingly, the proposed encoding framework is computationally efficient to meet the low delay requirement and is effective in reducing banding in the reconstructed HDR content.

Various aspects of the present disclosure relate to devices, systems, and methods for encoding video data using reshaping algorithms. While certain embodiments are directed to HDR video data, video data may also include Standard Dynamic Range (SDR) video data and other User Generated Content (UGC), such as gaming content.

In one exemplary aspect of the present disclosure, there is provided a video delivery system for context-based encoding of video data. The delivery system comprises a processor to perform encoding of video data. The processor is configured to receive the video data, the video data composed of a plurality of image frames, each image frame including a plurality of pixel blocks. The processor is configured to determine, for each pixel block, a luma bin index, determine, for each luma bin, a banding risk value, and determine Gaussian function parameters based on the banding risk value. The processor is configured to generate a differential reshaping function using the Gaussian function parameters, compute a luma-based forward reshaping function based on the differential reshaping function, and generate an output image for each image frame by applying the luma-based forward reshaping function to the respective image frame.

In another exemplary aspect of the present disclosure, there is provided a method for context-based encoding of video data. The method includes receiving the video data, the video data composed of a plurality of image frames, each image frame including a plurality of pixel blocks. The method includes determining, for each pixel block, a luma bin index, determining, for each luma bin, a banding risk value, and determining Gaussian function parameters based on the banding risk value. The method includes generating a differential reshaping function using the Gaussian function parameters, computing a luma-based forward reshaping function based on the differential reshaping function, and generating an output image for each image frame by applying the luma-based forward reshaping function to the respective image frame.

In another exemplary aspect of the present disclosure, there is provided a non-transitory computer-readable medium storing instructions that, when executed by a processor of a video delivery system, cause the video delivery system to perform operations comprising receiving the video data, the video data composed of a plurality of image frames, each image frame including a plurality of pixel blocks, determining, for each pixel block, a luma bin index, determining, for each luma bin, a banding risk value, determining Gaussian function parameters based on the banding risk value, generating a differential reshaping function using the Gaussian function parameters, computing a luma-based forward reshaping function based on the differential reshaping function, and generating an output image for each image frame by applying the luma-based forward reshaping function to the respective image frame.

In this manner, various aspects of the present disclosure provide for the display of images having a high dynamic range and high resolution, and effect improvements in at least the technical fields of image projection, holography, signal processing, and the like.

DESCRIPTION OF THE DRAWINGS

These and other more detailed and specific features of various embodiments are more fully disclosed in the following description, reference being had to the accompanying drawings, in which:

FIG. 1 depicts an example process for a video delivery pipeline.

FIG. 2 depicts an example block diagram of an encoder.

FIG. 3 depicts an example block diagram of a decoder.

FIG. 4 depicts an example Gaussian function.

FIGS. 5A-5D depict example forward reshaping functions and corresponding differentials.

FIGS. 6A-6F depict example forward reshaping functions and corresponding differentials.

FIG. 7 depicts an example method performed by the encoder of FIG. 2.

FIG. 8A and FIG. 8B depict example graphs comparing pixelwise and block-based image statistics.

FIG. 9 depicts an example Gaussian function with a floor value.

FIG. 10 depicts an example forward reshaping function using a Gaussian curve differential.

FIG. 11 depicts an example luma 8-piece first order polynomial-fit.

FIG. 12 depicts an example graph comparing a polyfit backwards look-up table to a compute-point backwards look-up table.

FIG. 13 depicts an example graph illustrating absolute error of a backward look-up table using an 8-piece 1st order polynomial.

FIG. 14 depicts an example graph comparing a revertible forward look-up table compared to a compute-point forward look-up table.

FIG. 15 depicts an example graph showing revertability of the revertible forward look-up table of FIG. 14.

FIG. 16 depicts an example method performed by the encoder of FIG. 2.

DETAILED DESCRIPTION

This disclosure and aspects thereof can be embodied in various forms, including hardware, devices or circuits controlled by computer-implemented methods, computer program products, computer systems and networks, user interfaces, and application programming interfaces; as well as hardware-implemented methods, signal processing circuits, memory arrays, application specific integrated circuits (ASICs), field programmable gate arrays (FPGAs), and the like. The foregoing is intended solely to give a general idea of various aspects of the present disclosure, and does not limit the scope of the disclosure in any way.

In the following description, numerous details are set forth, such as optical device configurations, timings, operations, and the like, in order to provide an understanding of one or more aspects of the present disclosure. It will be readily apparent to one skilled in the art that these specific details are merely exemplary and not intended to limit the scope of this application.

Moreover, while the present disclosure focuses mainly on examples in which the various circuits are used in digital projection systems, it will be understood that these are merely examples. It will further be understood that the disclosed systems and methods can be used in any device in which there is a need to project light; for example, cinema, consumer, and other commercial projection systems, heads-up displays, virtual reality displays, and the like. Disclosed systems and methods may be implemented in additional display devices, such as with an OLED display, an LCD display, a quantum dot display, or the like.

Video Coding of HDR Signals

FIG. 1 depicts an example process of a video delivery pipeline (100) showing various stages from video capture to video content display. A sequence of video frames (102) is captured or generated using image generation block (105). Video frames (102) may be digitally captured (e.g. by a digital camera) or generated by a computer (e.g. using computer animation) to provide video data (107). Alternatively, video frames (102) may be captured on film by a film camera. The film is converted to a digital format to provide video data (107). In a production phase (110), video data (107) is edited to provide a video production stream (112).

The video data of production stream (112) is then provided to a processor (or one or more processors such as a central processing unit (CPU)) at block (115) for post-production editing. Block (115) post-production editing may include adjusting or modifying colors or brightness in particular areas of an image to enhance the image quality or achieve a particular appearance for the image in accordance with the video creator's creative intent. This is sometimes called “color timing” or “color grading.” Other editing (e.g. scene selection and sequencing, image cropping, addition of computer-generated visual special effects, etc.) may be performed at block (115) to yield a final version (117) of the production for distribution. During post-production editing (115), video images are viewed on a reference display (125).

Following post-production (115), video data of final production (117) may be delivered to encoding block (120) for delivering downstream to decoding and playback devices such as television sets, set-top boxes, movie theaters, and the like. In some embodiments, coding block (120) may include audio and video encoders, such as those defined by ATSC, DVB, DVD, Blu-Ray, and other delivery formats, to generate coded bit stream (122). Methods described herein may be performed by the processor at block (120). In a receiver, the coded bit stream (122) is decoded by decoding unit (130) to generate a decoded signal (132) representing an identical or close approximation of signal (117). The receiver may be attached to a target display (140) which may have completely different characteristics than the reference display (125). In that case, a display management block (135) may be used to map the dynamic range of decoded signal (132) to the characteristics of the target display (140) by generating display-mapped signal (137). Additional methods described herein may be performed by the decoding unit (130) or the display management block (135). Both the decoding unit (130) and the display management block (135) may include their own processor, or may be integrated into a single processing unit.

FIG. 2 illustrates a block diagram of an encoder (200) for performing the forward-reshaping operation. The encoder (200) includes a noise injection block (202), a forward reshaping block (204), a compressor block (206), a metadata estimation block (208), and a multiplexer (or muxer) block (210). Original HDR video content is provided to both the noise injection block (202) and the metadata estimation block (208). The metadata estimation block (208) analyzes features of the HDR video content to generate non-linear luma and linear chroma reshaping functions used by the forward reshaping block (204). The noise injection block (202) may add film-grain noise to the HDR video content for additional banding alleviation. The forward reshaping block (204) performing the reshaping operation of the HDR video content before it is compressed by compressor block (206) into the 8-bit base layer (BL). The base layer is multiplexed with metadata from the metadata estimation block (208) by the muxer block (210). The multiplexed base layer is then provided to a downstream decoder.

FIG. 3 illustrates a block diagram of a decoder (300) for decoding a received multiplexed base layer. The decoder (300) includes a de-multiplexing (or de-muxer) block (302), a decompressor block (304), and a backward reshaping block (306). The de-muxer block (302) receives the multiplexed base layer from the encoder (200) and separates the HDR video content from the metadata. The decompressor block (304) decompresses the HDR video content. The backward reshaping block (306) uses the metadata to perform a backward-reshaping operation on the HDR video content to reconstruct the HDR video content.

Gaussian Functions

As mentioned above, a Gaussian function may be used for determining the reshaping function. A Gaussian function y(⋅) for an input x is defined as:

$\begin{array}{cc}y\left(x\right)=a·e^{-\left\{\frac{{\left(x-{\mu }_G\right)}^2}{2{{\sigma }_G}^2}\right\}},& \left[\mathrm{Equation}1\right]\end{array}$

where μ_G is the mean and σ_G is the standard deviation of the underlying Gaussian distribution.

Without loss of generality, a=1 may be set such that the maximum of the Gaussian function is 1 for given inputs. FIG. 4 provides a Gaussian function (400) where a=1, μ_G=0.5, and

$\frac{1}{2{{\sigma }_G}^2}=5,$

producing a bell-shaped curve. The maximum value of the curve is center at the means of μ_G=0.5 and tapers down symmetrically in both directions as x moves away from the mean. Varying the mean μ_G varies the “location” of the peak with respect to x. Additionally, varying

$\frac{1}{2{{\sigma }_G}^2},$

henceforth referred to as k_G, varies the width of the Gaussian function. Specifically, a higher value of k^G results in a steeper bell-shaped curve, whereas lower values of k_G “flatten” the curve.

Additional Notation

Let (v_i^Y, v_i^Cb, v_i^Cr) be the YCbCr values at pixel i of an original HDR image of bit-depth η_v and spatial dimensions (W×H). Pixels are assumed to be stored in a data-structure in raster-scan order. There are total N_v=2^ηv HDR codewords e.g. for 16-bit signal, N_v=65536. Let (v_i^Y, v_i^Cb, v_i^Cr) be normalized pixel values as floating point number between [0,1) such that

${\stackrel{\_}{v}}_i^p=\frac{v_i^Y}{N_v},$

for p-channel, p={Y, Cb, Cr}. Let (v_L^Y, v_H^Y), (v_L^Cb, v_H^Cb), (v_L^Cr, v_H^Cr) be the minimum and maximum values in Y, Cb, Cr channels and (v_L^Y, v_H^Y), (v_L^Cb, v_H^Cb), (v_L^Cr, v_H^Cr) be their normalized values respectively.

Let s_i^p be the forward-reshaped (BL) signal in the p-axis. There are N_s=2^ηs number of BL codewords e.g. for 8-bit BL, N_s=256. Normalized BL codeword can be computed as

${\stackrel{\_}{s}}_i^p=\frac{s_i^p}{N_s}.$

Let T_p^F(⋅):[0, N_v−1]→[0, N_s−1] be the single-channel forward reshaping (integer-valued) function for p-channel, where p can be one of Y, Cb, Cr channels. It can be stored in the form of look-up table (LUT), known as forward LUT (FLUT). Let s_i^p be the resulting reshaped i'th pixel value of p-channel:

$\begin{array}{cc}{s}_i^p=T_p^F\left(v_i^p\right)& \left[\mathrm{Equation}2\right]\end{array}$

The FLUT T_p^F(⋅) can also be constructed using a normalized FLUT T_p^F(⋅):[0,1)→[0,1), that converts a normalized HDR codeword to a normalized BL codeword, such that:

$\begin{array}{cc}{s}_i^p=T_p^F\left(v_i^p\right)=\mathrm{clip}3\left(\mathrm{round}\left[N_s·{\stackrel{\_}{T}}_p^F\left(\frac{v_i^p}{N_v}\right)\right],0,N_s-1\right)& \left[\mathrm{Equation}3\right]\end{array}$

where round[⋅] is rounding operation and clip3(value, a, b) is clipping operation that limits value between [a,b]

Let T_p^B(⋅):[0,1)→[0,1) be the normalized backward LUT (BLUT) that convert a normalized BL codeword to a normalized HDR value [0, 1]. Let s_i^(r)p be the p'th channel decompressed BL value at pixel i. We normalize it using

${\stackrel{\_}{s}}_i^{\left(r\right)p}=\left(\frac{s_i^{\left(r\right)p}}{N_s}\right).$

Using the BL and the BLUT, the reconstructed normalized HDR value in pth channel at pixel i is v_i^(r)p∈[0, 1):

$\begin{array}{cc}{\stackrel{\_}{v}}_i^{\left(r\right)p}={\stackrel{\_}{T}}_p^B\left({\stackrel{\_}{s}}_i^{\left(r\right)p}\right)& \left[\mathrm{Equation}4\right]\end{array}$

and the reconstructed η_v-bit HDR is: v_i^(r)p=clip3(round [N_v⋅v_i^(r)p], 0, N_v−1).

The normalized BLUT T_p^B is specified using piecewise polynomial via the RPU metadata. Let Ω^p be the maximum number of polynomial pieces in p-channel. Let ρ_l^p be pivot points expressed as η_s-bit BL codewords in p-channel, l=0, 1, . . . , Ω^p, e.g. an 8-piece luma polynomial is specified using 8+1=9 pivot points. Let a_q^p,m be the q'th order coefficient of m'th polynomial piece in p-channel. For 2^nd order Ω^p-piece luma polynomial, we have a_q^Y,m with q=0, 1, 2 and m=0, 1, 2, . . . , (Ω^p−1) of the Ω^p pieces:

$\begin{array}{cc}{\stackrel{\_}{v}}_i^{\left(r\right)p}=\left\{a_0^{p,m}+a_1^{p,m}\left({\stackrel{\_}{s}}_i^{\left(r\right)p}\right)+{a_2^{p,m}\left({\stackrel{\_}{s}}_i^{\left(r\right)p}\right)}^2\right\},& \left[\mathrm{Equation}5\right]\end{array}$

where m is such that ρ_m^p≤S_i^(r)p<ρ_m+1^p. Note that, as a standard practice, T_p^F(⋅) and T_p^B(⋅) may be monotonically non-decreasing functions.

Forward Reshaping Using Gaussian Differential LUT

A forward reshaping function is a monotonically non-decreasing function that transfers a higher bit-depth codeword (e.g., 16-bit [0, 65535]) to a lower bit-depth (e.g., 8-bit [0,255]). The forward reshaping function may be expressed as a forward look-up table (FLUT). The FLUT can be constructed using a differential look-up table (dLUT) that specifies the amount of increment to the previous value of FLUT to get the current value. For example:

$\begin{array}{cc}{\stackrel{\_}{T}}_p^F\left(\frac{v}{N_v}\right)={\stackrel{\_}{T}}_p^F\left(\frac{v-1}{N_v}\right)+{\stackrel{\_}{\delta }}_p\left(\frac{v}{N_v}\right),& \left[\mathrm{Equation}6\right]\end{array}$

where δp(⋅):[0,1)→[0,1) is the dLUT.

Equation 6 also gives the expression for the FLUT using cumulative summation of all small increments up to the current codeword:

$\begin{array}{cc}{\overline{T}}_p^F\left(\frac{v}{N_v}\right)={\sum }_{\mathrm{ind}=0}^v{\overline{\delta }}_p\left(\frac{\mathrm{ind}}{N_v}\right).& \left[\mathrm{Equation}7\right]\end{array}$

FIGS. 5A-5D illustrate example FLUT and dLUT functions. For example, FIG. 5A illustrates a constant-valued dLUT δ_p(⋅)=K. A corresponding FLUT is constructed by cumulatively adding the dLUT values to obtain a straight line, as shown in FIG. 5B. In another example, the dLUT is a linear function, as shown in FIG. 5C. The corresponding FLUT is a second order polynomial, shown in FIG. 5D.

Accordingly, the dLUT defines the local slope of its corresponding FLUT. The dLUT specifies how many codewords are allocated to a given luminance range. A higher value of dLUT indicates more codewords in that range. Conversely, the luma range that needs to spend more codewords for its corresponding image-content to be reconstructed needs a higher dLUT value compared to other luma ranges. Additionally, the dLUT may be based on image statistics such that the codewords are allocated in a way that removes banding.

In some embodiments, a Gaussian curve is selected as the dLUT. Such a dLUT is defined as:

${\overline{\delta }}_p\left(v\right)=e^{-{k_G\left(\frac{v}{N_v}-{\mu }_G\right)}^2}$

FIGS. 6A-6E illustrate several examples of dLUT and their corresponding FLUT. The peak of each dLUT is at the most banding-prone luminance ranges. As seen in FIG. 6A, the Gaussian curve is constructed using some (μ_G, k_G) values. Equation 6 is applied to the dLUT of FIG. 6A to construct the FLUT shown in FIG. 6B. In the example of FIG. 6A, the Gaussian curve has its peak value at μ_g and the “sharpness” of the peak is determined by the parameter k_G. The mean is near the center of the v_L^Y and v_H^Y values. The dLUT and FLUT of FIGS. 6A-6B are suitable for mid-tone banding prevention, since the mid-tone gets a higher number of codewords than any other range for having a higher dLUT value.

Shifting the mean towards v_H^Y while keeping the k_G constant results in the dLUT of FIG. 6C. In the corresponding FLUT, illustrated in FIG. 6D, a higher luminance range is given more codewords compared to the FLUT of FIG. 6B. Thus, locating the most banding prone luminance range in an image and setting the Gaussian function peak (μ_G) in that range provides additional codewords where they are needed.

If the k_G parameter is lowered, the Gaussian curve becomes more “flat” around its peak, as shown in the dLUT of FIG. 6E. This means if the banding-prone content is well-distributed near the most banding-prone bin, the use of a lower value of k_G spreads the codewords over a larger range in the FLUT of FIG. 6F. On contrast, if the k_G parameter is increased, the peak of the Gaussian curve becomes “sharper”. The dLUT function tapers down quickly on both sides of the peak, and the most banding-prone bin gets significantly more codewords than its neighbors. In summary, the non-linearity of the FLUT is based on the underlying parameterized Gaussian curve. The parameters of the Gaussian curve may be selected using image statistics, as described in more detail below.

Luma and Chroma Reshaping Functions

As described above, a content-based non-linear luma reshaping function may be generated using Gaussian-dLUT curves. The backward reshaping metadata is approximated in the form of an 8-piece 1^st order polynomial curve. FIG. 7 illustrates a method (700) for determining the luma reshaping algorithm. The method (700) may be performed by the encoder (200). At step (702), the encoder (200) receives an HDR image frame. The image frame may be a single image frame included in HDR video data.

At step (704), the encoder (200) collects image statistics from the input HDR image. The image statistics may include the minimum and maximum pixel values from luma and chroma channels of the input HDR image (v_L^Y, v_H^Y), (v_L^Cb, v_H^Cb), and (v_L^Cr, v_H^Cr). In some implementations, the image statistics includes letterbox detection in which the letterbox or pillarbox in an image is identified. The start and end rows of “active”-content (non-letterbox) as (r_min^v, r_max^v), and the columns as (c_min^v, C_max^v), using a letterbox-detection algorithm. Additionally, an average block-based standard deviation (BLKSTD (σ_b^Y,avg) and a block-processed luma histogram (BLKHIST (h_b^Y)) may be computed in luma codeword-intervals (bins).

Processing blockwise pixels reduces needed computations compared to a pixel-by-pixel approach. For blockwise pixels, let the entire HDR luma codeword range be divided into non-overlapping NB codeword-intervals (bins), b=0, 1, . . . . N_B−1. Each such interval is a luma bin containing

$\frac{N_v}{N_B}$

codewords. N_v must be a multiple of N_B. For example, N_B=64 for η_v=16 bit-depth signal means each luma bin contains

$\frac{N_v}{N_B}=\frac{65536}{64}=1024\mathrm{HDR}$

codewords. Let v_b,c^Y be the HDR codeword at the center of bin b and v_b,c^Y be the normalized HDR codeword [0,1).

$\begin{array}{cc}{v}_{b,c}^Y=\mathrm{round}\left[\left(b+0.5\right)\frac{N_v}{N_B}\right]\mathrm{and}{\overline{v}}_{b,c}^Y=\frac{v_{b,c}^Y}{N_v}& \left[\mathrm{Equation}11\right]\end{array}$

Let the non-letterbox (active content) part of the luma image be indexed by rows: (r_min^v, r_max^v) and columns: (c_min^v, c_max^v), and be divided into non-overlapping square pixel-blocks of (ω_B×ω_B) pixels. A k'th block is indicated by Bk, the set of pixel-indices in that block. Blockwise computations begin from (r_min^v, c_min^v) and ignore any partial-block pixels near the boundary towards right columns and bottom rows to avoid letterbox content. For example, an HD (1920×1080) image has active content between: (r_min^v, r_max^v)=(91,990) and (c_min^v, c_max^v)=(0,1919), as indicated by letterbox detection. Beginning from (0, 91) as our first pixel of first block, the encoder (200) proceeds in raster-scan order to compute blockwise statistics. There are total Ω_B=

$\left(\lfloor \frac{c_{\max }^v-c_{\min }^v+1}{{\omega }_B}\rfloor ·\lfloor \frac{r_{\max }^v-r_{\min }^v+1}{{\omega }_B}\rfloor \right)$

such blocks, where └⋅┘ is floor operation. Note that ω_B is small enough (e.g. 16) as compared to image dimensions, such that the number of boundary pixels that are not considered in any block is negligible as compared with either W or

For each block k (k=0, 1, . . . , Ω_B−1), the mean (μ_k^v) and standard deviation (σ_k^v) are computed in the normalized-domain of its luma pixel values according to:

$\begin{array}{cc}{\overline{\mu }}_k^v=\frac{1}{{\omega }_B^2}{\sum }_{i\in B_k}{\overline{v}}_i^Y,{\overline{\sigma }}_k^v=\sqrt{\frac{1}{{\omega }_B^2}{\sum }_{i\in B_k}{\left({\overline{v}}_i^Y-{\overline{\mu }}_k^v\right)}^2}& \left[\mathrm{Equation}12\right]\end{array}$

The corresponding luma bin index b_k of the block-mean is:

$\begin{array}{cc}{b}_k=\lfloor {\overline{\mu }}_k^v·N_B\rfloor & \left[\mathrm{Equation}13\right]\end{array}$

The BLKHIST is computed by counting the number of pixels that have block-mean bin index b:

$\begin{array}{cc}{h}_b^Y={\sum }_{\forall ks.t.b_k=b}{\omega }_B^2& \left[\mathrm{Equation}14\right]\end{array}$

BLKSTD is computed in all bins b where h_b^Y≠0 by averaging the standard deviation over all blocks that have block-mean bin index b:

$\begin{array}{cc}{\overline{\sigma }}_b^{Y,avg}=\frac{1}{h_b^Y}{\sum }_{\forall ks.t.b_k=b}\left({\omega }_B^2.{\overline{\sigma }}_k^v\right)& \left[\mathrm{Equation}15\right]\end{array}$

For bins where h_b^Y=0, the BLKSTD σ_b^Y.avg is given a value of INVALID.

Using block-based image statistics over pixel image statistics saves on computations at a negligible loss of accuracy. FIG. 8A, for example, illustrates a graph (800) comparing a pixelwise histogram and the BLKHIST. Similarly, FIG. 8B illustrates a graph (850) comparing a pixelwise standard deviation and the BLKSTD.

As one particular example of performing statistics collections, the following pseudocode is presented using a C-like format:

// Collect (vLY, vHY), (vLCb, vHCb), (vLCr, vHCr) for given HDR image
// Init vLY = vLCb = vLCr = Nv − 1, vHY = vHCb = vHCr = 0, hbY = σbY,avg = 0, b = 0,1,...,NB − 1
// Assign temporary variables: vtempY, μkv, vsqrY, σkv, bk
// luma min/max
for (i = 0; i < W*H; i ++){
if (viY < vLY)
vLY = viY;
if (viY > vHY )
vHY = viY;
}
// chroma min/max (4:2:0 subsampled format)
for (i = 0; i < W*H / 4; i ++){
if (viCb < vLCb)
vLCb = viCb;
if (viCb < vHCb )
vHCb = viCb;
if (viCr < vLCr)
vLCr = viCr;
if (viCr < vHCr )
vHCr = viCr;
}
// luma features: BLKSTD and BLKHIST
for( x = rminv; x <= (rmaxv − ωB) ; x+=ωB) {
for( y = cminv ; y <= (cmaxv − ωB) ; y +=ωB) {
//initialize mean and sum square of the block k
μkv = 0.0f;
vsqrY = 0.0f;
//Compute mean value and std of the block: pixel accessed by raster scan
for( n = 0 ; n < ωB; n++ ) {
for( m = 0 ; m < ωB; m++ ) {
// record normalized luma pixel value
vtempY = v(x+n)Y* W + (y+m) / Nv;
// record stats for BLKSTD
μkv += vtempY;
vsqrY += vtempY* vtempY;
}
}
// compute block mean and standard deviation
μkv /= ωB * ωB;
σkv = sqrt (vsqrY / (ωB * ωB) − μkv* μkv);
//accumulate data into respective bin bk
bk = floor└μkv.NB┘;
hbkY += (ωB * ωB);
σbkY,avg += (ωB * ωB) * σkv;
}
}
// compute avg std dev in hist bin
for ( b = 0; b < NB; b++ ) {
if (hbY )
σbY,avg = σbY,avg / hbY;
else
σbY,avg = INVALID;
}

Returning to FIG. 7, at step (706), the encoder (200) computes a feature that measures potential banding visibility in each luma bin. Generally, high-texture or noisy region of images have low banding visibility due to the masking effect. The BLKSTD functions as a measure of such signal smoothness, such that if BLKSTD is lower in some luma bin, the regions coded using those luma codewords are more smooth compared to regions coded with different luma codewords. Thus, a lower BLKSTD may indicate higher banding visibility. Accordingly, the computed feature should be inversely related to the BLKSTD. Additionally, banding over a larger region is more noticeable and annoying to a viewer of the HDR video content. Therefore, a higher BLKHIST results in higher chances of noticeable banding. Accordingly, the computed feature should be directly related to the BLKHIST. Thus, both the BLKSTD and the BLKHIST function as inputs to predict banding risk in each bin.

A banding indicator unit may be constructed using a multiplicative combination of BLKSTD and BLKHIST. For example, let op be the predicted banding risk in bin b=0, 1, . . . . N_B−1:

$\begin{array}{cc}{\phi }_b=\{\begin{array}{cc}\frac{h_b^Y}{{\stackrel{\_}{\sigma }}_b^{Y,\mathrm{avg}}}& \mathrm{if}{h}_b^Y\ne 0\\ 0& \mathrm{if}{h}_b^Y=0\end{array}& \left[\mathrm{Equation}16\right]\end{array}$

If h_b^Y=0 for some bin, then there are no pixels in that bin, and banding risk is 0. This indicator considers the effects of two features to indicate banding risk in larger areas of image. Since σ_b^Y,avg is in the denominator and if it is 0 for some bin, we need to set it to a small σ_b^Y,min value to avoid divide-by 0. Thus, we floor it to σ_b^Y,min. With this, the normalized risk (φ_b) is:

$\begin{array}{cc}{\overline{\phi }}_b=\frac{{\phi }_b}{{\sum }_{b=0}^{N_B-1}{\phi }_b}& \left[\mathrm{Equation}17\right]\end{array}$

Where a higher value of (φ_b) indicates a higher proclivity to visible banding.

As one particular example of determining banding risk, the following pseudocode is presented using a C-like format:

// Init φsum = 0, b = 0,1, ... , NB − 1
// Use σbY,min = 1/ ωB2
// compute risk
for (b = 0; b < NB; b ++ ) {
if (hbY > 0)
// set up a minimum BLKSTD based on 1 pixel different in ωB * ωB block
if (σbY,avg < σbY,min)
σbY,avg = σbY,min;
// compute risk using BLKHIST and BLKSTD
φb = hbY/ σbY,avg ;
φsum +=φb;
}
else {
φb = 0;
}
}
// normalize risk
if (φsum) {
for (b = 0; b < NB; b ++ )
φb = φb / φsum;
}
}

At step (708), the encoder (200) determines curve parameters for the earlier-defined Gaussian function. The Gaussian curve parameters include μ_G and k_G. The Gaussian function has a maximum value (or peak) at its mean μ_G. The peak location of the banding risk across all luma bins is identified and set as the mean μ_G. Let φ^peak be the peak normalized risk value with b_φpeak, the corresponding bin index.

$\begin{array}{cc}{\overline{\phi }}^{\mathrm{peak}}=\underset{b}{\max }\left({\overline{\phi }}_b\right)b_{{\overline{\phi }}^{\mathrm{peak}}}=\underset{b}{\arg \max }\left({\overline{\phi }}_b\right)& \left[\mathrm{Equation}18\right]\end{array}$

The normalized bin-center codeword is set as the mean of the Gaussian function, as previously described with respect to Equation 11.

$\begin{array}{cc}{\mu }_G={\overline{v}}_{b_{{\stackrel{\_}{\phi }}^{\mathrm{peak},c}}}^Y& \left[\mathrm{Equation}19\right]\end{array}$

The parameter k_G determines the shape of the Gaussian bell-curve and is computed as a number between (K_G,min, k_G,max), using the peak-bin index b_φpeak and its W_kG neighboring bins on each side. Let (b_φpeak^left, b_φpeak^right) be the leftmost and rightmost bins that are W_kG bins away from the peak bin b_φpeak in either direction.

$\begin{array}{c}\left[\mathrm{Equation}20\right]\end{array}$ $b_{{\overline{\phi }}^{\mathrm{peak}}}^{\mathrm{left}}=\max \left(b_{{\overline{\phi }}^{\mathrm{peak}}}-w_{k_G},0\right)\mathrm{and}{b}_{{\overline{\phi }}^{\mathrm{peak}}}^{\mathrm{right}}=\max \left(b_{{\overline{\phi }}^{\mathrm{peak}}}-w_{k_G},N_B-1\right)$

The sum of risk in this window (φ_winsum^peak) is:

$\begin{array}{cc}{\stackrel{\_}{\phi }}_{\mathrm{winsum}}^{\mathrm{peak}}=\sum _{b=b_{{\stackrel{\_}{\phi }}^{\mathrm{peak}}}^{\mathrm{left}}}^{b_{{\stackrel{\_}{\phi }}^{\mathrm{peak}}}^{\mathrm{right}}}{\stackrel{\_}{\phi }}_b& \left[\mathrm{Equation}21\right]\end{array}$ $k_G=k_{G,\min }+\left(k_{G,\max }-k_{G,\min }\right){\stackrel{\_}{\phi }}_{\mathrm{winsum}}^{\mathrm{peak}}$

Where φ_winsum^peak indicates the combined banding risk within a luminance range centered at the peak. If φ_winsum^peak is higher, the probability of banding is higher, and more codewords are assigned within this range. When φ_winsum^peak is higher, a smaller standard deviation of the Gaussian curve in terms of dLUT may be selected to narrow the Gaussian curve. Whereas, if φ_winsum^peak is smaller, a larger standard deviation of the Gaussian curve in terms of dLUT may be selected to widen the Gaussian curve.

As one particular example of determining Gaussian curve parameters, the following pseudocode is presented using a C-like format:

// compute Gaussian curve parameters: μG and kG
φ              peak = φwinsumpeak = 0.0f;
b                                                                              φ                            ¯                                                                                p                            ⁢                            e                            ⁢                            a                            ⁢                            k                                                                                              =                                              round                        [                                                                              N                            B                                                    2                                                ]                                                              ;
for (b = NB − 1; b > 0; b − − ) { // ignore darkest bin
if (φb > φpeak ){
φpeak = φb;
b;
}
}
// find mid-codeword of peak bin
v                          ¯                                                                          c                          ,                                                      b                                                                                          φ                                _                                                                                            p                                ⁢                                e                                ⁢                                a                                ⁢                                k                                                                                                                                    Y                                            =                                              CLIP                        ⁢                        3                        ⁢                                                  {                                                                                    (                                                                                                                                    b                                                                                                                  φ                                        ¯                                                                                                                    p                                        ⁢                                        e                                        ⁢                                        a                                        ⁢                                        k                                                                                                                                              +                                  0.5                                                                                                  N                                  B                                                                                            )                                                        ,                                                                                                                       v                                ¯                                                            L                              Y                                                        ,                                                                                          v                                ¯                                                            H                              Y                                                                                }                                                                                      ;
μG =
// compute Gaussian curve parameter kG
for (d = − wkG; d <= wkG; d ++ ){
b = CLIP3{bφpeak+ d, 0, NB − 1}
φwinsumpeak += φb;
}
kG = kG,min + (kG,max − kG,min) * φwinsumpeak;

In this example, CLIP3{a, b, c} means the signal a is clipped to be in between [b,c].

At step (710) the encoder (200) constructs the dLUT. A pointwise dLUT denoted by δ_Y(⋅):[0,1)→[0,1] is constructed at N_C number of equidistant “compute-points” x_i, i=0, 1, . . . . N_C−1, using Gaussian curve with parameters: μ_G, k_G.

$\begin{array}{cc}{x}_i=\frac{\left(i+0.5\right)}{N_C}=\left(i+0.5\right){\pi }_C,i=0,1,\dots N_C-1& \left[\mathrm{Equation}22\right]\end{array}$

Setting N_C<N_v significantly saves computations e.g. in case of 16-bit content. N_C=4096 compute-points i.e 12-bit granularity are used instead of full N_v=65536 actual codewords. Here,

${\pi }_C=\frac{1}{N_C}$

is normalized stride for compute-points. N_C needs to be a factor of N_v.

$\begin{array}{cc}{\delta }_Y\left(i\right)=\max \left(e^{-\left\{{k_G\left(x_i-{\mu }_G\right)}^2\right\}},{\delta }_{Y,\mathrm{MAX}}\right)\mathrm{for}i=0,1,\dots ,N_C-1,& \left[\mathrm{Equation}23\right]\end{array}$

Where δ_Y,MAX is minimum value imposed on dLUT.

Setting δ_Y,MAX ensures any luma range receives at least some minimum number of codewords, as a purely curve-based function may not account for ensuring each luma range receives codewords otherwise. FIG. 9 provides a graph (900) showing a Gaussian curve with parameters μ_G=0.7, k_G=8, and having a floor value of δ_Y,MAX=0.25.

Returning to FIG. 7, at step (712), the encoder (200) computes the luma FLUT based on the dLUT. An intermediate luma FLUT {tilde over (T)}_Y^F,C(⋅) is first obtained and defined at compute points x_i, i=0, 1, . . . . N_C−1 using below equation:

$\begin{array}{cc}{\tilde{T}}_Y^{F,C}\left(i\right)=\{\begin{array}{ccc}{\delta }_Y\left(0\right)& \mathrm{if}& i=0\\ {\stackrel{\_}{T}}_Y^{F,C}\left(i-1\right)+{\delta }_Y\left(i\right)& \mathrm{if}& 0<i<N_C\end{array}& \left[\mathrm{Equation}24\right]\end{array}$

Equation 24 defines a curve at N_C points that maps the entire HDR codeword range to a real-number range. To construct a normalized FLUT T_Y^F,C(⋅) from {tilde over (T)}_Y^F,C(⋅) for the input HDR image, the relevant piece of the curve that maps [v_L^Y], v_H^Y] to the entire normalized BL codeword range [0,1) is identified according to the following:

• • i) Obtain the value corresponding to v_L^Y as minimum offset τ_Y^Δ,min:

$\begin{array}{cc}{\tau }_Y^{\Delta ,\min }={\tilde{T}}_Y^{F,C}\left(\mathrm{floor}\lfloor N_C\frac{v_L^Y}{N_v}\rfloor \right)& \left[\mathrm{Equation}25\right]\end{array}$

• • ii) Form an un-normalized function {umlaut over (T)}_Y^F,C(⋅) at compute points by offsetting by ty τ_Y^Δ,min:

$\begin{array}{cc}{\ddot{T}}_Y^{F,C}\left(i\right)=\{\begin{array}{cc}0& \mathrm{if}i<\mathrm{floor}\lfloor N_C\frac{v_L^Y}{N_v}\rfloor \\ {\tilde{T}}_Y^{F,C}\left(i\right)-{\tau }_Y^{\Delta ,\min }& \mathrm{if}\mathrm{floor}\lfloor N_C\frac{v_L^Y}{N_v}\rfloor \le i\le \mathrm{ceil}\lceil N_C\frac{v_H^Y}{N_v}\rceil \\ {\tilde{T}}_Y^{F,C}\left(\mathrm{ceil}\lceil N_C\frac{v_H^Y}{N_v}\rceil \right)-{\tau }_Y^{\Delta ,\min }& \mathrm{if}i>\mathrm{ceil}\lceil N_C\frac{v_H^Y}{N_v}\rceil \end{array}& \left[\mathrm{Equation}26\right]\end{array}$

• • iii) Obtain the value corresponding to v_H^Y from {circumflex over (T)}_Y^F,C:

$\begin{array}{cc}{\tau }_Y^{\Delta ,\max }={\ddot{T}}_Y^{F,C}\left(\mathrm{ceil}\lceil N_C\frac{v_H^Y}{N_v}\rceil \right)& \left[\mathrm{Equation}27\right]\end{array}$

• • iv) Normalize the function to [0,1]:

$\begin{array}{cc}{\overline{T}}_Y^{F,C}\left(i\right)=\frac{{\ddot{T}}_Y^{F,C}\left(i\right)}{{\tau }_Y^{\Delta ,\max }}& \left[\mathrm{Equation}28\right]\end{array}$

FIG. 10 provides a graph (1000) illustrating an exemplary FLUT generated using a Gaussian-curve dLUT. Graph (1000) shows T_Y^F,C(⋅) using T_Y^F,C(⋅) for N_s=256 i.e. 8-bit BL:

$\begin{array}{cc}{T}_Y^{F,C}\left(i\right)=\mathrm{round}\lfloor \left(N_S-1\right)·{\overline{T}}_Y^{F,C}\left(i\right)]& \left[\mathrm{Equation}29\right]\end{array}$

In the example of graph (1000), v_L^Y=10000 and v_H^Y=55536. Accordingly, the resulting FLUT did not allocate any codewords to v<v_L^Y and v>v_H^Y. As one particular example of obtaining dLUT and FLUT at compute-points, the following pseudocode is presented using a C-like format:

// compute dLUT and FLUT for full range at NC compute-points
// 0th compute-point
π                        C                                            =                                              1                                                  N                          C                                                                                      ;
x0 = 0.5 * πC;
{tilde over (T)}YF,C (0) = max(e−{kG(x0−μG)2}, δY,MAX)
// other compute points
for (i = 1; i < NC; i++ ) {
xi = (i + 0.5 )* πC;
δtemp = max(e−{kG(xi−μG)2}, δY,MAX)
{tilde over (T)}YFC (i) = {tilde over (T)}YFC (i − 1) + δtemp;
}
// norm FLUT
for (i = 0; i < NC; i++ ) {
TYF,C (i) = {tilde over (T)}YF,C (i)/{tilde over (T)}YF,C (NC − 1);
}
// Construct frame FLUT
v                      L                                              Y                        ,                        C                                                              =                                          floor                      ⁢                                              ⌊                                                                              N                            C                                                    ⁢                                                                                    v                              L                              Y                                                                                      N                              v                                                                                                      ⌋
v                      H                                              Y                        ,                        C                                                              =                                          ceil                      ⁢                                              ⌈                                                                              N                            C                                                    ⁢                                                                                    v                              H                              Y                                                                                      N                              v                                                                                                      ⌉
τYΔ,min = {tilde over (T)}YF,C (νLY,C);
for ( i = 0; i < νLY,C; i++ ) {
{umlaut over (T)}YF,C(i) = 0;
}
for (  ; i <= νHY,C; i++ ) {
{umlaut over (T)}YF,C(i) = max({tilde over (T)}YF,C(i) − τYΔ,min, 0);
}
for (  ; i < NC; i++ ) {
{umlaut over (T)}YF,C (i) = {umlaut over (T)}YF,C (νHY,C);
}
// Normalize frame FLUT
τYΔ,max = {umlaut over (T)}YF,C (νHY,C)
if (τYΔ,max) {
for ( i = 0; i < NC; i++ ) {
T¯YF,C(i)=CLIP⁢3⁢(T¨YF,C(i)τYΔ,max,0,1);
}
}

Returning to FIG. 7, at step (714), the encoder (200) determines the luma BLUT polynomial. The normalized BLUT (T_Y^B) is specified using an 8-piece polynomial where Ω^Y=8. In some implementations, the BLUT has 9 pivot points: ρ₀^Y, β₁^Y, . . . , ρ₈^Y, expressed as η_s-bit codewords. Each m'th polynomial piece has 3 coefficients: a₀^Y,m, a₁^Y,m, a₂^Y,m.

$\begin{array}{cc}{\overline{T}}_Y^B\left(\overline{s}\right)=a_0^{Y,m}+a_1^{Y,m}\overline{s}+{a_2^{Y,m}\left(\overline{s}\right)}^2,m\mathrm{is}\mathrm{such}\mathrm{that}{\rho }_m^p<s\le {\rho }_{m+1}^p,& \left[\mathrm{Equation}30\right]\end{array}$

where s=round [N_s.s] is some BL codeword.

To simplify computations over using jointly-designed pivot points and a 2^nd order polynomial, fixed pivot points at equal intervals and a 1^st order polynomial is used. The 9 pivot points are computed as:

$\begin{array}{cc}{\rho }_l^Y=\mathrm{round}\left[l\left(\frac{N_s}{{\Omega }^Y-1}\right)\right],l=0,1,\dots {\Omega }^Y-1,{\rho }_{{\Omega }^Y}^Y=N_s-1& \left[\mathrm{Equation}31\right]\end{array}$

For example, for 8-bit BL, the 9 pivot points are 0, 32, 64, 96, 128, 160, 192, 224, and 255. The normalized pivot points are:

$\begin{array}{cc}{\overline{\rho }}_l^Y=\frac{{\rho }_l^Y}{N_s-1},l=0,1,\dots {\Omega }^Y-1\mathrm{and}{\rho }_{{\Omega }^Y}^Y=1& \left[\mathrm{Equation}32\right]\end{array}$

The corresponding mapping of the BL-domain points to HDR domain is computed using the normalized FLUT T_Y^F,C(⋅). Specifically, the start and end points of each 'th polynomial (ρ_l^Y, v_l,start^Y) and (ρ_l+1^Y, v_l,end^Y) respectively, l=0, 1, . . . Ω^Y−1, where v_l,start^Y, v_l,end^Y correspond to the minimum and maximum normalized HDR codewords to be mapped using l'th polynomial-piece. These polynomial pieces are continuous such that:

$\begin{array}{cc}\left({\overline{\rho }}_{l+1}^Y,{\overline{v}}_{l,\mathrm{end}}^Y\right)=\left({\overline{\rho }}_{l+1}^Y,{\overline{v}}_{l+1,\mathrm{start}}^Y\right),l=0,1,\dots {\Omega }^Y-2& \left[\mathrm{Equation}33\right]\end{array}$

To compute the start points of all the polynomial pieces:

$\begin{array}{cc}{\overline{v}}_{0,\mathrm{start}}^Y={\overline{v}}_L^Y\mathrm{and}{{\overline{v}}_{{\Omega }^Y}^Y}_{-1,\mathrm{end}}={\overline{v}}_H^Y& \left[\mathrm{Equation}34\right]\end{array}$

since T_Y^F,C:(v_L^Y, v_H^Y)→[0,1].

Using the monotonically non-decreasing property of reshaping functions, for l=1, . . . Ω^Y−1:

$\begin{array}{cc}{\overline{v}}_{l,\mathrm{start}}^Y=\underset{\overline{v}}{\arg \min }\left\{{\overline{T}}_Y^{F,C}\left(\overline{v}\right)\right\}\mathrm{such}\mathrm{that}{\overline{T}}_Y^{F,C}\left(\overline{v}\right)\ge {\overline{\rho }}_l^Y& \left[\mathrm{Equation}35\right]\end{array}$

The end points for l=0, . . . Ω^Y−2 are:

$\begin{array}{cc}{\overline{v}}_{l,\mathrm{end}}^Y={\overline{v}}_{l+1,\mathrm{start}}^Y& \left[\mathrm{Equation}36\right]\end{array}$

and v_ΩY−1,end=v_H^Y.

FIG. 11 provides a graph (1100) illustrating the process for the above luma 8-piece first order fitting for the BLUT. Once the start and end points of all polynomial pieces are established, a first order curve (e.g., a straight line) is constructed for each piece m=0, 1, 2, . . . , (Ω^p−1), in the slope-intercept form using the two end-points of that line. The polynomial coefficients are;

$\begin{array}{cc}{a}_1^{Y,m}=\left(\frac{{\overline{v}}_{m,\mathrm{end}}^Y-{\overline{v}}_{m,\mathrm{start}}^Y}{{\overline{\rho }}_{m+1}^Y-{\overline{\rho }}_m^Y}\right)\mathrm{and}{a}_0^{Y,m}={\overline{v}}_{m,\mathrm{start}}^Y-a_1^{Y,m}{\overline{\rho }}_m^Y& \left[\mathrm{Equation}37\right]\end{array}$

The BLUT is constructed using these 8 polynomial pieces. As one particular example for computing first-order BLUT coefficients, the following pseudocode is presented using a C-like format:

// estimate 1st order BLUT coeffs
// construct (ΩY + 1)-point BLUT {circumflex over (T)}YB (. )
{circumflex over (T)}YB (0) = νLY;
ν = νLY,C;
l = 1;
while ( l < ΩY ) {
while⁢(T¨YF,C(v)<(ρ¯lY+0.5Ns)){
ν++;
}
{circumflex over (T)}YB(l) = Nν * πC;
l++;
}
{circumflex over (T)}YB (ΩY) = νHY;
for (m = 0; m < ΩY ; m++) {
// slope
a1Y,m = ({circumflex over (T)}YB  (m + 1) − {circumflex over (T)}YB (m) ) / (ρm+1Y) − ρmY);
// intercept
a0Y,m = {circumflex over (T)}YB (m) − a1Y,m * ρmY;
}

FIG. 12 provides a graph (1200) illustrating an 8-piece polyfit BLUT compared to a BLUT constructed at each compute-point by inverting a FLUT. FIG. 13 provides a graph (1300) illustrating the absolute error while approximating the BLUT curve using an 8-piece 1^st order polynomial using fixed pivot points.

Returning to FIG. 7, at step (716), the encoder (200) computes a revertible luma FLUT based on the polynomial BLUT. As seen in FIGS. 9 and 10, the 8-piece approximation BLUT slightly differs from a fully inverted BLUT, particularly in a lower codeword range. If the luma FLUT from step (712) is used to perform a forward reshaping operation and the polynomial approximation BLUT is used to perform a backward reshaping operation, the reconstructed HDR video data may appear different than the original HDR video data. Accordingly, a FLUT is constructed by inverting the polynomial approximation BLUT, referred to as a revertible FLUT. The revertible FLUT is capable of producing BL that can be used to reconstruct the HDR without any polynomial fitting error.

As illustrated in FIG. 11, the start and end points of the 8 polynomial pieces of BLUT maps the BL (x-axis) to HDR codewords (y-axis). An inverse function is constructed using the same pieces with those start and end points, but mapping from HDR to BL codewords. Accordingly, a revertible FLUT is constructed: T_Y^F(⋅):[0, N_v−1]→[0, N_s−1]:

$\begin{array}{cc}{T}_Y^F\left(v\right)=\mathrm{round}\left[\left(N_s-1\right)\left\{b_1^{Y,m}\left(\frac{v}{N_v}\right)+b_0^{Y,m}\right\}\right],m\mathrm{is}\mathrm{such}\mathrm{that}{\overline{v}}_{m,\mathrm{start}}^Y\le \left(\frac{v}{N_v-1}\right)<{\overline{v}}_{m,\mathrm{end}}^Y& \left[\mathrm{Equation}37\right]\end{array}$

Where:

$\begin{array}{cc}{b}_1^{Y,m}=\frac{1}{a_1^{Y,m}}\mathrm{and}{b}_0^{Y,m}={\overline{\rho }}_l^Y-b_1^{Y,m}{\overline{v}}_{m,\mathrm{start}}^Y,\mathrm{for}\mathrm{all}m=0,1,\dots {\Omega }^Y-1& \left[\mathrm{Equation}38\right]\end{array}$

FIG. 14 provides a graph (1400) illustrating the revertible FLUT (magenta line) compared with the FLUT directly constructed using the compute-point FLUT (green line). The difference between the revertible FLUT and the compute-point FLUT assists in avoiding visual artifacts due to polynomial approximation errors. As one particular example for computing the luma revertible FLUT, the following pseudocode is presented using a C-like format:

// construct revertible FLUT
// for beginning
for (v = 0; v <= vLY ; v++ ) {
TYF (v)= 0;
}
for (m = 0; m < ΩY; m ++) {
vm,startY = {circumflex over (T)}YB(m)
vm,startY = round[vm,startY * Nv];
vm,endY = round[{circumflex over (T)}YB(m + 1) * Nv];
// compute slope and intercept
if (a1Y,m)
b1Y,m = 1.0 / a1Y,m;
else
b1Y,m = 0;
b0Y,m = ρmY − vm,startY * b1Y,m;
// compute revertible FLUT for this piece
for (v = vm,startY; v <= vm,endY; v++ ) {
v = v / Nv;
TYF(v) = round[(Ns − 1).(v * b1Y,m + b1Y,m)];
}
}
// compute end
for ( ; v < Nv; v ++ ) {
TYF (v) = Ns − 1;
}

FIG. 15 provides a graph (1500) illustrating the 1:1 revertability of the revertible FLUT and polynomial-approximation BLUT. The x-axis in graph (1500) shows the original HDR codeword. For a codeword v, the revertible FLUT is applied, followed by polyfit-BLUT, to get back the reconstructed HDR codeword. The y-axis shows the reconstruction: round

$\left[N_v·{\overline{T}}_Y^B\left(\frac{T_p^F\left(v\right)}{N_s}\right)\right].$

Here, T_Y^P is constructed using the 8-piece polynomial at all normalized BL codewords.

Graph (1500) includes a 45-degree line that indicates the proposed reshaping operation is properly revertible. Visible steps in some part of the graph (1500) (lower codewords in this example) indicate a higher quantization due to less codewords being allocated in those parts. This shows the non-linearity of the proposed reshaping function that allows for an unequal distribution of codewords.

Returning to FIG. 7, at step (718), the encoder (200) generates an output image and corresponding metadata. The output image is the HDR image frame received in step (702) expressed as an 8-bit base layer (the HDR image frame following noise injection, forward reshaping, and compressing). The luma BLUT polynomial is provided as metadata alongside the base layer such that decoder (300) reconstructs the output image to an HDR image.

Accordingly, the use of an 8-piece polynomial function for luma reshaping avoids costly computations and reduces latency. Additionally, the use of Gaussian curves whose parameters are determined based on image features minimizes banding within the image frames.

In some implementations, the encoder (200) pre-builds a number of Gaussian dLUTs and their cumulate addition (or intermediate) intermediate FLUTs: {tilde over (T)}_Y^F,C(⋅). FIG. 16 illustrates a method (1600) for determining the luma reshaping algorithm. The method (1600) may be performed by the encoder (200). The method (1600) is similar to the method (700). However, instead of constructing a dLUT to compute a luma FLUT, as in steps (710) and (712) respectively, the method (1600) uses a pre-built intermediate FLUT to compute a luma FLUT, as shown in steps (1610) and (1612), respectively.

As previously described, there are two parameters: UG and k_G to construct the Gaussian curve. A 2D table is pre-built, which can be addressed using an index-pair: (π_μ, π_k), where π_μ=0, 1, . . . , Π_μ−1 and π_k=0, 1, . . . , Π_k−1. A Δμ_G stepsize is used for μ_G and Δk_G for k_G parameters to construct a (Π_μ×Π_k)-sized look up table, in which each entry indexed by (π_μ, π_k) is an intermediate FLUT: {tilde over (T)}_Y,{πμ,πk}^F,C(⋅).

Here,

${\prod }_{\mu }=\frac{1}{\Delta {\mu }_G}+1.$

For example, if Δμ_G=0.1 is the step size, there are 11 entries between [0,1]. Similarly,

${\prod }_k=\frac{\left(k_{G,\max }-k_{G,\min }\right)}{\Delta k_G}+1.$

For example, if (K_G,min, k_G,max)=(2,10) and Δk_G=0.5, there will be Π_k=17 entries. Thus, the 2D look-up table will have (Π_μ×Π_k)=11×17=187 pre-computed FLUTs that are mapping entire HDR codeword range from [0,1] to BL.

As one particular example for pre-computing intermediate FLUTs, the following pseudocode is presented using a C-like format:

// Pre-compute intermediate FLUTs {tilde over (T)}Y,{πμ,πk}F,C (. ) for full range at NC
compute-points to build 2D look-up table indexed by πμ = 0,1, . . . ,
Πμ − 1 and πk = 0,1, . . . , Πk − 1.
for (πk = 0; πk < Πk; πk + +)
{
// obtain current kG
kG = kG,min + πk * ΔkG
for (πμ = 0; πμ < Πμ; πμ + +)
{
// obtain current μG
μG = πμ * ΔμG
// 0th compute-point
πC=1NC;
x0 = 0.5 * πC;
{tilde over (T)}Y,{πμ,πk}F,C (0) = max(e−{kG(x0−μG)2}, δY, MAX)
// other compute points
for (i = 1; i < NC; i++ ) {
xi = (i + 0.5 )* πC;
δtemp = max(e−{kG(xi−μG)2}, δY, MAX)
{tilde over (T)}Y,{πμ,πk}F,C (i) = {tilde over (T)}YF,C (i − 1) + δtemp;
}
}
}

With the pre-built tables, for a given frame f, image features are computed and parameters μ_G,f, k_G,f are estimated by the encoder (200). Next, these are quantized to find the corresponding indices (π_μ,f, π_k,f) using:

${\pi }_{\mu ,f}=\mathrm{clip}3\left[\mathrm{round}\left[{\mu }_{G,f}*\left({\prod }_{\mu }-1\right)\right],0,{\prod }_{\mu }-1\right],$ ${\pi }_{k,f}=\mathrm{clip}3\left[\mathrm{round}\left[\frac{\left(k_{G,f}-k_{G,\min }\right)*\left({\prod }_k-1\right)}{k_{G,\max }-k_{G,\min }}\right]0,{\prod }_k-1\right]$

{tilde over (T)}_Y,{πμ,πk}^F,C(⋅) is loaded, saving on Gaussian curve computations that involve an exponential term.

Chroma Reshaping Functions

For chroma channels, luma-weighted reshaping is used. This facilitates assigning more importance to reshaped luma content than that of chroma, aiding typical video compression to spend more bits on the more-visually-significant luma part.

First, the range of BL codewords to be used for p chroma channel, p=Cb or Cr is determined based on the ratio of HDR chroma range to luma range. Specifically, the number of BL codewords used in channel p is denoted by s_range^p and computed as:

$\begin{array}{cc}{s}_{\mathrm{range}}^p=\min \left(\mathrm{round}\left[N_s\left(\frac{v_H^p-v_L^p}{v_H^Y-v_L^Y}\right)\right],N_s\right)& \left[\mathrm{Equation}39\right]\end{array}$

The chroma-neutral point is shifted to the center of BL axis such that the minimum and maximum reshaped BL codewords s_min^p, s_max^p are:

$\begin{array}{cc}{s}_{\min }^p=\mathrm{round}\left[\frac{N_s}{2}-\frac{s_{\mathrm{range}}^p}{2}\right]\mathrm{and}{s}_{\max }^p=\mathrm{round}\left[\frac{N_s}{2}+\frac{s_{\mathrm{range}}^p}{2}\right]& \left[\mathrm{Equation}40\right]\end{array}$

Thus, the chroma forward reshaping for channel p is:

$\begin{array}{cc}s=T_p^F\left(v\right)=\{\begin{array}{cc}{s}_{\min }^p& \mathrm{for}v<v_L^p\\ s_{\min }^p+\mathrm{round}\left[\left(\frac{s_{\mathrm{range}}^p}{v_H^p-v_L^p}\right)\left(v-v_L^p\right)\right]& \mathrm{for}{v}_L^p\le v<v_H^p\\ s_{\max }^p& \mathrm{for}v\ge v_H^p\end{array}& \left[\mathrm{Equation}41\right]\end{array}$

The corresponding backward reshaping function is:

$\begin{array}{cc}{T}_p^B\left(s\right)=v_L^p+\mathrm{round}\left[\left(\frac{v_H^p-v_L^p}{s_{\mathrm{range}}^p}\right)\left(s-s_{\min }^p\right)\right]& \left[\mathrm{Equation}42\right]\end{array}$

The p-channel chroma backward reshaping parameters are expressed as first order polynomials using a 1-piece 1^st order polynomial (straight line) coefficients a₀^p,0 and a₁^p,0:

$\begin{array}{cc}{a}_1^{p,0}=\left(\frac{v_H^p-v_L^p}{s_{\mathrm{range}}^p}\right)\left(\frac{N_s}{N_v}\right)\mathrm{and}{a}_0^{p,0}={\overline{v}}_L^p-a_1^{p,0}{\overline{s}}_{\min }^p& \left[\mathrm{Equation}43\right]\end{array}$

where

${\overline{s}}_{\min }^p=\frac{s_{\min }^p}{N_s}.$

As one particular example for computing revertible reshaping functions for p-chroma channel, the following pseudocode is presented using a C-like format:

// compute chroma FLUT and BLUT coeff
νrangep = νHp − νLp ;
νrangeY = νHY − νLY
// If νHp  = = νLp , assign mid-value
if (νrangep = = 0) {
TpF (ν) = Ns/2;
a0p,0 = 0.5;
a1p,0 = 0;
ρ0p = 0;
ρ1p  = Ns − 1;
}
else {// construct chroma FLUT
srangep = min(νrangep /νrangeY, 1 );
sminp=CLIP⁢3⁢(round⁢⌈Ns2⁢(1-s¯rangep)⌉,0,Ns-1)
smaxp=CLIP⁢3⁢(round[Ns2⁢(1+s¯rangep)],0,Ns-1)
γp=(srangepvHp-vLp)
for (ν = 0; ν < νLp ; ν++ ) {
TpF (ν) = sminp;
}
for (  ; ν <= νHp; ν++ ) {
TpF (ν) = sminp + round [γp (ν − νLp)];
}
for (  ; v < Nν; v ++ ) {
TpF (ν) = smaxp;
}
// chroma BLUT coefficients
ρ0p = sminp ;
ρ1p = smaxp;
// slope
a1p,0 = Ns/(γp.Nν);
// intercept
a0p,0 = νLp/Nν − a1p,0.ρ0p/Ns;
}

Noise Injection

As previously described, the encoder (200) includes a noise injection block (202) that injects film-grain noise to the HDR luma channel. After noise is injected, the HDR image is forward-reshaped to generate a BL signal using the determined reshaping functions. As one particular example for noise injection and forward reshaping, the following pseudocode is presented using a C-like format:

// inject noise to luma plane in the non-letterbox region
// recall active image-content between rows (rminv, rmaxv) and columns (cminv, cmaxv),
OFFSET = rminv * W + cminv;
for ( y = rminv; y <= rmaxv; y++ ){
for ( x = cminv; x <= cmaxv; x++ ){
ptr = (x + n) * W + (y + m)
vptrY = vptrY +   .Ξptr
}
}
// luma reshaping
for (i = 0; i < W H; i++) {
siY = TCbF (viY);
}
// chroma reshaping
for (i = 0; i < W H /4; i++) {
siCb = TCbF(viCb);
siCr = TCrF(viCr);
}

Here, ρ is the fixed maximum noise strength and Ξ_i is ith pixel value of normalized [−1,1] noise image. The noise image is generated using a pseudo-random number as index to select an image from noise-image bank, pre-computed and stored.

Linear Encoding Architecture

In some implementations, reshaping methods described herein are implemented using linear encoding architecture. One example of linear encoding architecture is provided in WIPO Publication No. WO2019/169174, “Linear Encoder for image/video processing,” by N. J. Gadgil and G-M Su, which is incorporated herein by reference in its entirety.

The above video delivery systems and methods may provide for encoding high dynamic range (HDR) video data using reshaping functions. Systems, methods, and devices in accordance with the present disclosure may take any one or more of the following configurations.

(1) A video delivery system for context-based encoding of video data, the delivery system comprising: a processor to perform encoding of video data, the processor configured to: receive the video data, the video data composed of a plurality of image frames, each image frame including a plurality of pixel blocks, determine, for each pixel block, a luma bin index, determine, for each luma bin, a banding risk value, determine Gaussian function parameters based on the banding risk value, generate a differential reshaping function using the Gaussian function parameters, compute a luma-based forward reshaping function based on the differential reshaping function, and generate an output image for each image frame by applying the luma-based forward reshaping function to the respective image frame.

(2) The video delivery system according to (1), wherein the Gaussian function includes a mean value and a width value, and wherein the mean value and the width value are each based on the banding risk value.

(3) The video delivery system according to any one of (1) to (2), wherein the processor is further configured to: determine a backwards reshaping function based on the luma-based forward reshaping function.

(4) The video delivery system according to (3), wherein the backwards reshaping function is approximated in the form of an 8-piece 1st order polynomial curve.

(5) The video delivery system according to any one of (1) to (4), wherein the processor is further configured to: determine maximum and minimum pixel values from luma and chroma channels of each of the plurality of image frames, and identify a letterbox within each of the plurality of image frames.

(6) The video delivery system according to any one of (1) to (5), wherein the processor is further configured to: compute, for each pixel block, a mean for luma pixel values included in the pixel block, and compute, for each pixel block, a standard deviation for luma pixel values included in the pixel block.

(7) The video delivery system according to (6), wherein the banding risk value determined for each luma bin is determined based on the mean and the standard deviation for luma pixel values included in each pixel block.

(8) The video delivery system according to any one of (1) to (7), wherein the processor is further configured to: compute a block histogram by counting a number of pixels that have a first block-mean bin index, and compute a block standard deviation by averaging standard deviation over all pixel blocks that have the first block-mean bin index.

(9) A method for context-based encoding of video data, the method comprising: receiving the video data, the video data composed of a plurality of image frames, each image frame including a plurality of pixel blocks, determining, for each pixel block, a luma bin index, determining, for each luma bin, a banding risk value, determining Gaussian function parameters based on the banding risk value, generating a differential reshaping function using the Gaussian function parameters, computing a luma-based forward reshaping function based on the differential reshaping function, and generating an output image for each image frame by applying the luma-based forward reshaping function to the respective image frame.

(10) The method according to (9), wherein the Gaussian function includes a mean value and a width value, and wherein the mean value and the width value are each based on the banding risk value.

(11) The method according to any one of (9) to (10), further comprising: determining a backwards reshaping function based on the luma-based forward reshaping function.

(12) The method according to (11), wherein the backwards reshaping function is approximated in the form of an 8-piece 1st order polynomial curve.

(13) The method according to any one of (9) to (12), further comprising: determining maximum and minimum pixel values from luma and chroma channels of each of the plurality of image frames, and identifying a letterbox within each of the plurality of image frames.

(14) The method according to any one of (9) to (13), wherein determining, for each pixel block, the luma bin index includes: computing, for each pixel block, a mean for luma pixel values included in the pixel block, and computing, for each pixel block, a standard deviation for luma pixel values included in the pixel block.

(15) The method according to (14), wherein the banding risk value determined for each luma bin is determined based on the mean and the standard deviation for luma pixel values included in each pixel block.

(16) The method according to any one of (9) to (15), wherein determining, for each pixel block, the banding risk includes: computing a block histogram by counting a number of pixels that have a first block-mean bin index, and computing a block standard deviation by averaging standard deviation over all pixel blocks that have the first block-mean bin index.

(17) The method according to any one of (9) to (16), further comprising: adding noise to each image frame.

(18) The method according to any one of (9) to (17), wherein the differential reshaping function defines a number of codewords allocated to a given luminance range.

(19) The method according to any one of (9) to (18), further comprising: setting a floor value of the differential reshaping function.

(20) A non-transitory computer-readable medium storing instructions that, when executed by an electronic processor, cause the electronic processor to perform operations comprising the method according to any one of (9) to (19).

With regard to the processes, systems, methods, heuristics, etc. described herein, it should be understood that, although the steps of such processes, etc. have been described as occurring according to a certain ordered sequence, such processes could be practiced with the described steps performed in an order other than the order described herein. It further should be understood that certain steps could be performed simultaneously, that other steps could be added, or that certain steps described herein could be omitted. In other words, the descriptions of processes herein are provided for the purpose of illustrating certain embodiments, and should in no way be construed so as to limit the claims.

Accordingly, it is to be understood that the above description is intended to be illustrative and not restrictive. Many embodiments and applications other than the examples provided would be apparent upon reading the above description. The scope should be determined, not with reference to the above description, but should instead be determined with reference to the appended claims, along with the full scope of equivalents to which such claims are entitled. It is anticipated and intended that future developments will occur in the technologies discussed herein, and that the disclosed systems and methods will be incorporated into such future embodiments. In sum, it should be understood that the application is capable of modification and variation.

All terms used in the claims are intended to be given their broadest reasonable constructions and their ordinary meanings as understood by those knowledgeable in the technologies described herein unless an explicit indication to the contrary is made herein. In particular, use of the singular articles such as “a,” “the,” “said,” etc. should be read to recite one or more of the indicated elements unless a claim recites an explicit limitation to the contrary.

The Abstract of the Disclosure is provided to allow the reader to quickly ascertain the nature of the technical disclosure. It is submitted with the understanding that it will not be used to interpret or limit the scope or meaning of the claims. In addition, in the foregoing Detailed Description, it can be seen that various features are grouped together in various embodiments for the purpose of streamlining the disclosure. This method of disclosure is not to be interpreted as reflecting an intention that the claimed embodiments incorporate more features than are expressly recited in each claim. Rather, as the following claims reflect, inventive subject matter lies in fewer than all features of a single disclosed embodiment. Thus, the following claims are hereby incorporated into the Detailed Description, with each claim standing on its own as a separately claimed subject matter.

Various aspects of the present invention may be appreciated from the following enumerated example embodiments (EEEs):

EEE1. A video delivery system for context-based encoding of video data, the delivery system comprising:

• • a processor to perform encoding of video data, the processor configured to:
    • receive the video data, the video data composed of a plurality of image frames, each image frame including a plurality of pixel blocks;
    • determine, for each pixel block, a luma bin index;
    • determine, for each luma bin, a banding risk value;
    • determine Gaussian function parameters based on the banding risk value;
    • generate a differential reshaping function using the Gaussian function parameters;
    • compute a luma-based forward reshaping function based on the differential reshaping function; and
    • generate an output image for each image frame by applying the luma-based forward reshaping function to the respective image frame.EEE2. The video delivery system of EEE1, wherein the Gaussian function includes a mean value and a width value, and wherein the mean value and the width value are each based on the banding risk value.EEE3. The video delivery system of EEE1, wherein the processor is further configured to:
  • determine a backwards reshaping function based on the luma-based forward reshaping function.EEE4. The video delivery system of EEE3, wherein the backwards reshaping function is approximated in the form of an 8-piece 1st order polynomial curve.EEE5. The video delivery system of EEE1, wherein the processor is further configured to:
  • determine maximum and minimum pixel values from luma and chroma channels of each of the plurality of image frames; and
  • identify a letterbox within each of the plurality of image frames.EEE6. The video delivery system of EEE1, wherein the processor is further configured to:
  • compute, for each pixel block, a mean for luma pixel values included in the pixel block; and
  • compute, for each pixel block, a standard deviation for luma pixel values included in the pixel block.EEE7. The video delivery system of EEE6, wherein the banding risk value determined for each luma bin is determined based on the mean and the standard deviation for luma pixel values included in each pixel block.EEE8. The video delivery system of EEE1, wherein the processor is further configured to:
  • compute a block histogram by counting a number of pixels that have a first block-mean bin index; and
  • compute a block standard deviation by averaging standard deviation over all pixel blocks that have the first block-mean bin index.EEE9. A method for context-based encoding of video data, the method comprising:
  • receiving the video data, the video data composed of a plurality of image frames, each image frame including a plurality of pixel blocks;
  • determining, for each pixel block, a luma bin index;
  • determining, for each luma bin, a banding risk value;
  • determining Gaussian function parameters based on the banding risk value;
  • generating a differential reshaping function using the Gaussian function parameters;
  • computing a luma-based forward reshaping function based on the differential reshaping function; and
  • generating an output image for each image frame by applying the luma-based forward reshaping function to the respective image frame.EEE10. The method of EEE9, further comprising:
  • storing a normalized base-layer codeword as a single-channel forward reshaping function.EEE11. The method of EEE9, further comprising:
  • determining a backwards reshaping function based on the luma-based forward reshaping function.EEE12. The method of EEE11, wherein the backwards reshaping function is approximated in the form of an 8-piece 1st order polynomial curve.EEE13. The method of EEE9, further comprising:
  • determining maximum and minimum pixel values from luma and chroma channels of each of the plurality of image frames; and
  • identifying a letterbox within each of the plurality of image frames.EEE14. The method of EEE9, wherein determining, for each pixel block, the luma bin index includes:
  • computing, for each pixel block, a mean for luma pixel values included in the pixel block; and
  • computing, for each pixel block, a standard deviation for luma pixel values included in the pixel block.EEE15. The method of EEE14, wherein the banding risk value determined for each luma bin is determined based on the mean and the standard deviation for luma pixel values included in each pixel block.EEE16. The method of EEE9, wherein determining, for each luma bin, the banding risk includes:
  • computing a block histogram by counting a number of pixels that have a first block-mean bin index; and
  • computing a block standard deviation by averaging standard deviation over all pixel blocks that have the first block-mean bin index.EEE17. The method of EEE9, further comprising:
  • adding noise to each image frame.EEE18. The method of EEE9, wherein the differential reshaping function defines a number of codewords allocated to a given luminance range.EEE19. The method of EEE9, further comprising:
  • setting a floor value of the differential reshaping function.EEE20. A non-transitory computer-readable medium storing instructions that, when executed by an electronic processor, cause the electronic processor to perform operations comprising the method of EEE9.

Claims

1. A video delivery system for encoding of HDR video data, the delivery system comprising: a processor to perform encoding of HDR video data, the processor configured to: receive the HDR video data, the HDR video data composed of a plurality of image frames, each image frame including a plurality of pixel blocks;compute, for each pixel block k, a mean for luma pixel values included in the pixel block k;compute, for each pixel block k, a standard deviation for luma pixel values included in the pixel block k;determine, for each pixel block k, a block-mean bin index bk, wherein the entire HDR luma codeword range is divided into NB non-overlapping luma bins, wherein each luma bin b represents a corresponding discrete luma codeword range, and wherein the block-mean bin index bk is the floor function of multiplying the mean for luma pixel values included in the pixel block k with NB;compute, for each luma bin b, a block histogram by counting a number of pixels that have a block-mean bin index bk equal to b;compute, for each luma bin b, a block standard deviation by averaging standard deviation over all pixel blocks that have a block-mean bin index bk equal to b;determine, for each luma bin b, a banding risk value, wherein the banding risk value is determined using a multiplicative combination of the block histogram and the block standard deviation of the respective luma bin;determine a Gaussian function defined by Gaussian function parameters including a mean value and a width value of a corresponding Gaussian distribution, wherein the width value is the reciprocal of the doubled square of the standard deviation of the Gaussian distribution, wherein the mean value of the Gaussian function parameters is set to the maximum banding risk value across all luma bins;generate a differential reshaping function using the Gaussian function parameters, the differential reshaping function specifying the amount of increment to the next lower input value of the differential reshaping function;compute a luma-based forward reshaping function based on the differential reshaping function, wherein the luma-based forward reshaping function is a monotonically non-decreasing function that transfers a higher bit-depth codeword to a lower bit-depth by using the differential reshaping function; andgenerate an output image for each image frame by applying the luma-based forward reshaping function to the respective image frame.

2. The video delivery system according to claim 1, wherein the width value of the Gaussian function parameters is selected based on image statistics such that the most banding prone luminance range is covered by the Gaussian function.

3. The video delivery system according to claim 1, wherein the processor is further configured to: store a normalized base-layer codeword as a single-channel forward reshaping function.

4. The video delivery system according to claim 1, wherein the processor is further configured to: determine a backwards reshaping function based on the luma-based forward reshaping function.

5. The video delivery system according to claim 4, wherein the backwards reshaping function is approximated in the form of an 8-piece 1st order polynomial curve.

6. The video delivery system according to claim 1, wherein the differential reshaping function defines a number of codewords allocated to a given luminance range.

7. A method for encoding of HDR video data, the method comprising: receiving the HDR video data, the HDR video data composed of a plurality of image frames, each image frame including a plurality of pixel blocks;computing, for each pixel block k, a mean for luma pixel values included in the pixel block k;computing, for each pixel block k, a standard deviation for luma pixel values included in the pixel block k;determining, for each pixel block k, a block-mean bin index index bk, wherein the entire HDR luma codeword range is divided into NB non-overlapping luma bins, wherein each luma bin b represents a corresponding discrete luma codeword range, and wherein the block-mean bin index bk is the floor function of multiplying the mean for luma pixel values included in the pixel block k with NB;computing, for each luma bin b, a block histogram by counting a number of pixels that have a block-mean bin index bk equal to b;computing, for each luma bin b, a block standard deviation by averaging standard deviation over all pixel blocks that have a block-mean bin index bk equal to b;determining, for each luma bin b, a banding risk value, wherein the banding risk value is determined using a multiplicative combination of the block histogram and the block standard deviation of the respective luma bin;determining a Gaussian function defined by Gaussian function parameters including a mean value and a width value of a corresponding Gaussian distribution, wherein the width value is the reciprocal of the doubled square of the standard deviation of the Gaussian distribution, wherein the mean value of the Gaussian function parameters is set to the maximum banding risk value across all luma bins;generating a differential reshaping function using the Gaussian function parameters, the differential reshaping function specifying the amount of increment to the next lower input value of the differential reshaping function;computing a luma-based forward reshaping function based on the differential reshaping function, wherein the luma-based forward reshaping function is a monotonically non-decreasing function that transfers a higher bit-depth codeword to a lower bit-depth by using the differential reshaping function; andgenerating an output image for each image frame by applying the luma-based forward reshaping function to the respective image frame.

8. The method according to claim 7, wherein the width value of the Gaussian function parameters is selected based on image statistics such that that the most banding prone luminance range is covered by the Gaussian function.

9. The method according to claim 7, further comprising: storing a normalized base-layer codeword as a single-channel forward reshaping function.

10. The method of according to claim 7, further comprising: determining a backwards reshaping function based on the luma-based forward reshaping function.

11. The method according to claim 10, wherein the backwards reshaping function is approximated in the form of an 8-piece 1st order polynomial curve.

12. The method according to claim 7, wherein the differential reshaping function defines a number of codewords allocated to a given luminance range.

13. A non-transitory computer-readable medium storing instructions that, when executed by an electronic processor, cause the electronic processor to perform operations comprising the method according to claim 1.