Noise synthesis for digital images

Abstract

Apparatus and methods for providing a software- and hardware-based solution to the problem of noise in synthesized digital images. According to one aspect, a probability image is generated and noise blocks are randomly placed at locations in the probability image, where the locations have probability values that are compared to a threshold criterion, thereby creating a synthesized noise image. Embodiments include generating a synthesized film grain image and a synthesized digital camera noise image.

Description

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application claims the benefit of priority to U.S. Provisional Patent Application No. 62 / 950,466, filed on December 19, 2019, and European Patent Application No. 19218144.4, filed on December 19, 2019, both of which are incorporated herein by reference in their entirety. Technical Field

[0003] The present disclosure relates generally to images and, more particularly, to synthesizing film grain and camera noise in images. Background Art

[0004] As used herein, the term noise synthesis refers to generating a noise effect for a digital image (including a video frame) by means that is different from the way noise normally occurs. Unless otherwise specified in the description herein that a specific meaning is used at any time, it should be inferred that the term can be used in any sense, such as interchangeably.

[0005] Before the advent of digital technology, strips of photographic film were the canvas of traditional photography. This film is a thin sheet of plastic covered with a light-sensitive material (e.g., silver halide) to absorb light emitted or reflected from the subject being photographed. After processing this film, the captured light can be converted into an image. As used herein, "film grain" refers to the visual texture that forms in a processed image due to clouds of dye (or silver particles) receiving sufficient photons. It is an optical phenomenon caused by chemical processes that occur during the processing of the film and depends on both the resolution at which the film is viewed and the type of film stock used.

[0006] Digital photography inherently lacks film grain. However, it is still desirable for both artistic and quality reasons. For example, Hollywood studios prefer their film content to have film grain. For digital images, the film grain pattern must be synthesized and overlaid on the image during post-processing.

[0007] "Camera noise" refers to variations in brightness and / or color (colored specks on the image) in digital images due to the camera's electronics, such as sensor size, exposure time, ISO setting, etc. Camera noise is typically removed from digital images by various techniques to avoid compression problems, but in some cases it is desirable for camera noise to preserve the original "look" that the image had when it was captured.

[0008] As used herein, the term "metadata" relates to any auxiliary information transmitted as part of the encoded bitstream and that assists a decoder in rendering a decoded image. Such metadata may include, but is not limited to, color space or color gamut information, reference display parameters, and auxiliary signal parameters as described herein.

[0009] In practice, a digital image includes one or more color components (e.g., luma Y and chroma Cb and Cr), where each color component is represented by n bits of precision per pixel (e.g., n=8). Using linear luminance encoding, images where n<8 (e.g., color 24-bit JPEG images) are considered standard dynamic range (SDR) images, while images where n>8 can be considered enhanced dynamic range (EDR) images. EDR and high dynamic range (HDR) images can 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.

[0010] As used herein, the term "noise synthesis" includes, but is not limited to, synthesizing noise typically caused by film / video / image capture or development (such as film grain or camera noise) in a digital image. The term may also refer to any noise artificially inserted into a digital image for any purpose.

[0011] The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated, it should not be assumed that any approach described in this section qualifies as prior art simply by virtue of its inclusion in this section. Similarly, unless otherwise indicated, it should not be assumed that the problems identified with respect to one or more approaches in this section were recognized in any prior art based on this section. Summary of the Invention

[0012] The apparatus and method according to the present disclosure provide a solution to the problem of noise in synthesized digital images.According to an embodiment of the present disclosure, synthesized film grain is added to a clean (ie, noise-free) digital sequence.

[0013] The process of synthesizing noise as presented herein has many advantages in image transmission and display. For example, the ability to synthesize noise after transmission allows for the transmission of noise-free compressed images, which can provide improved transmission efficiency (data speed, bandwidth, etc.). Adding synthesized noise to an uncompressed image can reduce the effect of compression artifacts in the displayed image. The use of noise blocks allows for control over film grain size, clarity, and type (noise source mimicry), and the random placement of noise blocks in the image prevents blocking artifacts that would be caused by tiled placement. Furthermore, for hardware-based implementations, the use of line-by-line processing allows for resource-efficient implementation of noise synthesis.

[0014] According to a first aspect of the present disclosure, a computer-based method for creating a synthetic noise image for a digital image is disclosed, the method comprising: providing a plurality of noise block patterns; initializing the noise image; generating a probability image, the probability image comprising a randomly generated probability value at each pixel of the probability image, comparing each probability value in the probability image with a threshold criterion; if the probability value satisfies the threshold criterion, selecting a noise block pattern from the plurality of noise block patterns, the noise block pattern having an anchor point; and if the probability value satisfies the threshold criterion, creating a synthetic noise image by placing the noise block pattern in the noise image so that the anchor point corresponds to a pixel in the probability image that meets the threshold criterion.

[0015] The noise particle block pattern may be randomly selected. The probability values of the probability image may be uniformly distributed probability values. The noise block pattern may include a film grain block pattern. The method may further include aggregating values in regions of the noise image where the noise block patterns overlap. The method may include generating the noise block pattern before generating the noise image, wherein the noise block pattern is generated using an inverse DCT technique. This generation may include removing low-frequency DCT coefficients and / or removing high-frequency DCT coefficients. The sizes of the probability image and the noise image may be determined to match a video frame. The method may include editing the content image by adding the noise image to a channel of the content image. The method may include multiplying values in the noise image by a modulation factor before adding the noise image to the content image. The values may be luminance intensity values of the noise image. The method may include generating a YUV content image based on the edited content image. The method may include generating an RGB content image based on the YUV content image. The method may be executed on a computer program product comprising data encoded to perform the method.

[0016] The method may be run through a noise synthesis module to create a synthesized noise image for a device. The device may include a decoder that decodes an encoded image to create a decoded clean sequence, wherein the decoder is configured to combine the synthesized noise image with the decoded clean sequence to create a rendered image for display. The device may include a modulation curve module that modulates the synthesized noise image before combining it with the decoded clean sequence.

[0017] According to a second aspect of the present disclosure, a device for creating synthetic noise in an image, the device comprising: a line buffer comprising a row from the image; firmware comprising a noise block pattern; a pseudo-random number generator providing random values for pixels in the row; logic for comparing the random values with threshold criteria; an NBMT data storage area comprising a noise block management table; logic for populating the noise block management table based on associating random noise block patterns from the firmware with pixels in the row, wherein the random values associated with the pixels meet the threshold criteria; logic for calculating a noise value for each pixel position in the row of the image based on the noise block management table; and logic for modifying the row based on the noise value.

[0018] The device may include logic for determining a modulation curve from the image, calculating a modulation factor, and applying the modulation factor to the noise value before modifying the row. The pseudo-random noise generator may generate random numbers based on a row index and a random offset value. The image may be a luma channel image or a chroma channel image. The device may include multiple pseudo-random number generators and multiple line buffers for processing the images in parallel.

[0019] According to a third aspect of the present disclosure, a method for generating metadata for a decoder includes: setting a noise category parameter; setting a block size parameter; setting a threshold parameter; and setting a modulation factor curve parameter.

[0020] The method for generating metadata may include setting noise variance parameters, setting a plurality of block pattern parameters, and / or setting noise block management table entry parameters. BRIEF DESCRIPTION OF THE DRAWINGS

[0021] Figure 1 An example decoder system including a noise synthesis module is described in accordance with an embodiment.

[0022] Figure 2A and Figure 2B An exemplary DCT matrix for generating film grain block patterns is illustrated according to an embodiment.

[0023] Figure 3 An example decoder system utilizing synthetic noise generation is described in accordance with an embodiment.

[0024] Figure 4 An example flow diagram of a process for adding noise to the luminance channel of an image is depicted in accordance with an embodiment.

[0025] Figure 5 An example of a brightness modulation curve with a fixed α is shown according to an embodiment.

[0026] Figure 6 An example of a brightness modulation curve with a fixed β is shown according to an embodiment.

[0027] Figure 7 An example of film grain compositing with color conversion is shown according to an embodiment.

[0028] Figure 8 An example of camera noise synthesis with color conversion is shown according to an embodiment.

[0029] Figure 9 An example block diagram for hardware-generated content for injecting synthetic film grain is shown according to an embodiment.

[0030] Figure 10 An example of how each pixel of an image may be evaluated in hardware with respect to film grain is shown according to an embodiment.

[0031] Figure 11 An example 16-bit register is shown for use with a hardware implementation according to an embodiment.

[0032] Figure 12 An example of how to pick block ID bits from a pseudo-random number generator is shown according to an embodiment.

[0033] Figure 13 An example of NBMT to pixel value logic is shown according to an embodiment.

[0034] Figure 14 An example graph comparing a software-based (raw) modulation curve and a hardware-based (piecewise linear) modulation curve is shown according to an embodiment.

[0035] Figure 15 An example block diagram of a hardware implementation of noise synthesis for a digital camera is shown according to an embodiment.

[0036] Figure 16 An example simplified camera noise synthesis system / method for chroma channels is shown according to an embodiment.

[0037] Figure 17 An example unified noise injection architecture for hardware implementation is shown according to an embodiment.

[0038] definition

[0039] Throughout this disclosure, a probabilistic image is defined as a digital image composed of random values.

[0040] Noise refers to random variations in brightness (luminance) and / or color (chrominance) information in a digital image caused by effects other than imaging the environment.

[0041] Film grain refers to the random optical texture on an image, such as would be caused by film processing. Film grain is noise in the luminance channel.

[0042] Grain size refers to the average diameter of the individual particles of film grain.

[0043] Camera noise refers to random optical textures on an image, such as those caused by digital camera hardware. Camera noise is noise in both the luma and chroma channels. Non-synthetic camera noise is caused by a variety of factors, including sensor size, thermal effects, long exposure times, high ISO settings, and more.

[0044] DCT refers to discrete cosine transform, and IDCT refers to inverse discrete cosine transform.

[0045] A digital image is a frame of an image or video represented digitally. DETAILED DESCRIPTION

[0046] Described herein are systems and methods for synthesizing noise, such as film grain or camera noise, onto digital images (including video). In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present disclosure. However, it will be apparent that the presently claimed subject matter may be practiced without these specific details. In other instances, well-known structures and devices are not described in detail in order to avoid unnecessarily obscuring, obscuring, or obfuscating the present disclosure.

[0047] Figure 1 An example architecture for a decoder implementing noise synthesis is depicted. A bitstream (110) is received by the system, transmitting an encoded image (111) and its corresponding metadata (112). A decoder (120) decodes the image into a decoded clean sequence (125). Since the encoded image (111) is produced by removing any noise pre-encoded image, the decoded clean sequence (125) is also (mostly) noise-free. The metadata (112) provides parameters to a noise synthesis module (130) and optionally to a modulation curve module (140). The noise synthesis module (130) uses the metadata (112) to create a synthesized noise image (135). This synthesized noise image (135) can be passed through a modulation curve module (140) to produce a modulated noise image (145). The decoded clean sequence (125) and the modulated noise image (145) (or the synthesized noise image (135) if no modulation is performed) are combined (150) in one or more channels to produce a rendered image (155) for display or for color conversion prior to display.

[0048] Noise synthesis need not be tied to a decoder. For example, a video producer could use noise synthesis for pre-release video production. In the case of a non-decoder implementation, the decoded clean sequence (125) could be substituted for the content image to be edited. For example, the noise image could be synthesized by a colorist and then later modulated before being added to the content image.

[0049] Depending on the desired effect, noise can be in the luma channel, the chroma channel, or both. For example, to simulate film grain, noise can be in the luma channel only. To simulate noise introduced by digital camera hardware, noise can be in both the luma and chroma channels. Various types of noise simulation can be performed by appropriately adjusting metadata parameters.

[0050] Noise can be synthesized for digital images by adding noise block patterns to the image through probabilistic imaging. The idea is to add the block patterns on a pixel-by-pixel basis, rather than dividing the original image into blocks.

[0051] To synthesize a film grain block pattern of size B×B, start with a B×B matrix M of standard normal random numbers (e.g., B=4, 8, etc.). The matrix M represents the 2D DCT coefficients, where the upper left is the DC (frequency=0) coefficient and the lower right is the highest frequency AC (frequency>0) coefficient. The DC coefficient is labeled 1 (210) and the labels increase in a zigzag order, as in Figure 2A This is shown for a 4×4 block example.

[0052] These frequency coefficients can be broadly classified into three bands, namely low, medium and high, e.g. Figure 2B As shown. The mid-frequency band (230) in M is retained, while the low-frequency component (220) and the high-frequency component (240) are removed (or alternatively, only multiple or one low-frequency component (220) are removed). For example, in a 4×4 block, the frequency coefficients labeled 4 to 10 can be retained and the coefficients 1 to 3 and 11 to 16 can be removed. The range of frequency coefficients that can be retained is customizable, wherein at least the coefficient 1 is removed.

[0053] Let M mid Represents the matrix M where only mid-frequency coefficients are kept and low / high coefficients are set to zero. Film grain block G raw By M mid Perform the inverse DCT to construct , as shown in Equation 1.

[0054] G raw =iDCT(M mid ) Equation 1

[0055] The block is normalized by dividing each element by the energy E, and then the block is scaled to the desired multiplier V, as shown in Equation 2.

[0056]

[0057] Th norm is the threshold normalized to the interval [0,1). norm An example value of is 0.1. is the noise variance. The noise variance is an adjustable parameter. An example range for a 16-bit image could be 1000 to 6000.

[0058] Rounding is performed at the end to remove any fractional parts, as shown in Equation 3.

[0059]

[0060] The pseudo code for computing the film grain matrix G is outlined below. The function zigzag() gives the frequency label at each position in the matrix. The range of frequency coefficients to be retained is [f s ,f e ].

[0061]

[0062] Multiple noise patterns with different block sizes can be constructed to be used later to put together a synthetic noise image. 4×4, 8×8, 16×16, and 32×32 are some typical block sizes. The size of the film grain can be changed by modifying the frequency range. If the proportion of frequency coefficients closer to the LF region is greater than the frequency range [f s ,f e ] is significant, the particle size will be larger. Conversely, if the portion of frequency coefficients closer to the HF region is significant, it will produce smaller particles. For the 8×8 block example, the frequency coefficient range [4-10] will produce larger particles compared to [4-36].

[0063] Several noise blocks with different sizes can be precomputed and stored in the block pattern dataset This database can be viewed as a 3D matrix with Q number of 2D noise blocks stacked one after another. If L×L is the maximum size of the film grain block, then The size of is L×L×Q. A vector S with Q elements may be maintained to store the corresponding size of each block in the pattern dataset, ie, S(i)≤L, where i∈[0,Q-1].

[0064] Figure 3An example of constructing a synthetic noise image is shown. In this example, the noise imitates film grain. To construct a synthetic noise image (302) of size H×W from a block pattern (301), we start with a probability image (300) of the same size. Typical noise images of film grain are FHD (Full High Definition, such as 1080p), UHD (Ultra High Definition, such as 4K) and 8K resolutions. The probability image is a matrix with uniform random numbers, for example, in the interval [0,1). A threshold Th is chosen norm (e.g., 0.1), and each entry in the probability image (300) is compared with a threshold. Figure 3 In [ 1 ], circles (310) represent positions with probabilities less than a threshold. Alternatively, the positions can be selected at pixels with probabilities greater than, less than or equal to, or greater than or equal to the threshold. Basically, there is a criterion for comparing the probability value at a given pixel with a threshold. For simplicity, only a few positions are shown, but an actual probability image may have many more positions. Noise blocks are placed at the circles. These positions are denoted by the set Ψ.

[0065] The noise block can be placed so that the position in the probability image is at the upper left corner (320) of the noise block, as Figure 3 Alternatively, the position can be set at the center, other corners, or any specified position relative to the noise block. The point of the noise block corresponding to the position is the "anchor point" of the noise block and can be the same for all noise blocks.

[0066] The block pattern selector (305) will randomly pick the film grain block pattern to be inserted at the position in the set Ψ. This block selector can be a uniform random number generator. After placing the blocks at the appropriate positions, there is a probability that these blocks may overlap, such as Figure 3 As shown in . The cells from the juxtaposed cells in the overlapping blocks are added together. This aggregate value becomes the output noise image (302). Since the overlapping areas are aggregated rather than averaged, the film grain block can be scaled by the multiplier V rather than the noise variance. (See Equation 2.) This prevents the aggregated noise pixel values from becoming too large.

[0067] To synthesize a film grain image I, consider a block pattern dataset At each position in the set Ψ, a block can be randomly picked from the dataset to be inserted into the film grain image. Let r be the index of the randomly selected block at the current position, where r ~ Uniform [0, Q-1]. The size of this block G' is S(r) × S(r), such that A different random number r may be chosen each time there is a new block to be inserted at the current position. The pseudo code for this may be shown as:

[0068]

[0069] G' represents a random block selected for position i, j based on a random number r. In other words, a random number r is selected for each position i, j, and G' is generated as a function of r.

[0070] In the case of synthetic film grain or similar noise, the noise can be quite annoying and intrusive in bright areas of the image. An intensity-based luminance modulation curve reduces the intensity of the noise in these bright areas, making the film grain-infused image more desirable to the viewer. Film grain images are pre-generated, as described in the previous section. These images are then modulated based on the juxtaposed luminance intensity and added to the luminance channel.

[0071] Figure 4 A general method for adding noise to the luminance channel (e.g., Y channel) of an image is shown for purposes of example and not by way of limitation. First, a noise image I is initialized (405). The noise image may have the same dimensions as the Y channel image. Initialization may set all pixel values of the noise image to 0 or some other set value. Next, a probability image P is generated (410), wherein a random value is generated at each position in P. The probability image may have the same dimensions as the noise image. The random value may range from 0 to 1, or between any two values. A position map Ψ (415) is then generated by comparing each probability value for each pixel position in P to a threshold criterion (e.g., less than or equal to a set threshold). For each position in Ψ identified as meeting the threshold criterion, a randomly selected noise block is added to the corresponding pixel position in I. If the block is larger than 1×1, the block may be assigned an anchor point (e.g., the upper left pixel of the block), wherein the block will be anchored to the corresponding pixel position in I. When all identified positions in Ψ have been processed, the aggregation of the added noise blocks forms a composite noise image (425) in I. The synthesized noise image can be modulated (435) by a modulation factor, which can be calculated based on the luminance channel (430). The modulated synthesized noise image can then be added to the luminance channel of the image (440).

[0072] exist Figure 5 and Figure 6Sample luminance modulation curves are shown in . These graphs give the modulation factor for different values of luminance intensity. The modulation factor is a rational number in the range (0,1]. In an embodiment, without limitation, the modulation factor is close to one for low intensity codewords and decreases as the intensity increases. Before adding the film grain pixel to the collocated pixel in the luminance channel, the system can multiply the film grain value by its modulation factor. The modulation factor is derived from the collocated luminance intensity values and the modulation curve. Due to the decaying trend of the curve, the film grain intensity decreases when targeting bright areas in the image.

[0073] Assume that the intensity value of the brightness channel is determined by t As an example, without limitation, the modulation factor curve f(·) can be calculated as shown in Equation 4.

[0074]

[0075] In Equation 4, α and β represent curve parameters.

[0076] Figure 5 Shows the variation of α and β = 2 (B t =16). Curves where α = 0.15 (501), 0.25 (502) and 0.4 (503) are shown.

[0077] Figure 6 Shown is α = 0.25 and varying β (B t =16). Curves where β = 1.0 (601), 2.0 (602) and 4.0 (603) are shown.

[0078] The freedom to choose α or β allows the same equation to be used for different electro-optical transfer functions (EOTFs).

[0079] If Y(i,j)=y ij is the brightness intensity at position (i, j) in the Y channel image, then the noise value at position (i, j) in the noise image can be multiplied by f(y ij ) and added to the brightness channel to get the brightness value of the injected noise

[0080] Figure 7An example of film grain synthesis with color conversion is shown. A probability image (705) is created and locations (710) are selected by comparing the value at each pixel of the probability image (705) to a threshold, in this example, those pixels having values below the threshold. A set of film grain patterns (715) are pre-generated and blocks (720) are randomly selected to be injected into the probability image (725), thereby creating a film grain image (730). The Y (luminance) channel image (735) of the (740) is modulated to create an image with a modulation factor (745) of noise. The film grain image (730) is combined (750) with the modulation factor image to produce a luminance modulated film grain image (755). The luminance modulated film grain image (755) is combined (760) with the Y channel image (735) to produce a Y channel image with added film grain (765). The YUV image including the Y channel with added film grain may be color converted (770) to produce an RGB image with film grain noise added to all channels (775).

[0081] Digital camera noise can be synthesized using Gaussian random numbers. For example, random numbers can be generated from uniform random numbers using a Box Muller Transform or the Marsaglia Polar Method.

[0082] For the Marshallia polar coordinate method for generating Gaussian random numbers from uniform random numbers, it is assumed that u1 and u2 are two uniform random numbers selected from the range [0,1]. If the condition 0<u1 is satisfied 2 +u2 2 <1, then the number are Gaussian random numbers with zero mean and unit standard deviation. Care should be taken to avoid letting the process loop for too long before the condition is met.

[0083] Since digital camera noise can be simulated with Gaussian random numbers, synthesizing a camera noise image boils down to generating a 2D matrix with the dimensions of the image and containing Gaussian random numbers with zero mean. The luminance intensity modulated noise image is as previously discussed. The noise image can then be added to the Y, U, and V channels of the content, followed by an optional color space conversion (e.g., to RGB).

[0084] Figure 8An example of camera noise synthesis with color conversion is shown. This is a further embodiment of noise synthesis, and therefore features common to both embodiments may be omitted from the description, but should be understood to remain common to both embodiments. The Y (luminance) channel (810) of the image is modulated (805) to produce a modulation factor image ("MFI", 815). Three random Gaussian images ("RGI", 820) are generated, one for each channel, and three luminance modulated noise images (830) are generated using the modulation factor image (815). These noise images (830) are added (835) to their corresponding channels (840) in the original image. These channels (840) can then be converted (845) to a different color encoding scheme (850), such as RGB. The luminance modulated noise images (830) represent the pixel-by-pixel multiplication (825) of the MFI image (815) with the RGI image (820) of the corresponding channel.

[0085] When implementing noise synthesis in a hardware (as opposed to software) solution, four factors should be considered for optimization.

[0086] 1. In a software implementation, a noise image is synthesized separately and then added to the luma channel. Due to memory limitations in the hardware, only one pixel of the film grain image is calculated and added directly to the content's luma channel. This approach eliminates any intermediate memory buffers used to store the entire film grain image and saves significant on-chip memory.

[0087] 2. In hardware implementations, images are accessed through line buffers. Line buffers can store lines of an image. Because hardware memory is expensive, the number of line buffers is typically limited, making it impossible to load the entire image into these few line buffers. Reading and writing to memory is also time-consuming. For this reason, hardware solutions should read an image line into the line buffer once, perform the entire processing, and then write the result to memory only once. Reading and writing the same portion of the image into the line buffer multiple times is suboptimal.

[0088] 3. Floating point representations are not hardware friendly, so values are more efficiently processed when in integer format for hardware implementation. Noise block patterns, image pixels, thresholds, etc. can be represented in integer format to allow for simpler hardware implementation. For example, instead of setting probabilities from 0 to 1 (real numbers), they can be set from 0 to 255 (integers).

[0089] 4. The block size in the hardware implementation is fixed (eg, all blocks are 8x8) to achieve consistency across all decoder hardware chips. In the remaining description, the fixed block size will be represented by BxB.

[0090] To optimize the system for a hardware implementation, the noise synthesis algorithm can be adjusted to take these factors into account.

[0091] Figure 9 An example block diagram of hardware-generated content with injected noise (in this case, film grain) is shown. Film grain (945) is added only to the Y (luminance) channel (955), but other noise injection techniques can also include the V and U channels. The processor clock (timestamp / date / time of day / etc.) can be used as a frame-level random seed (905). This random seed is used to initialize all row-level pseudo-random number generators (910). Each pixel is evaluated for film grain (920) and then added (940) to the luminance channel (925) of the content after modulation (930, 935). The film grain-added content (956) is finally converted (960) to RGB (965) for display (970).

[0092] Figure 10 This example shows how each pixel can be evaluated in terms of film grain. For the film grain block pattern dataset, a uniform block size of B×B is assumed. Different block sizes will contribute to varying film grain size, but the same effect can be achieved by varying the frequency range of equally sized blocks. Therefore, to reduce the number of variables, the block size of the film grain pattern can be set to a fixed size when implemented in hardware. The film grain block pattern can be generated using the same scheme described for the software implementation. Figure 10 The steps for generating the film grain value at column C (1050) in row R are shown.

[0093] There is no explicit probability image in the hardware solution. Instead, there is a pseudo-random number (PRN) sequence generator (1010 to 1015) for each row of the image. For each entry (pixel) in row R, the PRN module generates a new random number. The PRN (1005) can be selected from a function of the row index and a random offset. If the random number is less than a threshold (1020) and there is enough space in the noise block management table (NBMT) (1090), a film grain block (1070) is randomly selected from the set of film grain patterns (1030) to be inserted starting at this position (1065). The block is not added directly to the image, but the system places the entry (1025) of the block in the NBMT (1090). The NBMT to pixel value logic block (1035) calculates the noise value at the current position in the luminance channel image (1045). For the hardware implementation, the threshold Th is not normalized, thereby reducing computational cost. The non-normalized threshold is denoted without the subscript "norm" in the notation and is given by the equation Related to the normalization threshold.

[0094] The reason for using the pseudo-random number generator from the previous row when calculating the noise value at the current position is efficiency. If B (the noise block size) is significantly large, then reading / writing B rows on each pass will significantly increase memory input / output (I / O) and hardware costs due to the need for B line buffers in memory.

[0095] In contrast, the current solution requires only one line buffer, regardless of the block size. For a given position, there may be overlapping blocks from previous lines. These blocks are represented by Figure 10 The dashed squares (e.g., 1070) in the image (1060) are represented. Since the random seed for each PRN generator is deterministic, the random number sequences used in the previous rows can be regenerated. These sequences provide the exact locations of the blocks and block patterns used in the previous rows. This information allows the correct film grain value at any position to be calculated using only one line buffer, thereby reducing I / O latency and hardware cost. A noise block management table (990) is maintained for each row to record overlapping blocks.

[0096] Despite Figure 10 The original and film grain injected luminance channel rows R are shown separately in , but the original rows R can be updated in place to obtain the film grain injected rows R.

[0097] Film grain block patterns are generated using a process similar to that described for software-based solutions. Since the mechanism used to calculate these block patterns requires the use of complex mathematical operations, this task can be handed over to firmware. The synthesized blocks can later be stored in on-chip SRAM for easy hardware access.

[0098] Another major challenge for hardware implementation is the random number generator. For a faster implementation, a pseudo-random number generator based on a linear feedback shift register can be used. Some of the bits in those random numbers are used to select a film grain block from a data set of block patterns.

[0099] Linear feedback shift registers are often used to generate random number sequences in hardware chips. Consider Figure 11 The next random number is obtained by right-shifting the contents of the register by 1 and inserting a new bit at the most significant bit (MSB) position (1110). The new bit is the exclusive OR (XOR) of the bits at some predefined position (1120) in the register. Figure 11 In the example shown in , an XOR operation is performed on the bits at index positions 3, 12, 14, and 15. The output of the XOR gate (1115) is fed into the MSB position (1110).

[0100] If the tap point locations are chosen appropriately, the register will cycle through all different 16-bit numbers before returning to the same number. In other words, the sequence repeats itself after a certain period. As you can see, the next random number is a function of the register's current state. Therefore, care must be taken to ensure the register is not initialized to all zeros. In that case, the process will become locked in that state.

[0101] The hardware implementation does not explicitly generate a probability image of size H×W. As a temporary workaround, a linear feedback shift register can be used to generate the random numbers in each row. The shift register assigned to each row is initialized with a different random seed. This seed is a function of the row index R and the random offset, Seed R =(Const+R×Offset)mod 2 D , where D is the length of the register. The random offset is derived from the current timestamp, and the constant is set to any large number, such as 2 of a 16-bit shift register. 14 The offset is chosen randomly, but it is fixed for each row in the current frame. Although there is a different pseudo-random number generator for each row, at any given point in time, there are no more than B shift registers in the hardware. Here, B×B is the size of the blocks in the block pattern dataset.

[0102] The seed is deterministic as a constant, the offset and row index are known. The idea behind making this seed deterministic is to regenerate the random number sequence that has been passed through the previous rows when processing the current row R. This allows determining the position of overlapping film grain blocks from the previous rows and using that knowledge to calculate the film grain value at the current position.

[0103] Together with the random sequence generator, a table can be used to store information about the position of blocks in the previous row. This table is called the Noise Block Management Table (NBMT).

[0104] NBMT stores information about the film grain block injected into the luminance channel of a particular line. Each PRN sequence generator (see Figure 10 ) has a corresponding NBMT. The number of entries in the table is a configurable parameter and each entry holds the following three columns, as shown in Table 1.

[0105] Table 1: Noise block management table

[0106] Block ID Position-x Position-y <![CDATA[b i ]]> <![CDATA[x i ]]> <![CDATA[y i ]]>

[0107] In order to calculate the final value at each position, the system needs to consider all blocks that overlap with the position. The noise block management table is created by adding block id b i , the X coordinate of the block's origin x i and the origin Y coordinate yi These overlapping blocks are recorded in the image. For speed and computational efficiency, the maximum number of entries in the table is limited to ceil(B / 4).

[0108] For example, assume that the size of the film grain block pattern is B×B and the system is calculating the film grain injection value at position (C,R) in the luminance channel image of the injected noise. Then, the blocks originating from B-1 rows above or B-1 columns to the left can still affect the current position. For this reason, when processing the current row R, the system considers the B-1 rows above the current row.

[0109] As Figure 10 illustrated, the system initiates a pseudo-random number generator for the B-1 rows above the current row R to find the overlapping blocks. The current row can also have its own random number generator represented by PRN row R. Since the random seed is deterministic, the system can always regenerate the sequence passed by the previous few rows. In addition to the row-specific random number generator, each of these B rows can also have its own NBMT.

[0110] Let C represent the current column in the row R being processed. The row R of the luminance channel image is read into the line buffer. The column C is incremented from C = 0 to C = W-1 in steps of 1. For each value of C, the system can perform the following steps:[[ID=!3]]

[0111] 1. Each of the B random number generators generates a random number. If the number is greater than or equal to the threshold Th, no action is taken. [[ID=!7]]

[0112] 2. Additionally, if the random number is less than the threshold, then

[0113] a. Remove any entries in the NBMT that do not affect the current position. For example, remove the block size B×B, where x i <C-B+1 or y i <R-B+1.

[0114] b. If the NBMT of the row is not full, select a random block from the film grain pattern dataset. The bits from the pseudo-random number generator of the row are used to select the block ID b i . Figure 12 Presents an example of how to pick the block ID bits from the pseudo-random number generator. For a dataset of 16 different block patterns, the block ID PRN[15:12]=7 refers to block ID 7, which is the 7th pattern in the dataset. The sorting starts at index 0.

[0115] c. The entry of the block is added to the NBMT, where x i =C and the origin Y coordinate is equal to the row index. The block ID source is derived from the previous step.

[0116] 3. Calculate the film grain value at position (C, R) from the NBMT of all R rows. This step is called by example in Figure 13 NBMT to pixel value logic shown in Figure 2.

[0117] a. For each entry in each NBMT, check if the block overlaps with the current position (1310). i ≤C≤B+x i -1 and y i ≤R≤B+y i When -1, blocks overlap.

[0118] b. Use the block ID extracted from the PRN generator to select the corresponding block from the block pattern dataset (1320). Pick the value in the block that overlaps with the current position.

[0119] c. There may be multiple such overlapping blocks, so the values are added together (1330).

[0120] d. The value is handed over to the next stage which calculates the luma modulation factor of the noise value (1340). The luma modulated noise value is added (1350) to the original luma (1355) and written to the line buffer at column C (1360).

[0121] 4. Each row goes through this process, one at a time, to get a luminance channel image with film grain injected. For rows that do not have B-1 rows above them, only the available rows are considered.

[0122] For hardware-implemented luma-intensity-based noise modulation techniques, software-implemented nonlinear curves should be replaced with piecewise linear segments to avoid wasting memory cycles on nonlinear arithmetic. The parameters of these segments can be signaled to the decoder in metadata. The system can then calculate the modulation factor for each luma intensity value based on the piecewise linear curve.

[0123] Furthermore, the values in the curves for the software implementation are decimals. In hardware, manipulating decimals is cumbersome. Therefore, the curve The values in can be obtained in the piecewise linear approximation method, i.e. in Previously scaled to B c = 8-bit integer. Then use T+1 pivot points to transform the curve f hw (·) is divided into T segments. Let the position of the pivot point be represented by the vector Ω, such that Where 0≤k≤T.

[0124] For every two pivots on the curve, i.e., x1=Ω(k) and x2=Ω(k+1), the system calculates the connection point y1=f hw(x1) and y2 = f hw The equation of the kth line segment of (x2). The equation of a line has three parameters, the slope, the X-intercept (x1), and the Y-intercept (y1).

[0125]

[0126] y-y1=slope k ×(x-x1) Equation 6

[0127] The slope, pivot and Y intercept parameters for each segment are sent to the decoder. The curve is reconstructed at the decoder to calculate the modulation factor for each brightness intensity. For illustration, Figure 14 The original (software-based) and piecewise linear curves are plotted with α = 0.25 and β = 2. If Y(C,R) = y CR is the brightness intensity at position (C, R) in the Y channel image, then the noise value, that is, n CR Multiply by f(y CR ) and is added to the luminance channel to get the luminance value of the injected noise Since the modulation factor is B c The product of the film grain value and the modulation factor can be right-shifted by B. c The units digit is used to get the correct brightness modulated film grain value.

[0128] Similar to film grain noise, the hardware implementation of digital camera noise has several limitations.

[0129] 1. Synthesizing Gaussian random numbers in hardware is expensive due to the log functions involved. As a workaround, these numbers can be generated in firmware and stored as a digital camera noise block.

[0130] 2. Due to memory limitations, it is expensive to store digital camera noise images in on-chip memory. Noise pixels can be calculated and added directly to the Y, U, and V channels after modulation.

[0131] 3. Read only a few lines of the Y, U, and V channels into memory as line buffers for processing. Because image sizes can be enormous, processing the entire image would be I / O and memory intensive. Line buffers would help alleviate latency and memory requirements. However, the architecture would require significant changes to achieve similar results to a software solution.

[0132] 4. Floating point arithmetic is more complex for hardware implementation, so all values are converted to fixed point format. Some changes to the architecture are necessary when moving from floating point to fixed point arithmetic.

[0133] 5. The block size of the digital camera noise pattern can be fixed to 1×1 (B=1), which basically means that the system only adds one Gaussian random number at each position. This is consistent with the software solution.

[0134] One embodiment of digital camera noise synthesis in hardware limits the block size of the digital camera noise pattern to 1×1, and sets the probability threshold of row R to 2 D , while the other rows have a threshold of zero. Set the probability threshold to 2 D Make sure that the block is added to every pixel position in the Y channel. Since the block size is restricted to 1×1, there is no overlap between blocks. Therefore, there is only one entry in the NMBT for row R.

[0135] Each row has a pseudo-random number generator. When processing row R and column C, if the pseudo-random number is less than 2 D , the system adds a digital camera block to the pixel. Since these random numbers are always less than 2 D , the system adds a Gaussian random number at each position. A leading bit from a pseudo-random number generator is used to randomly select a block. The block's information can be inserted into the NBMT for that row. The NBMT-to-pixel value logic calculates the digital camera noise value. This value is modulated with the modulation factor and added to column C of the line buffer. For a block size of 1×1, B=1, and the NBMT-to-pixel value logic is simple because adjacent blocks do not overlap. Figure 15 An example block diagram showing a hardware implementation of noise synthesis for a digital camera, which can be described as Figure 10 special circumstances.

[0136] Digital camera noise is also added to the chroma channels, as opposed to film grain which is only added to the luma channel. The architecture used to inject camera noise into both the luma and chroma channels is essentially the same. Figure 15 The hardware architecture simplifies the design of the chroma channel by removing redundant components such as additional pseudo-random number generators, threshold blocks, NBMT and NBMT to pixel value logic, such as Figure 16 as shown in the example.

[0137] For example, assume there is a 1024-block pattern of digital camera noise. Then the first 10 bits of the PRN row R can be used to calculate the block index b i A 1×1 block is picked from the dataset, modulated with the luma intensity and added to the chroma channel line buffer at the current position.

[0138] For YUV 444 sequences, the modulation factor can be calculated based on the juxtaposed intensity in the luma channel. The noise value is added to the chroma channels after modulation. In other words, the noise value is first modulated with the luma intensity and then added to the chroma channels.

[0139] For YUV 422 sequences, the Y channel can be subsampled to half the width, and then the modulation factor is calculated based on the juxtaposed pixels in the Y channel. The noise value is modulated with the downsampled brightness intensity and then added to the chrominance channel. Downsampling using traditional filtering methods can be expensive for hardware. But the modulation factor can work together with rough and approximate downsampling. In order to reduce hardware complexity, the brightness channel is subsampled by simply averaging the adjacent elements in the brightness channel row. The process is elaborated in the following pseudo code. Symbol Y hh Represents a horizontally downsampled version of the luma channel Y obtained by taking the average of adjacent elements in the same row.

[0140]

[0141] Figure 17 An example unified noise injection architecture is shown that allows for hardware implementations of multiple types of noise to be synthesized (in this example, film grain and camera noise). A pseudo-random number generator (1710) can produce a sequence of random numbers. If these random numbers meet a threshold condition, an aggregate noise value is calculated (1720) using either a film grain (1721) or digital camera noise (1722) block data set, depending on whether a determination is made (1715) on what type of noise is desired. The value is modulated (1730) by the luma intensity and added to the original luma or chroma channel. One row is processed at a time (1740), so the line buffer only needs to be large enough to accommodate a row of YUV content. The YUV content into which the noise is injected is converted (1750) to RGB for display.

[0142] There are two different scenarios in which the noise injection model is used to inject noise into content. In the first scenario, the content provider can control the appearance of the noise added to the video. The parameters are set at the encoder and transmitted to the decoder as part of the metadata. In the second scenario, the decoder can synthesize the noise based on viewing conditions or display specifications. The content provider's settings can take precedence over local adjustments, and vice versa.

[0143] Noise synthesis parameters can be set at different stages of the workflow, i.e., at the encoder side for content provider preferred settings or at the decoder side for local adaptation. Decoder parameters can be configured in firmware or hardware.

[0144] For artistic reasons, content providers may want to add film grain or camera noise to video sequences to achieve a cinematic effect. Noise is compressed during encoding, and thus, the cinematic effect is reduced at the decoder. Furthermore, compressing a noisy sequence requires a higher bit rate, so sending a noise-free sequence along with the parameters to generate noise at the decoder reduces the bit rate requirement while still preserving the cinematic effect. To this end, there is the option of setting the parameters at the encoder and sending them to the decoder via metadata. The parameters are listed in Table 2.

[0145] Table 2

[0146]

[0147] Parameters can be read from metadata to initialize the noise generation module on the decoder side. Similarly, parameters can be adjusted on the decoder side based on the viewing environment or display specifications. Regardless, the decoder must synthesize noise given a set of parameters. The decoder consists of either firmware or a processor and hardware systems. Firmware can calculate complex mathematical functions at the expense of speed, but hardware can perform low-level logic operations at a much faster rate.

[0148] Due to speed requirements and computational complexity, the task of noise image generation must be split between firmware and hardware. Synthesizing film grain or camera noise blocks is computationally intensive for hardware, so it can be offloaded to firmware. There are only a few block patterns to construct, so these can be easily constructed in firmware during system boot without much processing overhead.

[0149] Example Embodiments

[0150] EE1. A computer-based method for creating a synthetic noise image for a digital image, the method comprising: providing a plurality of noise block patterns; initializing the noise image; generating a probability image, the probability image comprising a randomly generated probability value at each pixel of the probability image, comparing each probability value in the probability image with a threshold criterion; if the probability value satisfies the threshold criterion, selecting a noise block pattern from the plurality of noise block patterns, the noise block pattern having an anchor point; and if the probability value satisfies the threshold criterion, creating a synthetic noise image by placing the noise block pattern in the noise image so that the anchor point corresponds to a pixel in the probability image that meets the threshold criterion.

[0151] EE2. The computer-based method of EE1, wherein the noise particle block pattern is randomly selected.

[0152] EE3. The computer-based method according to EE1 or EE2, wherein the probability values of the probability image are uniformly distributed probability values.

[0153] EE4. The computer-based method of any one of EE1 to EE3, wherein the noise block pattern comprises a film grain block pattern.

[0154] EE5. The computer-based method of any one of EE1 to EE4, further comprising aggregating values in regions of the noise image where the noise block patterns overlap.

[0155] EE6. The computer-based method according to any one of EE1 to EE5, further comprising generating the noise block pattern before generating the noise image, wherein the noise block pattern is generated by an inverse DCT technique.

[0156] EE7. The computer-based method of EE6, wherein the generating further comprises removing low-frequency DCT coefficients.

[0157] EE8. A computer-based method as described in EE6 or EE7, wherein the generating further includes removing high-frequency DCT coefficients.

[0158] EE9. The computer-based method of any one of EE1 to EE8, wherein the size of the probability image and the noise image is set to match the video frame.

[0159] EE10. The computer-based method according to any one of EE1 to EE9, further comprising: editing the content image by adding the noise image to a channel of the content image.

[0160] EE11. The computer-based method of EE10, further comprising: multiplying the values in the noise image by a modulation factor before adding the noise image to the content image.

[0161] EE12. The computer-based method of EE11, wherein the value is a brightness intensity value of the noise image.

[0162] EE13. The computer-based method according to any one of claims EE10 to EE12, further comprising: generating a YUV content image based on the edited content image.

[0163] EE14. The computer-based method according to EE13 further comprises generating an RGB content image based on the YUV content image.

[0164] EE15. A device comprising: a decoder that decodes an encoded image to create a decoded clean sequence; a noise synthesis module that performs a method as described in any one of EE1 to EE14 to create a synthesized noisy image; wherein the decoder is configured to combine the synthesized noisy image with the decoded clean sequence to create a rendered image for display.

[0165] EE16. The apparatus according to EE15, further comprising a modulation curve module for modulating the synthesized noise image before combining with the decoded cleaning sequence.

[0166] EE17. A computer program product comprising data coded to perform the method according to any one of EE1 to EE14 when executed on a processor.

[0167] EE18. A device for creating synthetic noise in an image, the device comprising: a line buffer comprising a row from the image; firmware comprising a noise block pattern; a pseudo-random number generator providing random values for pixels in the row; logic for comparing the random values to threshold criteria; a data storage area comprising a noise block management table; logic for populating the noise block management table based on associating random noise block patterns from the firmware with pixels in the row, wherein the random values associated with the pixels meet the threshold criteria; logic for calculating a noise value for each pixel position in the row of the image based on the noise block management table; and logic for modifying the row based on the noise value.

[0168] EE19. The apparatus of EE18, further comprising logic for determining a modulation curve from the image, calculating a modulation factor, and applying the modulation factor to the noise value before modifying the row.

[0169] EE20. The device according to EE18 or EE19, wherein the pseudo-random noise generator generates a random number based on a row index and a random offset value.

[0170] EE21. The apparatus according to any one of EE18 to EE20, wherein the image is a luminance channel image.

[0171] EE22. An apparatus as described in any one of EE18 to EE20, wherein the image is a chroma channel image.

[0172] EE23. The device according to any one of EE18 to EE22, further comprising a plurality of pseudo-random number generators and a plurality of line buffers for processing the image in parallel.

[0173] EE24. A decoder system comprising: a decoder that decodes an encoded image to create a decoded clean sequence; a noise synthesis module that includes a device as described in any one of EE18 to EE23 to create a synthesized noisy image; wherein the decoder is configured to combine the synthesized noisy image with the decoded clean sequence to create a rendered image for display.

[0174] EE25. A method for generating metadata for a decoder, the method comprising: setting a noise category parameter; setting a block size parameter; setting a threshold parameter; and setting a modulation factor curve parameter.

[0175] EE26. The method as described in EE25 further includes setting a noise variance parameter.

[0176] EE27. The method according to any one of EE25 to EE26, further comprising setting a discrete cosine transform frequency range parameter.

[0177] EE28. The method according to any one of EE25 to EE27, further comprising setting a plurality of block pattern parameters.

[0178] EE29. The method according to any one of EE25 to EE28, further comprising setting noise block management table entry parameters.

[0179] A number of embodiments of the present disclosure have been described. However, it will be appreciated that various modifications may be made without departing from the spirit and scope of the present disclosure. Therefore, other embodiments are within the scope of the appended claims. Any significant features of the present embodiments are common to all embodiments, where appropriate.

[0180] The examples set forth above are provided to those skilled in the art as a complete disclosure and description of how to make and use the embodiments of the disclosure, and are not intended to limit the scope of what the inventor / inventors regard as their disclosure.

[0181] Modifications of the above-described schemes for implementing the methods and systems disclosed herein that are obvious to those skilled in the art are intended to fall within the scope of the appended claims. All patents and publications mentioned in the specification are indicative of the level of skill of those skilled in the art to which the present disclosure pertains. All references cited in this disclosure are incorporated by reference to the same extent as if each reference had been individually incorporated by reference in its entirety.

[0182] It will be understood that the present disclosure is not limited to a particular method or system, which may of course vary. It will also be understood that the terms used herein are for the purpose of describing particular embodiments only and are not intended to be limiting. Unless the content clearly dictates otherwise, as used in this specification and the appended claims, the singular forms "a," "an," and "the" include plural referents. Unless the content clearly dictates otherwise, the term "plurality" includes two or more referents. Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by those of ordinary skill in the art to which the present disclosure belongs.

Claims

1. A computer-based method for creating a synthetic noise image for a digital image, the method comprising: Providing multiple noise block patterns; Initialize the noise image; generating a probability image comprising a randomly generated probability value at each pixel of the probability image, comparing each probability value in the probability image with a threshold criterion; selecting a noise block pattern from the plurality of noise block patterns if the probability value satisfies the threshold criterion, the noise block pattern having an anchor point; as well as If the probability value meets the threshold criterion, a synthetic noise image is created by placing the noise block pattern in the noise image such that the anchor point corresponds to a pixel in the probability image that meets the threshold criterion.

2. The method according to claim 1, wherein The noise block pattern is randomly selected.

3. The method according to claim 1 or 2, wherein The probability values of the probability image are uniformly distributed probability values.

4. The method according to claim 1 or 2, wherein The noise block pattern includes a film grain block pattern.

5. The method of claim 1 or 2, further comprising aggregating values in regions of the noise image where the noise block patterns overlap.

6. The method of claim 1 or 2, further comprising generating the noise block pattern before generating the noise image, wherein The noise block pattern is generated by an inverse DCT technique.

7. The method according to claim 6, wherein: The generating further includes removing low frequency DCT coefficients.

8. The method of claim 6, wherein: The generating further includes removing high frequency DCT coefficients.

9. The method according to claim 1 or 2, wherein: The sizes of the probability image and the noise image are set to match the video frame.

10. The method of claim 1 or 2, further comprising: The content image is edited by adding the noise image to a channel of the content image.

11. The method of claim 10, further comprising: Values in the noise image are multiplied by a modulation factor before being added to the content image.

12. The method of claim 11, wherein: The value is the brightness intensity value of the noise image.

13. The method of claim 10, further comprising: A YUV content image is generated based on the edited content image.

14. The method of claim 13, further comprising: An RGB content image is generated based on the YUV content image.

15. An apparatus for creating a rendered image for display, comprising: a decoder for decoding the encoded image to create a decoded clean sequence; a noise synthesis module, configured to perform the method according to any one of claims 1 to 14 to create a synthesized noise image; Wherein the decoder is configured to combine the synthesized noisy image with the decoded clean sequence to create the rendered image for display.

16. The apparatus of claim 15, further comprising a modulation curve module to modulate the synthesized noise image prior to combining with the decoded cleaning sequence.

17. A computer program product comprising data coded to perform the method of any one of claims 1 to 14 when run on a processor.

18. A computer-readable storage medium storing computer-executable instructions which, when executed by a processor, cause the processor to perform the method of any one of claims 1-14.

19. An apparatus for creating synthetic noise in an image, the apparatus comprising: a line buffer comprising lines from the image; firmware, the firmware including a noise block pattern; a pseudo-random number generator for providing random values for pixels in the row; logic for comparing the random value to a threshold criterion; data storage, the data storage comprising a noise block management table; logic for populating the noise block management table based on associating a random noise block pattern from the firmware with pixels in the row, wherein the random value associated with the pixel meets the threshold criteria; logic for calculating a noise value for each pixel position in the row of the image based on the noise block management table; and Logic is provided for modifying the row based on the noise value.

20. The apparatus of claim 19, further comprising: Logic is used to determine a modulation curve from the image, calculate a modulation factor, and apply the modulation factor to the noise value before modifying the row.

21. The apparatus of claim 19 or 20, wherein The pseudo-random number generator generates a random value based on a row index and a random offset value.

22. The apparatus of claim 19 or 20, wherein The image is a luminance channel image.

23. The apparatus of claim 19 or 20, wherein: The image is a chroma channel image.

24. The apparatus of claim 19 or 20, further comprising a plurality of pseudo-random number generators and a plurality of line buffers for processing the image in parallel.

25. A decoder system comprising: a decoder for decoding the encoded image to create a decoded clean sequence; a noise synthesis module comprising an apparatus as claimed in any one of claims 19 to 24 to create a synthesized noise image; Wherein the decoder is configured to combine the synthesized noisy image with the decoded clean sequence to create a rendered image for display.

Images