Film grain process

Abstract

A decoder capable of obtaining a film grain model syntax element from a parameter set in an encoded data representation. The decoder is capable of determining a film grain model value by decoding the film grain model syntax element. The decoder is capable of decoding a current picture from the encoded data representation. The decoder is capable of generating an output picture by applying the generated film grain to the current picture. The decoder is capable of outputting the output picture.

Description

Technical Field

[0001] The present disclosure generally relates to communications, and more particularly, to communication methods for supporting wireless communications, as well as related devices and nodes. Background Art

[0002] High Efficiency Video Coding ("HEVC") is a block-based video codec standardized by the International Telecommunication Union - Telecommunication ("ITU-T") and the Moving Picture Experts Group ("MPEG"), using both temporal prediction and spatial prediction. Spatial prediction can be achieved using intra ("I") prediction within the current picture. Temporal prediction is achieved using unidirectional ("P") or bidirectional ("B") inter-frame prediction at the block level based on previously decoded reference pictures. In the encoder, the difference between the original pixel data and the predicted pixel data (referred to as the residual) can be transformed into the frequency domain, quantized, and then entropy encoded before being sent together with necessary prediction parameters such as prediction mode and motion vectors, which can also be entropy encoded. The decoder performs entropy decoding, inverse quantization, and inverse transformation to obtain the residual, and then adds the residual to the intra prediction or inter-frame prediction to reconstruct the picture.

[0003] MPEG and ITU-T are developing a successor to HEVC within the Joint Video Exploration Team ("JVET"). The name of this video codec under development is Versatile Video Coding ("VVC").

[0004] A video sequence can include a series of images, where each image includes one or more components. Each component can be described as a two-dimensional rectangular array of sample values. The images in a video sequence can include three components: a luminance component Y and two chrominance components Cb and Cr. The sample values in the luminance component Y are luminance values, and the sample values in the chrominance components are chrominance values. In each dimension, the size of the chrominance component can be 1 / 2 of that of the luminance component. For example, the size of the luminance component of an HD image can be 1920x1080, while the chrominance components can each have a size of 960x540. Components are sometimes referred to as color components.

[0005] A block is a two-dimensional array of samples. In video coding, each component can be divided into blocks, and the encoded video bitstream includes a series of encoded blocks. In video coding, an image can be divided into units that cover specific regions of the image. Each unit includes all the blocks from all the components that make up that specific region, and each block belongs entirely to one unit. Macroblocks in H.264 and coding units ("CUs") in HEVC are examples of units.

[0006] A block may alternatively be defined as a two-dimensional array to which a transform used in encoding is applied. These blocks may be referred to as "transform blocks". Alternatively, a block may be defined as a two-dimensional array to which a single prediction mode is applied. These blocks may be referred to as "prediction blocks". In the present disclosure, the term "block" may not be bound to one of these definitions, but the description herein may apply to either definition.

[0007] A residual block may include samples representing the sample value differences between the sample values of the original source block and the sample values of the prediction block. A spatial transform may be used to process the residual block. In an encoder, transform coefficients may be quantized according to a quantization parameter ("QP"), which may control the precision of the quantized coefficients. The quantized coefficients may be referred to as residual coefficients. A high QP value may result in lower precision of the coefficients and thus lower fidelity of the residual block. A decoder may receive the residual coefficients, apply inverse quantization and inverse transform to derive the residual block. SUMMARY OF THE INVENTION

[0008] According to some embodiments, a method performed by a decoder is provided. The method includes obtaining a film grain model syntax element from a parameter set in an encoded data representation. The method may further include determining a film grain model value by decoding the film grain model syntax element. The method may further include decoding a current picture from the encoded data representation. The method may further include generating an output picture by applying the generated film grain to the current picture. The method may further include outputting the output picture.

[0009] According to other embodiments, a method performed by an encoder is provided. The method includes obtaining a film grain model syntax element from a parameter set in an encoded data representation. The method may further include determining a film grain model value by decoding the film grain model syntax element. The method may further include decoding a current picture from the encoded data representation. The method may further include generating an output picture by applying the generated film grain to the current picture. The method may further include outputting the output picture.

[0010] According to some embodiments, a decoder is provided. The decoder includes a processing circuit and a memory coupled to the processing circuit. The memory includes instructions that, when executed by the processing circuit, cause the decoder to obtain a film grain model syntax element from a parameter set in an encoded data representation. The instructions are further executable to determine a film grain model value by decoding the film grain model syntax element. The instructions are further executable to decode a current picture from the encoded data representation. The instructions are further executable to generate an output picture by applying the generated film grain to the current picture. The instructions are further executable to output the output picture.

[0011] According to other embodiments, an encoder is provided. The encoder includes processing circuitry and a memory coupled to the processing circuitry. The memory includes instructions that, when executed on the processing circuitry, cause the encoder to obtain a film grain model syntax element from a parameter set in an encoded data representation. The instructions are further executable to determine a film grain model value by decoding the film grain model syntax element. The instructions are further executable to decode a current picture from the encoded data representation. The instructions are further executable to generate an output picture by applying the generated film grain to the current picture. The instructions are further executable to output the output picture.

[0012] According to other embodiments, a computer program is provided. The computer program includes program code to be executed by a decoder to obtain a film grain model syntax element from a parameter set in an encoded data representation. The program code can further be executed to determine a film grain model value by decoding the film grain model syntax element. The program code can further be executed to decode a current picture from the encoded data representation. The program code can further be executed to generate an output picture by applying the generated film grain to the current picture. The program code can further be executed to output the output picture.

[0013] According to other embodiments, a computer program is provided. The computer program includes program code to be executed by an encoder to obtain a film grain model syntax element from a parameter set in an encoded data representation. The program code can further be executed to determine a film grain model value by decoding the film grain model syntax element. The program code can further be executed to decode a current picture from the encoded data representation. The program code can further be executed to generate an output picture by applying the generated film grain to the current picture. The program code can further be executed to output the output picture.

[0014] According to other embodiments, a computer program product is provided. The computer program product can include a non-transitory storage medium that includes program code to be executed by processing circuitry of a decoder. Execution of the program code causes the decoder to obtain a film grain model syntax element from a parameter set in an encoded data representation. The program code can further be executed to determine a film grain model value by decoding the film grain model syntax element. The program code can further be executed to decode a current picture from the encoded data representation. The program code can further be executed to generate an output picture by applying the generated film grain to the current picture. The program code can further be executed to output the output picture.

[0015] According to other embodiments, a computer program product is provided. The computer program product may include a non-transitory storage medium including program code to be executed by a processing circuit of an encoder. Execution of the program code causes the encoder to obtain a film grain model syntax element from a parameter set in an encoded data representation. The program code may also be executed to determine a film grain model value by decoding the film grain model syntax element. The program code may also be executed to decode a current picture from the encoded data representation. The program code may also be executed to generate an output picture by applying the generated film grain to the current picture. The program code may also be executed to output the output picture.

[0016] According to other embodiments, a non-transitory computer-readable medium is provided. The non-transitory computer-readable medium may have instructions stored therein that are executable by a processing circuit to cause a decoder to obtain a film grain model syntax element from a parameter set in an encoded data representation. The instructions may also be executable to determine a film grain model value by decoding the film grain model syntax element. The instructions may also be executable to decode a current picture from the encoded data representation. The instructions may also be executable to generate an output picture by applying the generated film grain to the current picture. The instructions may also be executable to output the output picture.

[0017] According to other embodiments, a non-transitory computer-readable medium is provided. The non-transitory computer-readable medium may have instructions stored therein that are executable by a processing circuit to cause an encoder to obtain a film grain model syntax element from a parameter set in an encoded data representation. The instructions may also be executable to determine a film grain model value by decoding the film grain model syntax element. The instructions may also be executable to decode a current picture from the encoded data representation. The instructions may also be executable to generate an output picture by applying the generated film grain to the current picture. The instructions may also be executable to output the output picture.

[0018] The various embodiments described herein enable referring to a previous film grain model for pictures that do not use any pictures for reference and support sharing of film grain model parameter values between pictures at different layers (including both temporal sub-layers and spatial scalability layers). It is also possible to store a single set of film grain parameters for a sequence of multiple pictures. Some embodiments provide potential benefits including significant bit savings for low-bitrate bitstreams in the case of using a film grain model. BRIEF DESCRIPTION OF THE DRAWINGS

[0019] The drawings illustrate certain non-limiting embodiments of the inventive concept and are included to provide a further understanding of the present disclosure and are incorporated into and constitute a part of this application. In the drawings:

[0020] Figure 1 is a table showing an example of the HEVC NAL unit header syntax;

[0021] Figure 2 is a table showing an example of the VVC NAL unit header syntax;

[0022] Figure 3 is a table showing an example of the NAL unit types in VVC;

[0023] Figure 4 is a block diagram showing an example of the relationship between a layer access unit and an encoded layer video sequence;

[0024] Figure 5 is a schematic diagram showing an example of tile partitioning;

[0025] Figure 6 is a schematic diagram showing an example of a rectangular slice;

[0026] Figure 7 is a block diagram showing an example of an output process;

[0027] Figure 8 is a table showing an example of the film grain characteristic SEI message syntax in VVC;

[0028] Figure 9 is a table showing an example of the film grain parameter syntax in AV1;

[0029] Figure 10 is a block diagram showing an example of a film grain model according to some embodiments of the inventive concept;

[0030] Figure 11 is a table showing an example of a film grain enable flag according to some embodiments of the inventive concept;

[0031] Figure 12 is a table showing an example of no film grain constraint flag according to some embodiments of the inventive concept;

[0032] Figure 13 is a table showing an example of a film grain model in the SPS according to some embodiments of the inventive concept;

[0033] Figure 14 is a table showing an example of a film grain model in the APS according to some embodiments of the inventive concept;

[0034] Figure 15 is a table showing an example of a short seed syntax according to some embodiments of the inventive concept;

[0035] Figure 16A table showing examples of long seed grammars according to some embodiments of the inventive concept;

[0036] Figure 17 A block diagram showing examples of film grain grammar elements according to some embodiments of the inventive concept;

[0037] Figure 18 A block diagram showing examples of multi-layer bitstreams according to some embodiments of the inventive concept;

[0038] Figure 19 A table showing examples of seed lengths in parameter sets according to some embodiments of the inventive concept;

[0039] Figure 20 A table showing examples of variable-length seed grammars according to some embodiments of the inventive concept;

[0040] Figure 21 A block diagram showing a terminal device (“UE”) according to some embodiments of the inventive concept;

[0041] Figure 22 A block diagram showing a decoder according to some embodiments of the inventive concept;

[0042] Figure 23 A block diagram showing an encoder according to some embodiments of the inventive concept; and

[0043] Figures 24 to 26 A flowchart showing an example of the operation of a decoder or encoder according to some embodiments of the inventive concept. Detailed Description

[0044] Hereinafter, the inventive concept will be described more fully with reference to the accompanying drawings, in which examples of embodiments of the inventive concept are shown. However, the inventive concept may be embodied in many different forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the inventive concept to those skilled in the art. It should also be noted that these embodiments are not mutually exclusive. Components from one embodiment may be assumed to be present in / used in another embodiment by default.

[0045] The following description presents various embodiments of the disclosed subject matter. These embodiments are presented as teaching examples and are not to be construed as limiting the scope of the disclosed subject matter. For example, certain details of the embodiments may be modified, omitted, or extended without departing from the scope of the subject matter.

[0046] Both HEVC and VVC define a Network Abstraction Layer (“NAL”). All data (e.g., both video coding layer (“VCL”) or non-VCL data in HEVC and VVC) can be encapsulated in NAL units. VCL NAL units can include data representing picture sample values. Non-VCL NAL units can include additional associated data, such as parameter sets and Supplemental Enhancement Information (“SEI”) messages. NAL units in HEVC can start with a header that specifies the NAL unit type, which identifies the type of data carried in the NAL unit, the layer ID, and the temporal ID to which the NAL unit belongs. The NAL unit type can be sent in the nal_unit_type codeword in the NAL unit header. This type indicates and defines how the NAL unit should be parsed and decoded. The remaining bytes of the NAL unit can be the payload of the type indicated by the NAL unit type. The bitstream can include a series of concatenated NAL units.

[0047] The syntax of the NAL unit header in HEVC is as Figure 1 shown.

[0048] The current version of the VVC draft is JVET-P2001-vE. The syntax of the NAL unit header in this current draft is as Figure 2 shown.

[0049] The NAL unit types in the current VVC draft are as Figure 3 shown.

[0050] The decoding order is the order in which the NAL units should be decoded, which is the same as the order of the NAL units within the bitstream. The decoding order can be different from the output order, which is the order in which the decoded pictures are to be output by the decoder (e.g., for display).

[0051] In HEVC and in the VVC draft, all pictures can be associated with a TemporalId value that specifies the temporal layer to which the picture belongs. The TemporalId value can be decoded from the nuh_temporal_id_plus1 syntax element in the NAL unit header. The encoder can set the TemporalId value such that when higher temporal layers are discarded, pictures belonging to lower layers can be decoded perfectly. For example, assume the encoder has output a bitstream using temporal layers 0, 1, and 2. Then removing all layer 2 NAL units or removing all layer 1 and layer 2 NAL units will result in a bitstream that can be decoded without problems. This is ensured by restrictions in the HEVC specification that the encoder must abide by. For example, it is not allowed for pictures in a temporal layer to reference pictures in a higher temporal layer.

[0052] The value of the nuh_layer_id syntax element in the NAL unit header specifies the layer ID to which the NAL unit belongs.

[0053] A layer access unit in VVC can be defined as a set of NAL units for which the VCL NAL units all have a specific nuh_layer_id value, these VCL NAL units are associated with each other according to the specified classification rules, are consecutive in decoding order, and exactly contain one coded picture.

[0054] The coded layer video sequence (“CLVS”) in the current version of VVC can be defined as a sequence of layer access units, which includes CLVS layer access units in decoding order, followed by zero or more layer access units that are not CLVS layer access units, including all subsequent layer access units: until but not including any subsequent layer access unit that is a CLVS layer access unit.

[0055] The relationship between a layer access unit and the coded layer video sequence is as Figure 4 shown. In the current version of VVC, layers can be encoded independently or dependently on each other. When a layer is encoded independently, the layer with nuh_layer_id 0 may not be able to predict video data based on another layer with nuh_layer_id 1. In the current version of VVC, dependent encoding between layers can be used, which can support scalable encoding with SNR, spatial, and view scalability.

[0056] The current VVC draft includes a picture header, which is a NAL unit with nal_unit_type equal to PH_NUT. The picture header is similar to a slice header, but the values of the syntax elements in the picture header are used to decode all slices of a picture. Each picture in VVC includes a picture header NAL unit, followed by all the coded slices of the picture, where each coded slice is transmitted in a coded slice NAL unit.

[0057] For single-layer encoding in HEVC, an access unit (“AU”) can be the encoded representation of a single picture. An AU can include several video coding layer (“VCL”) NAL units and non-VCL NAL units.

[0058] An intra random access point (“IRAP”) picture in HEVC is a picture that is predicted without referring to any picture other than itself during its decoding process. In HEVC, the first picture in the bitstream in decoding order must be an IRAP picture. However, an IRAP picture can also appear later in the bitstream. HEVC specifies three types of IRAP pictures: broken link access (“BLA”) pictures, instantaneous decoder refresh (“IDR”) pictures, and clean random access (“CRA”) pictures.

[0059] An encoded video sequence (“CVS”) in HEVC is a series of access units that starts with an IRAP access unit and ends at, but does not include, the next IRAP access unit in decoding order.

[0060] An IDR picture can start a new CVS. An IDR picture can have an associated Random Access Decodable Leading (“RADL”) picture. An IDR picture can not have an associated RASL picture.

[0061] A BLA picture can also start a new CVS and can have the same effect on the decoding process as an IDR picture. However, a BLA picture in HEVC can include syntax elements that specify a non-empty set of reference pictures. A BLA picture can have associated RASL pictures that are not output by the decoder and may be undecodable because they may contain references to pictures that may not exist in the bitstream. A BLA picture can also have associated RADL pictures that are decoded.

[0062] A CRA picture can have associated RADL or RASL pictures. Similar to a BLA picture, a CRA picture can include syntax elements that specify a non-empty set of reference pictures. For a CRA picture, a flag can be set to specify that the associated RASL pictures are not output by the decoder because they may be undecodable as they may include references to pictures that do not exist in the bitstream. A CRA can start or can not start a CVS.

[0063] In VVC, there is also a GRA picture that can start or can not start a CVS in the absence of an intra picture. A Coding Layer Video Sequence Start (“CLVSS”) picture in VVC is an IRAP picture or a GRA picture. A CLVSS picture in VVC can start a VVC Coding Layer Video Sequence (“CLVS”), which can be similar to a CVS in HEVC.

[0064] There is no BLA picture type in VVC.

[0065] HEVC specifies three types of parameter sets: Picture Parameter Set (“PPS”), Sequence Parameter Set (“SPS”), and Video Parameter Set (“VPS”). The PPS can include data common to an entire picture, the SPS can include data common to an encoded video sequence (“CVS”), and the VPS can include data common to multiple CVSs.

[0066] These parameter set types can also be used in VVC. In VVC, there are also Adaptive Parameter Sets ("APS") and Decoding Parameter Sets ("DPS"). An APS can include information that can be used for multiple slices, and two slices of the same picture can use different APSs. A DPS can include information specifying the "worst case" that the decoder will encounter in terms of profile and level throughout the bitstream.

[0067] In HEVC, the concept of a slice divides a picture into independently encoded slices, where the decoding of one slice in a picture is independent of other slices in the same picture. Different coding types can be used for slices of the same picture (e.g., a slice can be an I slice, a P slice, or a B slice). One purpose of a slice is to enable resynchronization in case of data loss. In HEVC, a slice can be a set of CTUs.

[0068] In the current version of VVC, a picture can be partitioned into raster scan slices or rectangular slices. A raster scan slice can include multiple complete tiles in raster scan order. A rectangular slice can include a set of tiles that together occupy a rectangular region in the picture or a consecutive number of CTU rows within a tile. Each slice has a slice header that includes syntax elements. When decoding a slice, the decoded slice header values from these syntax elements can be used. Each slice can be carried in one VCL NAL unit.

[0069] In previous versions of the VVC draft specification, a slice was referred to as a tile group.

[0070] The VVC video coding standard draft includes a tool called a tile that divides a picture into rectangular spatially independent regions. Tiles in the VVC coding standard draft are similar to those used in HEVC. Using tiles, in VVC, a picture can be divided into multiple rows and columns of CTUs, where a tile is the intersection of a row and a column. Figure 5 An example of a tile partition that results in a total of 20 tiles for a picture using 4 tile rows and 5 tile columns is shown.

[0071] The tile structure is signaled in the Picture Parameter Set ("PPS") by specifying the thickness of the rows and the width of the columns. Each row and column can have different sizes, but the partition always spans the entire picture, from left to right and from top to bottom respectively.

[0072] There are generally no decoding dependencies between tiles of the same picture. This includes intra prediction, context selection for entropy coding, and motion vector prediction. One exception is that loop filter dependencies are generally allowed between tiles.

[0073] In the rectangular slice mode in VVC, a tile can be further divided into multiple slices, where each slice includes a consecutive number of CTU rows within a tile. Figure 6Shows an example of tile partitioning in VVC and rectangular slice partitioning using tile partitioning.

[0074] Pictures in HEVC are identified by their Picture Order Count ("POC") values (also referred to as complete POC values). Each slice may include the codeword pic_order_cnt_lsb, which may be the same for all slices in a picture. pic_order_cnt_lsb is also referred to as the least significant bit ("lsb") of the complete POC, as it is a fixed-length codeword and only signals the least significant bit of the complete POC. Both the encoder and decoder can track the POC and assign POC values to each picture being encoded / decoded. pic_order_cnt_lsb can be signaled by 4 - 16 bits. The variable MaxPicOrderCntLsb is used in HEVC, which is set to the maximum pic_order_cnt_lsb value plus 1. This means that: if 8 bits are used to signal pic_order_cnt_lsb, the maximum value is 255, and MaxPicOrderCntLsb is set to 2^8 = 256. In HEVC, the picture order count value of a picture is referred to as PicOrderCntVal. Generally, the PicOrderCntVal of the current picture is simply referred to as PicOrderCntVal. It is expected that POC will work in a similar manner in the final version of VVC.

[0075] Figure 7 Shows the output process in a decoding system. The input (bitstream 710) to video decoder 720 is decoded by decoding engine 722 into one or more decoded pictures 730 during the decoding process. The decoded pictures ultimately go through output process 726 and are output as output pictures 750.

[0076] The input to output process 726 is decoded picture 730, and the output of output process 726 is output picture 750. The decoded picture 730 used as the input to output process 726 can be stored in decoded picture buffer 724 and can be used for the decoding process of other future pictures. In this example, previous decoded pictures 740a to 740c may have been used by decoding engine 722 to generate decoded picture 730. Output picture 750 may be different from decoded picture 730. In this case, output picture 750 can be stored in memory as a separate picture.

[0077] Output process 726 can output output picture 750, which is a modified version of decoded picture 730 that has been modified in a variety of different ways, such as one of the following or a combination of two or more of the following:

[0078] 1. Applying film grain;

[0079] 2. Apply color transformation and / or color component value scaling;

[0080] 3. Apply projection mapping or inverse projection mapping, e.g., convert a decoded picture from a cube map projection to a spherical representation or to an equirectangular representation;

[0081] 4. Perform region-level packing or region-level unpacking on a picture by a set of region-level operations such as repositioning, scaling, and rotation;

[0082] 5. Crop the decoded picture;

[0083] 6. Convert the decoded picture to a different color format, e.g., from Rec 709 to PQ;

[0084] 7. Convert the decoded picture to a different chroma format, e.g., from YUV 4:2:0 to YUV 4:4:4;

[0085] 8. Scale or resample the picture from the decoded resolution to the output resolution;

[0086] 9. Convert to a different sample aspect ratio;

[0087] 10. Convert two decoded fields to an interlaced picture;

[0088] 11. Apply / remove frame packing;

[0089] 12. Extract one or more sub-pictures (similar to cropping the decoded picture, but can include, e.g., combining sub-pictures from different positions in the picture);

[0090] 13. Apply post-filtering such as deblocking filtering, anti-band filtering, anti-aliasing filtering, sharpening filtering, and blurring filtering; and

[0091] 14. Apply overlays such as timed text, logos, and motion graphics.

[0092] Noise in video can originate from different sources. This noise can be suppressed by the encoder at the earliest stage of the process. When the picture is reconstructed at the decoder before display, modeled or unmodeled noise can be added to the decoded frame in one way or another. Different objectives have been introduced, i.e., to show an increase in subjective quality by adding noise, which has now become more apparent due to the increase in picture resolution. One reason for adding noise is to introduce an artistic effect. For example, while shooting documentaries, portraits, black-and-white scenes, capturing reality, or obtaining the "true cinema effect" of a movie. Another reason for adding noise is to hide coding artifacts, e.g., blurring, blocking, and banding effects that occur due to the heavy coding process in the encoder.

[0093] According to the description of the supplementary enhancement information used in the draft of the VVC standard and specified in JVET-P2007-v3.docx, the film grain process is supported in VVC. This process is basically the same as the film grain processes specified in the H.264 / AVC and HEVC video coding standards. This process includes SEI messages carrying a parametric model for film grain synthesis in the decoder.

[0094] The film grain characteristics SEI message includes the cancel flag film_grain_characteristics_cancel_flag, and if it is set to equal 0, the film grain process is enabled. In addition, when this flag is set to 0, the film grain parameter syntax elements follow this flag. The film_grain_characteristics_persistence_flag specifies the persistence of the film grain characteristics SEI message for the current layer. Figure 8 An example of this syntax is shown.

[0095] In the film grain technical specification introduced in [SPMTE], a seed derivation method for deriving the seed value for the film grain characteristics SEI process is specified. The seed is initialized using information already available at the decoder and is selected from a predetermined set of 256 possible seeds in a lookup table. For the pseudo-random number generator and for selecting an 8x8 sample block, the seed is initialized as:

[0096] seed = Seed_LUT[Mod[pic_offset+color_offset[c],256)],

[0097] where for the Y, Cb, and Cr channels, color_offset[c] is equal to 0, 85, and 170 respectively, and pic_offset is defined as:

[0098] pic_offset = POC(curr_pic)+(POC_offset<<5)

[0099] where POC(curr_pic) is equal to the picture order count value of the current frame, and where POC_offset is set to be equal to the value of idr_pic_id on an IDR frame, otherwise it is set to be equal to 0.

[0100] In addition, the initialization of the pseudo-random number generator for creating a 64x64 sample block is as follows:

[0101] seed = Seed_LUT[h+v*13]

[0102] where h and v represent the values in the horizontal and vertical directions respectively. Both h and v are in the range of [0, 12], and determine which pattern of the film grain database is used as the source of the film grain sample.

[0103] Finally, in either case, the output of Seed_LUT[.], i.e., the variable of the above-mentioned variable seed, is used as the seed of the pseudo-random number generator. The film_grain_mode_id syntax element, the separate_colour_description_present_flag syntax element, and Figure 8 the syntax elements in the more_film_grain_parameters() structure in are examples of film grain model syntax elements. The film_grain_characteristics_cancel_flag and film_grain_characteristics_persistence_flag syntax elements may not be regarded as film grain syntax elements because they control whether the film grain process is enabled rather than controlling the values of the generated film grains.

[0104] The AV1 video codec format supports film grain generation. When outputting pictures, film grains are applied. The sequence_header_obu() contains the film_grain_params_present flag, which is the enable flag for film grain signaling and processes.

[0105] In Figure 9 the syntax table called film_grain_params() shown in, the film grain parameters are signaled at the end of the frame_header_obu().

[0106] In film_grain_params(), first there is the flag apply_grain, which controls whether film grains should be applied to the current picture. Then there is the 16-bit grain_seed syntax element, which is used as the seed of the pseudo-random number generator for generating grains. The update_grain flag specifies whether the film grain parameter values from the reference picture should be used, or whether the film grain parameter values to be used should be decoded from the frame header. The reference picture to be used is identified by the film_grain_params_ref_idx syntax element value. In Figure 9 the frame header film grain parameters are represented by the more_film_grain_parameters() line to simplify the table.

[0107] The value of grain_seed initializes the seed for the luminance component of the white noise particles of the pseudo-random number generator. For the chrominance components Cb and Cr, this value is modified via an XOR operation as follows:

[0108] Cb_seed = grain_seed ^ 0xb524

[0109] Cr_seed = grain_seed ^ 0x49d8.

[0110] Figure 21 FIG. 10 is a block diagram showing elements of a terminal device (“UE”) 2100 (also referred to as a mobile terminal, a mobile communication terminal, a wireless communication device, a wireless terminal, a mobile device, a wireless communication terminal, a user equipment UE, a user equipment node / terminal / device, etc.) configured to receive an encoded representation (e.g., a bitstream or a video sequence) of data according to an embodiment of the inventive concept. As shown, the UE 2100 may include an antenna 2107 and a transceiver circuit 2101, the transceiver circuit 2101 including a transmitter and a receiver configured to provide uplink and downlink radio communications with a base station of a radio access network (e.g., also referred to as a RAN node). The UE 2100 may also include a processing circuit 1803 (also referred to as a processor) coupled to the transceiver circuit, and a memory circuit 2105 (also referred to as a memory) coupled to the processing circuit. The memory circuit 2105 may include computer-readable program code that, when executed by the processing circuit 2103, causes the processing circuit to perform operations according to embodiments disclosed herein. According to other embodiments, the processing circuit 2103 may be defined to include a memory such that a separate memory circuit is not required. The UE 2100 may also include an interface (e.g., a user interface) coupled to the processing circuit 2103, and / or the UE 2100 may be incorporated into a vehicle.

[0111] As discussed herein, operations of the UE 2100 may be performed by the processing circuit 2103 and / or the transceiver circuit 2101. For example, the processing circuit 2103 may control the transceiver circuit 2101 to transmit communications to a radio access network node (also referred to as a base station) over a radio interface via the transceiver circuit 2101 and / or receive communications from a RAN node over a radio interface via the transceiver circuit 2101. In addition, modules may be stored in the memory circuit 2105, and these modules may provide instructions such that when the instructions of the modules are executed by the processing circuit 2103, the processing circuit 2103 performs corresponding operations (e.g., operations discussed below with respect to example embodiments related to wireless devices). In some embodiments, the UE 2100 may include a display for displaying an image decoded from a received bitstream. For example, the UE 2100 may include a television.

[0112] Figure 22 It is a block diagram showing the components of a decoder 2200 configured to decode a bitstream according to an embodiment of the inventive concept. The decoder 2200 may include a network interface circuit 2207 (also referred to as a network interface), and the network interface circuit 2207 is configured to communicate with other devices. The decoder 2200 may also include a processing circuit 2203 (also referred to as a processor) coupled to a memory circuit 2205 (also referred to as a memory), and the memory circuit 2205 is coupled to the processing circuit. The memory circuit 2205 may include computer-readable program code that, when executed by the processing circuit 2203, causes the processing circuit to perform operations according to the embodiments disclosed herein. According to other embodiments, the processing circuit 2203 may be defined to include a memory such that a separate memory circuit is not required.

[0113] As discussed herein, the operations of the decoder 2200 may be performed by the processing circuit 2203 and the network interface 2207. For example, the processing circuit 2203 may control the network interface 2207 to receive an encoded representation of data from one or more bitstream modification entities (e.g., a transcoder) and / or send an encoded representation of data to one or more bitstream modification entities (e.g., a transcoder). In addition, modules may be stored in the memory 2205, and these modules may provide instructions such that when the instructions of the modules are executed by the processing circuit 2203, the processing circuit 2203 performs corresponding operations (e.g., the operations discussed below with respect to the exemplary embodiments related to the decoder).

[0114] Figure 23 It is a block diagram showing the components of an encoder 2300 configured to encode a bitstream according to an embodiment of the inventive concept. As shown, the encoder 2300 may include a network interface circuit 2307 (also referred to as a network interface), and the network interface circuit 2307 is configured to transmit a bitstream to one or more other devices. The encoder 2300 may also include a processing circuit 2303 (also referred to as a processor) coupled to the network interface circuit, and a memory circuit 2305 (also referred to as a memory) coupled to the processing circuit. The memory circuit 2305 may include computer-readable program code that, when executed by the processing circuit 2303, causes the processing circuit to perform operations according to the embodiments disclosed herein. According to other embodiments, the processing circuit 2303 may be defined to include a memory such that a separate memory circuit is not required.

[0115] Basing the expected output video quality on SEI messages such as the film grain SEI message can be problematic because the decoder is not required to implement these film grain SEI messages. This means that an encoder that considers using the film grain SEI message to improve video quality risks providing the consumer with a decoded video sequence that is free of noise and results in a poor experience.

[0116] For a variety of reasons, using the AV1 film_grain_params_ref_idx method for a VVC codec can be inefficient. For example, if a picture is not predicted using any pictures, there are no film grain parameters to reference. Additionally or alternatively, film grain parameter values cannot be shared between layers unless there is a reference picture in that layer that serves as a reference picture for the current picture. Additionally or alternatively, a single set of film grain parameter values can be used for a sequence of pictures, but in AV1, a set of parameters needs to be stored for each reference picture rather than just a single set of parameters.

[0117] Using 16 bits to signal the seed as in the AV1 film grain method is inefficient. For a 60fps bitstream, the cost is nearly 1kbps, which is a 1% overhead of a 100kbps bitstream.

[0118] Various embodiments described herein describe decoding film grain model syntax elements from a parameter set (e.g., an adaptive parameter set) in an encoded data representation. The seed syntax element can also be decoded, for example, from a picture header or a slice header. The length of the seed syntax element can be configured and decoded according to a length syntax element in another parameter set. In some embodiments, the seed can be generated based on the following parameter values or a subset of the following parameter values: the decoded seed syntax element, the layer ID of the picture, the slice address of the slice, the subpicture ID of the subpicture, and the identifier value of the picture (e.g., the least significant bit of the picture order count).

[0119] Some embodiments enable reference to a previous film grain model for pictures that do not use any pictures for reference. Additional or alternative embodiments support sharing film grain model parameter values between pictures in different layers (both temporal sublayers and, for example, spatial scalable layers). A single set of film grain parameters can also be stored for a sequence of multiple pictures. Additional or alternative embodiments provide significant bit savings for low bitrate bitstreams in which the film grain model is used.

[0120] In some of the embodiments described below, various processes have been described. Those skilled in the art should understand that two or more embodiments or portions of embodiments can be combined to form a new solution still covered by the invention described in this disclosure. The following embodiments can be applied to a single still picture or to a video sequence of pictures. The coded data representation in these embodiments can be the same as a bitstream.

[0121] In some embodiments, a process for signaling a film grain syntax element in a coded picture or a coded video sequence is described. In this embodiment, it can be assumed that the film grain model includes: a film grain enable flag; film grain model syntax elements; one or more seed syntax elements; a seed value generation process; one or more generated seed values; and a film grain process.

[0122] The model can operate as Figure 10 shown. The film grain enable flag 1010 can be signaled in the coded picture or video data representation (e.g., a bitstream). One value of the flag can specify that film grain generation is enabled, while another value can specify that film grain generation is disabled. The film grain enable flag can consist of a 1-bit flag in the data representation.

[0123] One or more seed syntax elements 1030 can be signaled in the coded picture or video data representation (e.g., bitstream 1050). In the decoding process 1070, the seed syntax elements 1030 can be decoded into one or more decoded seed values 1072. The seed value generation process 1080 can use the decoded seed values 1072 as input to generate one or more generated seed values 1082. The seed value generation process 1080 can additionally or alternatively use other decoded values 1052 as input, where the other decoded values 1052 are decoded from other syntax elements in the coded data representation (e.g., bitstream 1050).

[0124] In the coded data representation 1050, there are also film grain model syntax elements 1020, which are decoded into decoded film grain model values 1062 in the decoding process 1060. The film grain process 1040 uses the generated seed values 1082 and the decoded film grain model values 1062 as input to generate the generated film grain 1090. The generated film grain 1090 is preferably applied to the picture decoded from the coded data representation 1050. The generated film grain 1090 can be applied such that one version of the decoded picture with film grain is output by the decoder, while another version of the decoded picture without film grain is stored by the decoder for inter-picture prediction of future pictures.

[0125] The film grain process 1040 may include a pseudo-random number generator 1042 that uses the generated seed value 1082 as an input. The pseudo-random number generator 1042 may be initialized by the generated seed value 1082 and operate in such a way that if the seed value used for initialization is the same, the sequence of generated values from the pseudo-random number generator 1042 is the same. This means that the generated film grains 1090 can be fully controlled by syntax elements in the coded data representation. In some examples, the pseudo-random number generator 1042 may include a linear feedback shift register ("LFSR"), which is a shift register whose bits are a linear function of its previous state. The initial value of the LFSR may be set to be equal to the generated seed value 1082.

[0126] If the film grain enable flag 1010 specifies that film grain generation is disabled, the generated film grains 1090 are not applied to any pictures and the film grain process 1040 is not performed. Additionally, the presence of other syntax elements such as the film grain model syntax element 1020 and the seed syntax element 1030 may be conditional on the film grain enable flag 1010 such that if the flag 1010 specifies that film grain generation is disabled, these syntax elements are not present in the coded data representation.

[0127] In additional or alternative embodiments, it is proposed to decode the film grain enable flag 1010 and the film grain model syntax element 1020 from a parameter set such as a DPS, VPS, SPS, PPS, or APS. It is proposed to decode the seed syntax element 1030 from a picture header or a sequence header.

[0128] The film grain enable flag 1010 in this embodiment may be decoded from the parameter set as described above. Figure 11 An example is shown in which the film grain enable flag 1010 is decoded from a sequence parameter set (SPS) above the current VVC draft specification.

[0129] A parameter_set_film_grain_enable_flag equal to 1 specifies that film grain generation is enabled. A parameter_set_film_grain_enable_flag equal to 0 specifies that film grain generation is disabled.

[0130] In another example, a no-film-grain constraint flag is added to as Figure 12The general_constraint_info() syntax table shown. In the current VVC draft, general_constraint_info() can be present in any parameter set among the DPS, VPS, and SPS. For example, the syntax table can be present in all three parameter sets or only in the DPS, and so on.

[0131] The no_film_grain_constraint_flag equal to 1 specifies that the parameter_set_film_grain_enabled_flag should be equal to 0. The no_film_grain_constraint_flag equal to 0 does not impose such a constraint.

[0132] In another example, the no film grain constraint flag is present in the Video Usability Information (VUI), which is conditionally signaled in the SPS in the current version of VVC.

[0133] In some embodiments, the film grain model syntax elements are decoded from the Sequence Parameter Set (SPS). In one embodiment, as Figure 13 shown, if the film grain enabled flag specifies that film grain generation is enabled, the syntax elements are decoded. The film_grain_model_syntax_elements() line here represents the film grain model syntax elements. Note that the details of the film grain model are not within the scope of the present invention. Also note that the present invention can be applied to many different film grain models, for example, the film grain characteristic SEI film grain model or the AV1 film grain model as described above. The sps_seq_parameter_set_id is the codeword specifying the ID value of the SPS.

[0134] In additional or alternative embodiments, the film grain model syntax elements are decoded from the Adaptation Parameter Set (APS). In the Figure 14 syntax table shown, the adaptation_parameter_set_id is the codeword specifying the ID value of the APS. The aps_params_type specifies what data is carried in the APS and in the Figure 14 example shown. The value 3 is used for the film grain model syntax elements. A picture to which the film grain process is applied can identify the film grain model value to be used by the film grain parameter set identifier syntax element, which is present in the picture header of the picture or in the slice header of the picture. Then, the film grain model value to be used is the film grain model value decoded from the APS having an ID value equal to the value of the film grain parameter set identifier syntax element.

[0135] In an additional or alternative embodiment, if the film grain enable flag specifies that film grain generation is enabled, then the syntax elements are decoded.

[0136] In some embodiments, the seed syntax elements are decoded from the picture header or sequence header. Figure 15 An example syntax is shown in which the seed syntax consists of a single 8-bit syntax element.

[0137] Other signaling elements that may supplement the actual syntax for conveying the seed value can include:

[0138] 1. Gating the presence of the seed syntax element via the film grain enable flag

[0139] 2. Requiring the decoder to decode a 1-bit flag in the picture header or sequence header that gates the presence of the seed syntax element

[0140] 3. A combination of 1 and 2, where the 1-bit flag is also gated by the film grain enable flag

[0141] 4. Designing the syntax such that when the decoder decodes the seed syntax element, it also decodes a parameter set ID that specifies that a model of a parameter set with an ID value matching the decoded parameter set ID value will be used for the film grain process.

[0142] In Figure 16 the table shown, all combinations of elements 1 through 4 are shown. The film_grain_parameter_set_id specifies the parameter set to be used and thus specifies the decoded film grain model values to be used in the film grain process. The parameter set can be an adaptive parameter set here. In versions in which the film grain model syntax elements are carried in the PPS, SPS, VPS, or DPS, the film_grain_parameter_set_id syntax element as shown in Figure 16 may not be present. Instead, the referenced parameter set can be used, which is identified by the PPS id syntax element present in the picture header or sequence header and is not gated by any of the flags shown in the syntax element table shown in Figure 16 since many other decoding processes need to identify the referenced parameter set.

[0143] Note that using a single 8-bit syntax element to carry the seed value is an example, and other lengths or many other types of syntax elements (e.g., variable length syntax elements) are also possible.

[0144] In Figure 17 is shown Figure 10Some embodiments of the coded data in [description] represent 1050. In these embodiments, there is a parameter set type A that carries a film grain enable flag syntax element and a parameter set type B that contains film grain model syntax elements. Parameter set type A can be the SPS, but as mentioned before, other placements of the film grain enable flag are possible. Parameter set type B can be the APS, but other placements are possible here. In a variant of this embodiment, parameter set types A and B are the same, such as the SPS or PPS, which means that the film grain enable flag and the film grain model syntax elements are decoded from the same parameter set. The picture header or slice contains one or more syntax elements from which one or more of the referenced parameter set ID values are decoded, and this syntax element specifies which parameter set or parameter sets the current picture or slice refers to, and thus specifies whether film grain generation is enabled, and if so, which film grain model values are used for the film grain process.

[0145] In some embodiments, although not shown in Figure 17 , a seed syntax element exists in the slice and in the picture header for the coded picture that contains the slice. In this example, at least one of the referenced parameter set ID syntax elements can exist in the picture header and is used to derive which film grain model values are used for the film grain process. In the case where there are two or more parameter set types that carry film grain syntax elements, the referenced parameter set ID syntax elements can exist in both the slice and the picture header. The slice syntax elements described here can exist in the slice header and are decoded from the slice header.

[0146] Some embodiments solve the following problems.

[0147] First, in AV1, if a picture is fully intra-coded and does not have the type INTER_FRAME, then in the case where film grain generation is used for the picture, the complete set of film grain model syntax elements must be included in the picture header. Compared with the AV1 design, the proposed design places the film grain model syntax elements in the parameter set, which means that any picture can use the referenced parameter set ID syntax element to reference the model, with a significantly reduced bit cost. Additionally, if multiple picture sets share the same film grain characteristics, more than one model can be efficiently signaled in a separate APS or PPS, and each picture references each model using the APS id or PPS id.

[0148] Second, in AV1, the film_grain_params_ref_idx syntax element references a reference picture. With this design, there may be pictures that belong to a higher layer but cannot reference a model for a previous picture that belongs to a different lower layer. By placing the model in the proposed parameter set, very flexible model reference support is provided. Consider Figure 18 , where an access unit is part of a bitstream that contains a picture and an associated parameter set. The first access unit consists of a parameter set with a parameter set ID value equal to 7, which is signaled in a syntax element. The layer ID of the parameter set is equal to 0, and this value is also signaled in a syntax element in the parameter set. All three pictures in the figure use the parameter set because they all contain a syntax element with a value of 7 that specifies that the picture uses the parameter set with an ID value equal to 7. Then each picture belongs to a different layer. Although the parameter sets belong to different layers, all pictures can use the parameter set because the layer ID of the parameter set is equal to or less than the layer ID of the picture. This is the case for both the temporal sub-layer ID and layer IDs such as those for spatial scalable layers.

[0149] Third, by using the proposed method, the minimum number of film grain models needs to be stored in the decoder. For example, if we assume that one model is used and the number of reference pictures used by the current picture is equal to n, the AV1 method requires storing n models, while in the proposed method, only one model needs to be stored in one parameter set.

[0150] In some embodiments, the decoder may perform all or a subset of the following operations to decode and output a picture from an encoded data representation. First, the decoder may decode a film grain enable flag from the parameter set. Second, the decoder may decode a film grain model syntax element from the parameter set and derive a decoded film grain model value. Third, the decoder may decode one or more seed syntax elements from the picture header of the current picture into one or more decoded seed values. Fourth, the decoder may derive a generated seed value based on the decoded seed values. Fifth, the decoder may decode the current picture from the encoded data representation. Sixth, the decoder may use the decoded seed values or the generated seed values to initialize a pseudo-random number generator that is used in the film grain generation process performed by the decoder to apply film grain to the decoded current picture. Seventh, the decoder may output the current picture.

[0151] In additional or alternative embodiments, the decoder may perform all or a subset of the following operations for decoding and outputting a picture from an encoded data representation. First, the decoder may decode a film grain enable flag from a parameter set. Second, the decoder may decode a film grain model syntax element from a parameter set and derive a decoded film grain model value. Third, the decoder may decode one or more seed syntax elements from a first slice header of a first slice of a current picture into one or more first decoded seed values. Fourth, the decoder may derive a first generated seed value based on the first decoded seed value. Fifth, the decoder may decode a first current slice from an encoded data representation. Sixth, the decoder may use the first decoded seed value or the first generated seed value to initialize a pseudo-random number generator that is used in a film grain generation process performed by the decoder to apply film grain to a first decoded current slice. Seventh, the decoder may decode one or more seed syntax elements from a second slice header of a second slice of the current picture into one or more second decoded seed values. Eighth, the decoder may derive a second generated seed value based on the second decoded seed value. Ninth, the decoder may decode a second current slice from an encoded data representation. Tenth, the decoder may use the second decoded seed value or the second generated seed value to initialize a pseudo-random number generator for use in a film grain generation process performed by the decoder to apply film grain to the second decoded current slice. Eleventh, the decoder may output a picture including the first decoded current slice and the second decoded current slice.

[0152] In additional or alternative embodiments, a slice may be any fragment of a picture, such as a sub-picture, a tile group, a tile, etc. A slice may be a portion of a picture or a complete picture.

[0153] In some embodiments, the number of bits used for the seed syntax element is configurable. The number of bits may be used to decode a syntax element from a parameter set (e.g., DPS, VPS, SPS, PPS, or APS as shown in the syntax and semantics below). In the parameter set there is a syntax element that is decoded to a length value, which is then used to derive the number of bits used for the seed syntax element.

[0154] Figure 19 The seed length in the parameter set is shown. film_grain_seed_len_minus1 plus 1 specifies the length in bits of the film_grain_seed syntax element.

[0155] Figure 20A variable-length seed syntax is shown. film_grain_seed specifies the film grain seed value to be used. The length of film_grain_seed is equal to film_grain_seed_len_minus1 + 1.

[0156] In some embodiments, the decoder may perform all or a subset of the following operations to decode a picture from an encoded data representation. First, the decoder may decode a length syntax element from the encoded data representation. Second, the decoder may derive a length value L from the decoded value of the length syntax element. Third, the decoder may decode a seed syntax element from a picture header of the current picture or from a picture slice header of the current picture into a decoded seed value, where the seed syntax element consists of L bits. Fourth, the decoder may derive a generated seed value based on the decoded seed value. Fifth, the decoder may decode the current picture from the encoded data representation. Sixth, the decoder may use the decoded seed value or the generated seed value to initialize a pseudo-random number generator that is used in a film grain generation process in which film grain is applied to the decoded current picture by the decoder. Seventh, the decoder may output the current picture.

[0157] One advantage of a configurable seed size is a trade-off between bit cost and the number of unique seed values that can be expressed. The problem with too few unique seed values is that the generated noise may repeat between pictures. In some examples, the encoder may use eight seed values such that the seed for the current picture is the same as the seed for the picture encoded eight pictures before. If temporal scalability is used such that only every eighth picture is output, the film grain noise applied to consecutive output pictures may be the same, which may be visible in low-texture picture regions. To avoid this undesirable effect, a larger number of unique seed values may be used. Alternatively, if such temporal scalability is not provided, using eight unique seed values may be sufficient and in some examples even fewer than eight seed values may be used.

[0158] In additional or alternative embodiments, pictures are classified into picture types, such as pictures of a certain layer. In additional or alternative embodiments, for each picture type or group of picture types, there is a separate syntax element to derive the length value L for that picture type or group of picture types. In one variant, the length value L is derived based on the length syntax element and the type of the current picture. An example of the latter variant is to decode a length syntax element, derive a length value L1 for pictures belonging to a higher temporal sublayer or layer, and derive a length value L2 for pictures belonging to a lower temporal sublayer or layer, such that L2 is different from L1.

[0159] In some examples, 16 bits may be used to signal the seed. As previously mentioned, this corresponds to a 1% bit cost for a 100 kbps 60 fps bitstream. If a 4-bit seed length is used instead, a 0.75% bitrate reduction is achieved, which is a significant bitrate reduction.

[0160] In some embodiments, the seed value generation process is performed by the decoder. As previously mentioned, the seed value generation process takes the decoded seed value and other decoded values as inputs and outputs the generated seed value.

[0161] In some embodiments, the generated seed value G may be derived as:

[0162] G = (O << n) + D

[0163] where O is a value derived from other decoded values, n is the number of bits for the seed syntax element, and D is the value of the decoded seed syntax element. For example, if the value derived from other decoded values equals 10, the number of bits for the seed syntax element equals 4, and the bit value of the seed syntax element equals 9 (in binary format 1001), then the value of the generated seed value G equals (10 << 4) + 9 = 169.

[0164] In additional or alternative embodiments, the value of O is based on the layer ID, such that if the layer IDs of picture A and picture B are different, then when picture A and picture B use the same decoded seed value, the generated seeds for picture A and picture B are different.

[0165] In additional or alternative embodiments, the value of O is based on the temporal sublayer ID, such that if the temporal sublayer IDs of picture A and picture B are different, then when picture A and picture B use the same decoded seed value, the generated seeds for picture A and picture B are different.

[0166] In additional or alternative embodiments, the value of O is based on the slice address, such that if the slice address values of picture A and picture B are different, then when picture A and picture B use the same decoded seed value, the generated seeds for picture A and picture B are different.

[0167] In additional or alternative embodiments, the value of O is based on the slice type, such that if the slice type values of picture A and picture B are different, then when picture A and picture B use the same decoded seed value, the generated seeds for picture A and picture B are different.

[0168] In additional or alternative embodiments, the value of O is based on the subpicture ID, such that if the subpicture IDs of picture A and picture B are different, then when picture A and picture B use the same decoded seed value, the generated seeds for picture A and picture B are different.

[0169] In an additional or alternative embodiment, the value of O is based on, for example, the (delta-encoded) quantization parameter value present in the picture header or slice header such that if the quantization parameter values of picture A and picture B are different, the generated seeds for picture A and picture B are different when picture A and picture B use the same decoded seed value.

[0170] In an additional or alternative embodiment, the number of bits used for the seed syntax element is equal to 0, which means that there is no signaled seed in the picture header of the picture or the slice header of the slice. In this case, for all pictures A and B discussed above, the decoded seed values are considered to be the same.

[0171] In some embodiments, the number of bits used for the seed syntax element is variable. In the case where the seed syntax element is specified to use 0 bits, the generated seed value can only be derived from other decoded values.

[0172] In some embodiments, the decoder may perform all or a subset of the following operations to decode a picture from an encoded data representation. First, the decoder may decode a length syntax element from the encoded data representation. Second, the decoder may derive a length value L from the decoded length syntax element. Third, the decoder may decode the seed syntax element from the picture header of the current picture or the slice header of the current picture into a decoded seed value, where the seed syntax element consists of L bits. Fourth, the decoder may derive the generated seed value as equal to (O << L)+D, where O is a value derived from a first set of decoded syntax elements in the encoded data representation and D is the decoded seed value. Fifth, the decoder may decode the current picture from the encoded data representation. Sixth, the decoder may use the generated seed value to initialize a pseudo-random number generator that is used in the film grain generation process performed by the decoder to apply film grain to the decoded current picture. Seventh, the decoder may output the current picture.

[0173] In some embodiments, the first set of decoded syntax elements may include a subset of the following syntax elements: the seed syntax element; the layer ID of the picture; the temporal sub-layer ID of the picture, the slice type value, the quantization parameter value, the slice address of the slice; the sub-picture ID of the sub-picture; and the identifier value of the picture, e.g., the least significant bit of the picture order count of the current picture.

[0174] In some embodiments, a method for decoding and outputting a picture from an encoded data representation is provided. The method may include obtaining a film grain model syntax element from a parameter set in the encoded data representation; deriving a decoded film grain model value by decoding the film grain model syntax element; obtaining a seed syntax element from the encoded data representation; deriving a generated seed value by decoding the seed syntax element; decoding a current picture from the encoded data representation; generating a film grain value from a pseudo-random number generator, wherein the pseudo-random number generator is initialized by the generated seed value; applying the generated film grain value to the current picture; and outputting the current picture.

[0175] In additional or alternative embodiments, decoding a current picture from the encoded data representation includes decoding a first picture from the encoded data representation. Applying the generated film grain value to the current picture includes applying the generated film grain value to the first picture to obtain a second picture including film grains. Outputting the current picture includes outputting the second picture. Storing the first picture in a decoded picture buffer. Decoding a third picture from the encoded data representation, wherein the stored first picture is used for inter-picture prediction during the decoding of the third picture.

[0176] In additional or alternative embodiments, the seed syntax element is obtained from a picture header or a slice header in the encoded data representation.

[0177] In additional or alternative embodiments, the film grain model syntax element is obtained from a sequence parameter set.

[0178] In additional or alternative embodiments, the film grain model syntax element is obtained from an adaptive parameter set, wherein the adaptive parameter set includes an adaptation_parameter_set_id syntax element and a parameter set type syntax element having a value equal to a film grain type value, and the picture header or the slice header includes a film_grain_parameter_set_id syntax element, the value of the film_grain_parameter_set_id syntax element being equal to the value of the adaptation_parameter_set_id syntax element.

[0179] In some embodiments, a method for decoding and outputting a picture from an encoded data representation is provided. The method may include obtaining a film grain model syntax element from the encoded data representation; deriving a decoded film grain model value by decoding the film grain model syntax element; obtaining a film grain seed length syntax element from the encoded data representation; deriving a film grain seed length value L1 by decoding the film grain seed length syntax element; obtaining a seed syntax element from the encoded data representation, where the seed syntax element exactly includes L1 bits; deriving a generated seed value by decoding the seed syntax element; decoding a current picture from the encoded data representation; generating a film grain value from a pseudo-random number generator, where the pseudo-random number generator is initialized by the generated seed value; applying the generated film grain value to the current picture; and outputting the current picture.

[0180] In additional or alternative embodiments, decoding the current picture from the encoded data representation includes decoding a first picture from the encoded data representation. Applying the generated film grain value to the current picture includes applying the generated film grain value to the first picture to obtain a second picture including film grains. Outputting the current picture includes outputting the second picture. The first picture may be stored in a decoded picture buffer. A third picture may be decoded from the encoded data representation, where the stored first picture is used for inter-prediction during the decoding of the third picture.

[0181] In additional or alternative embodiments, deriving the generated seed value by decoding the seed syntax element includes: deriving the generated seed value to be equal to (O << L1) + D, where O is a value derived from a first set of decoded syntax elements in the encoded data representation, and D is the value of the decoded seed syntax element.

[0182] In additional or alternative embodiments, the first set of decoded syntax elements includes a subset of the following syntax elements: the decoded seed syntax element; the layer ID of the picture; the slice address of the slice; the sub-picture ID of the sub-picture; and the identifier value of the picture, e.g., the least significant bit of the picture order count.

[0183] Now, the operation of the decoder 2200 (implemented using the Figures 24 to 26 structure) will be discussed with reference to the flowchart of some embodiments according to the inventive concept. For example, the modules may be stored in the Figure 21 memory 2205, and these modules may provide instructions such that when the instructions of the modules are executed by the corresponding decoder processing circuit 2203, the processing circuit 2203 performs the corresponding operations of the flowchart. Although the following describes Figure 22 with respect to the decoder 2200, Figures 24 to 26 however, Figures 24 to 26The operations in can be performed by any suitable bitstream modification entity (e.g., encoder 2300).

[0184] In Figure 24 In block 2410, processing circuit 2203 decodes the film grain enable flag.

[0185] In block 2420, processing circuit 2203 determines that the film grain output process is enabled based on the film grain enable flag.

[0186] In block 2430, processing circuit 2203 obtains the film grain model syntax element from the encoded data representation. In some embodiments, obtaining the film grain model syntax element from the parameter set in the encoded data representation is performed in response to determining that the film grain output process is enabled.

[0187] In block 2440, processing circuit 2203 determines the film grain model value by decoding the film grain model syntax element.

[0188] In block 2450, processing circuit 2203 decodes the current picture from the encoded data representation.

[0189] In block 2460, processing circuit 2203 generates the output picture by applying the generated film grain to the current picture.

[0190] Figures 25 to 26 An example of generating the generated film grain is depicted.

[0191] In Figure 25 In block 2562, processing circuit 2203 obtains the seed syntax element from the encoded data representation. In some embodiments, obtaining the seed syntax element from the encoded data representation includes obtaining the seed syntax element from the picture header or sequence header in the encoded data representation. In additional or alternative embodiments, obtaining the film grain model syntax element from the parameter set in the encoded data representation may include obtaining the film grain model syntax element from the Adaptive Parameter Set (APS). The APS may include an APS set identifier syntax element and a parameter set type syntax element, and the parameter set type syntax element includes a value equal to the film grain type value. The picture header or sequence header may include a film grain parameter set identifier syntax element, and the film grain parameter set identifier syntax element includes a value equal to the value of the APS set identifier syntax element.

[0192] In block 2564, processing circuit 2203 determines the seed value by decoding the seed syntax element.

[0193] In block 2566, processing circuit 2203 generates the generated film grain based on the seed value. In some embodiments, the generated film grain is generated from a digital generator (e.g., a linear feedback shift register).

[0194] In Figure 26 , in block 2662, processing circuitry 2203 obtains a film grain seed length syntax element from the coded data representation. In block 2664, processing circuitry 2203 determines a film grain seed length value L1 by decoding the film grain seed length syntax. In some embodiments, determining the seed value by decoding the seed syntax element includes determining the seed value as (O << L1)+D. O may be a value derived from a first set of decoded syntax elements in the coded data representation, and D may be the value of the seed syntax element. In additional or alternative embodiments, the first set of decoded syntax elements includes at least one of the following: the seed syntax element; the layer ID of the current picture; the temporal sublayer ID of the current picture; the slice type value; the quantization parameter value; the slice address of the slice of the current picture; the subpicture ID of the subpicture of the current picture; and the identifier value of the current picture, e.g., the least significant bit of the picture order count of the current picture.

[0195] Returning to Figure 24 , in block 2470, processing circuitry 2203 stores the current picture in the decoded picture buffer.

[0196] In block 2480, processing circuitry 2203 outputs the output picture.

[0197] In block 2490, processing circuitry 2203 performs inter prediction using the current picture to decode subsequent pictures from the coded data representation. In some embodiments, the subsequent pictures are decoded after the output picture is generated.

[0198] Regarding some embodiments of a decoder, an encoder, and related methods, various operations of the flowchart from Figure 24 may be optional. For example, regarding the method of Example Embodiment 1 (described below), Figure 24 the operations of blocks 2410, 2420, 2470, and 2490 of Figure 24 may be optional. For example, regarding the method of Example Embodiment 11 (described below),

[0199] Example embodiments are discussed below.

[0200] Example Embodiment 1. A method performed by a decoder, the method comprising:

[0201] obtaining (2430) a film grain model syntax element from a parameter set in a coded data representation;

[0202] determining (2440) a film grain model value by decoding the film grain model syntax element;

[0203] Decode (2450) the current picture from the coded data representation;

[0204] Generate (2460) an output picture by applying the generated film grains to the current picture; and

[0205] Output (2480) the output picture.

[0206] Example 2. The method according to Example 1 further includes:

[0207] Store (2470) the current picture in a decoded picture buffer DPB; and

[0208] Use the current picture for inter prediction to decode (2490) a subsequent picture from the coded data representation, the subsequent picture being decoded after the output picture is generated.

[0209] Example 3. The method according to any one of Examples 1 to 2 further includes:

[0210] Obtain (2562) a seed syntax element from the coded data representation;

[0211] Determine (2564) a seed value by decoding the seed syntax element; and

[0212] Generate (2566) the generated film grains from a digital generator based on the seed value.

[0213] Example 4. The method according to Example 3, wherein the digital generator includes a linear feedback shift register.

[0214] Example 5. The method according to any one of Examples 3 to 4, wherein obtaining a seed syntax element from the coded data representation includes obtaining the seed syntax element from a picture header or a sequence header in the coded data representation.

[0215] Example 6. The method according to Example 5, wherein obtaining a film grain model syntax element from a parameter set in the coded data representation includes obtaining the film grain model syntax element from an Adaptive Parameter Set APS, the APS including:

[0216] An APS set identifier syntax element; and

[0217] A parameter set type syntax element, the parameter set type syntax element including a value equal to a film grain type value, and

[0218] wherein the picture header or the sequence header includes a film grain parameter set identifier syntax element, the film grain parameter set identifier syntax element including a value equal to the value of the APS set identifier syntax element.

[0219] Example 7. The method according to any one of Examples 3 to 6 further includes:

[0220] obtaining (2662) a film grain seed length syntax element from the coded data representation; and

[0221] determining (2664) a film grain seed length value L1 by decoding the film grain seed length syntax,

[0222] wherein the seed syntax element includes L1 bits.

[0223] Example 8. The method according to Example 7, wherein determining the seed value by decoding the seed syntax element includes determining the seed value as (O << L1) + D,

[0224] where O is a value derived from a first set of decoded syntax elements in the coded data representation, and

[0225] where D is the value of the seed syntax element.

[0226] Example 9. The method according to Example 8, wherein the first set of decoded syntax elements includes at least one of the following:

[0227] the seed syntax element;

[0228] the layer ID of the current picture;

[0229] the temporal sub-layer ID of the current picture;

[0230] the slice type value;

[0231] the quantization parameter value;

[0232] the slice address of the slice of the current picture;

[0233] the sub-picture ID of the sub-picture of the current picture; and

[0234] the identifier value of the current picture, such as the least significant bit of the picture order count of the current picture.

[0235] Example 10. The method according to any one of Examples 1 to 9 further includes:

[0236] decoding (2410) a film grain enable flag from the parameter set; and

[0237] determining (2420) that the film grain output process is enabled based on the film grain enable flag,

[0238] wherein obtaining the film grain model syntax element from the parameter set in the coded data representation is performed in response to determining that the film grain output process is enabled.

[0239] Example 11. A method performed by an encoder, the method comprising:

[0240] Obtaining (2430) a film grain model syntax element from a parameter set in an encoded data representation;

[0241] Determining (2440) a film grain model value by decoding the film grain model syntax element;

[0242] Decoding (2450) a current picture from the encoded data representation;

[0243] Generating (2460) an output picture by applying the generated film grain to the current picture; and

[0244] Outputting (2480) the output picture.

[0245] Example 12. The method according to Example 11, further comprising:

[0246] Obtaining (2562) a seed syntax element from the encoded data representation;

[0247] Determining (2564) a seed value by decoding the seed syntax element; and

[0248] Generating (2566) the generated film grain from a digital generator based on the seed value.

[0249] Example 13. The method according to Example 12, wherein the digital generator comprises a linear feedback shift register.

[0250] Example 14. The method according to any one of Examples 12 to 13, wherein obtaining the seed syntax element from the encoded data representation comprises obtaining the seed syntax element from a picture header or a film header in the encoded data representation.

[0251] Example 15. The method according to any one of Examples 12 to 14, further comprising:

[0252] Obtaining (2662) a film grain seed length syntax element from the encoded data representation; and

[0253] Determining (2664) a film grain seed length value L1 by decoding the film grain seed length syntax,

[0254] wherein the seed syntax element comprises L1 bits.

[0255] Example 16. The method according to Example 15, wherein determining the seed value by decoding the seed syntax element comprises determining the seed value as (O << L1)+D,

[0256] where O is a value derived from a first set of decoded syntax elements in an encoded data representation, and

[0257] where D is the value of a seed syntax element.

[0258] Example 17 provides a decoder (2200) that includes:

[0259] processing circuitry (2203);

[0260] a memory (2205) coupled to the processing circuitry, where the memory includes instructions that, when executed by the processing circuitry, cause the decoder to perform operations including:

[0261] obtain (2430) a film grain model syntax element from a parameter set in an encoded data representation;

[0262] determine (2440) a film grain model value by decoding the film grain model syntax element

[0263] value;

[0264] decode (2450) a current picture from the encoded data representation;

[0265] generate (2460) an output picture by applying the generated film grain to the current picture; and

[0266] output (2480) the output picture.

[0267] Example 18, The decoder according to Example 17, the operation further includes any operation according to Examples 2 to 10.

[0268] Example 19 provides an encoder (2300) that includes:

[0269] processing circuitry (2303);

[0270] a memory (2305) coupled to the processing circuitry, where the memory includes instructions that, when executed by the processing circuitry, cause the encoder to perform operations including:

[0271] obtain (2430) a film grain model syntax element from a parameter set in an encoded data representation;

[0272] determine (2440) a film grain model value by decoding the film grain model syntax element;

[0273] decode (2450) a current picture from the encoded data representation;

[0274] Generate (2460) an output picture by applying the generated film grains to the current picture; and

[0275] Output (2480) the output picture.

[0276] Example 20. The encoder according to Example 19, the operation further includes any operation according to Examples 11 to 16.

[0277] Example 21. A computer program, including program code to be executed by a decoder (2200) to perform operations, the operations including:

[0278] Obtain (2430) film grain model syntax elements from a parameter set in the encoded data representation;

[0279] Determine (2440) film grain model values by decoding the film grain model syntax elements;

[0280] Decode (2450) the current picture from the encoded data representation;

[0281] Generate (2460) an output picture by applying the generated film grains to the current picture; and

[0282] Output (2480) the output picture.

[0283] Example 22. The computer program according to Example 21, the operation further includes any operation according to Examples 2 to 10.

[0284] Example 23. A computer program, including program code to be executed by an encoder (2300) to perform operations, the operations including:

[0285] Obtain (2430) film grain model syntax elements from a parameter set in the encoded data representation;

[0286] Determine (2440) film grain model values by decoding the film grain model syntax elements;

[0287] Decode (2450) the current picture from the encoded data representation;

[0288] Generate (2460) an output picture by applying the generated film grains to the current picture; and

[0289] Output (2480) the output picture.

[0290] Example 24. The computer program according to Example 23, the operation further includes any operation according to Examples 11 to 16.

[0291] Example 25. A computer program product includes a non-transitory storage medium (2205), the non-transitory storage medium (2205) including program code to be executed by a processing circuit (2203) of a decoder (2200), whereby execution of the program code causes the decoder to perform operations including the following:

[0292] Obtain (2430) a film grain model syntax element from a parameter set in an encoded data representation;

[0293] Determine (2440) a film grain model value by decoding the film grain model syntax element;

[0294] Decode (2450) a current picture from the encoded data representation;

[0295] Generate (2460) an output picture by applying the generated film grain to the current picture; and

[0296] Output (2480) the output picture.

[0297] Example 26. The computer program product according to Example 25, the operations further include any of the operations according to Examples 2 to 10.

[0298] Example 27. A computer program product includes a non-transitory storage medium (2305), the non-transitory storage medium (2305) including program code to be executed by a processing circuit (2303) of an encoder (2300), whereby execution of the program code causes the encoder to perform operations including the following:

[0299] Obtain (2430) a film grain model syntax element from a parameter set in an encoded data representation;

[0300] Determine (2440) a film grain model value by decoding the film grain model syntax element;

[0301] Decode (2450) a current picture from the encoded data representation;

[0302] Generate (2460) an output picture by applying the generated film grain to the current picture; and

[0303] Output (2480) the output picture.

[0304] Example 28. The computer program product according to Example 27, the operations further include any of the operations according to Examples 11 to 16.

[0305] Example 29. A non - transitory computer - readable medium has instructions stored therein, which can be executed by a processing circuit (2203) to cause a decoder (2200) to perform operations, the operations including:

[0306] Obtain (2430) a film grain model syntax element from a parameter set in an encoded data representation;

[0307] Determine (2440) a film grain model value by decoding the film grain model syntax element;

[0308] Decode (2450) a current picture from the encoded data representation;

[0309] Generate (2460) an output picture by applying the generated film grains to the current picture; and

[0310] Output (2480) the output picture.

[0311] Example 30. The non - transitory computer - readable medium according to Example 29, the operations further include any of the operations according to Examples 2 to 10.

[0312] Example 31. A non - transitory computer - readable medium has instructions stored therein, which can be executed by a processing circuit (2303) to cause an encoder (2300) to perform operations, the operations including:

[0313] Obtain (2430) a film grain model syntax element from a parameter set in an encoded data representation;

[0314] Determine (2440) a film grain model value by decoding the film grain model syntax element;

[0315] Decode (2450) a current picture from the encoded data representation;

[0316] Generate (2460) an output picture by applying the generated film grains to the current picture; and

[0317] Output (2480) the output picture.

[0318] Example 32. The non - transitory computer - readable medium according to Example 31, the operations further include any of the operations according to Examples 11 to 16.

[0319] Further definitions and examples are discussed below.

[0320] In the foregoing description of the various embodiments of the inventive concept, it is to be understood that the terms used herein are for the purpose of describing particular embodiments only and are not intended to limit the inventive concept. Unless otherwise defined, all terms (including technical and scientific terms) used herein have the same meaning as commonly understood by one of ordinary skill in the art to which the inventive concept pertains. It should also be understood that terms such as those defined in a general dictionary should be interpreted as having a meaning that is consistent with their meaning in the context of the present specification and the relevant art, and should not be interpreted in an idealized or overly formal sense unless expressly so defined herein.

[0321] When an element is referred to as being "connected", "coupled", "responsive" or a variation thereof to another element, it can be directly connected, coupled to or responsive to the other elements, or intervening elements may be present. In contrast, when an element is referred to as being "directly connected", "directly coupled", "directly responsive" or a variation thereof to another element, no intervening elements are present. Throughout the specification, like reference numerals represent like elements. Further, the "coupled", "connected", "responsive" or a variation thereof used herein may include wireless coupling, connection or response. As used herein, the singular forms "a", "an" and "the" are intended to include the plural forms as well, unless the context clearly dictates otherwise. For brevity and / or clarity, well-known functions or constructions may not be described in detail. The term "and / or" (abbreviated as " / ") includes any and all combinations of one or more of the associated listed items.

[0322] It will be understood that although the terms first, second, third, etc. may be used herein to describe various elements / operations, these elements / operations should not be limited by these terms. These terms are only used to distinguish one element / operation from another. Thus, a first element / operation in some embodiments may be referred to as a second element / operation in other embodiments without departing from the teachings of the inventive concept. Throughout the specification, the same reference numerals or the same reference signs denote the same or similar elements.

[0323] As used herein, the terms “comprise,” “comprising,” “comprises,” “include,” “including,” “includes,” “have,” “has,” “having” or variations thereof are open-ended and include one or more of the stated features, integers, elements, steps, components, or functions, but do not preclude the presence or addition of one or more other features, integers, elements, steps, components, functions, or combinations thereof. Further, as used herein, the common abbreviation “e.g.” is derived from the Latin phrase “exempli gratia” and may be used to introduce or specify a general example of an item previously mentioned, without intending to be limiting of that item. The common abbreviation “i.e.” is derived from the Latin phrase “idest” and may be used to specify a particular item of a more general recitation.

[0324] Example embodiments are described herein with reference to block diagrams and / or flowchart illustrations of computer-implemented methods, apparatus (systems and / or devices), and / or computer program products. It will be understood that the blocks of the block diagrams and / or flowchart illustrations, and combinations of blocks in the block diagrams and / or flowchart illustrations, can be implemented by computer program instructions executed by one or more computer circuits. These computer program instructions can be provided to a processor circuit of a general purpose computer circuit, a special purpose computer circuit, and / or other programmable data processing circuit to produce a machine, such that the instructions executed by the processor of the computer and / or other programmable data processing device transform and control transistors, values stored in memory locations, and other hardware components within such circuits to implement the functions / actions specified in the block diagrams and / or flowchart blocks, and thereby create means (functionality) and / or structures for implementing the functions / actions specified in the block diagrams and / or flowchart blocks.

[0325] These computer program instructions can also be stored in a tangible computer-readable medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable medium produce an article of manufacture that includes instructions for implementing the functions / actions specified in the blocks of the block diagrams and / or flowchart. Accordingly, embodiments of the inventive concept can be implemented in hardware and / or in software (including firmware, stored software, microcode, etc.) running on a processor such as a digital signal processor, and the foregoing can collectively be referred to as “circuitry,” “module,” or variations thereof.

[0326] It should also be noted that in some alternative implementations, the functions / actions marked in the boxes may not occur in the order marked in the flowchart. For example, depending on the functions / actions involved, two consecutively shown boxes may actually be executed substantially simultaneously, or the boxes may sometimes be executed in the reverse order. Additionally, the functions of a given box of the flowchart and / or block diagram may be divided into multiple boxes and / or the functions of two or more boxes of the flowchart and / or block diagram may be at least partially integrated. Finally, other boxes may be added / inserted between the shown boxes, and / or boxes / operations may be omitted, without departing from the scope of the inventive concept. Further, although some boxes include arrows regarding communication paths that indicate the main direction of communication, it should be understood that communication may occur in a direction opposite to that of the represented arrows.

[0327] Many changes and modifications can be made to the embodiments without substantially departing from the principles of the inventive concept of the present invention. All such changes and modifications are intended to be included within the scope of the inventive concept herein. Accordingly, the above subject matter should be understood as illustrative and not restrictive, and the examples of the embodiments are intended to cover all such modifications, improvements, and other embodiments that fall within the spirit and scope of the inventive concept. Therefore, to the maximum extent permitted by law, the scope of the inventive concept shall be determined by the broadest permissible interpretation of this disclosure, which includes the examples of the embodiments and their equivalents, and shall not be limited to or restricted by the previous detailed description.

Claims

1. A method for decoding an encoded picture, which is executed by a decoder, the method comprising: Obtain (2430) a film grain model syntax element from an adaptive parameter set APS in the encoded data representation; Determine (2440) a film grain model value by decoding the film grain model syntax element; Obtain a seed syntax element from a picture header or a sequence header of the encoded data representation; Determine (2564) a seed value by decoding the seed syntax element; Decode (2450) a current picture from the encoded data representation; Generate (2566) film grains from a digital generator based on the seed value; Generate (2460) an output picture by applying the generated film grains to the current picture; and Output (2480) the output picture, wherein the APS includes an APS set identifier syntax element and an APS type syntax element, the APS type syntax element includes a value equal to a film grain type value, and wherein the picture header or the sequence header includes a film grain parameter set identifier syntax element, the film grain parameter set identifier syntax element includes a value equal to the value of the APS set identifier syntax element.

2. The method according to claim 1, further comprising: Store (2470) the current picture in a decoded picture buffer DPB; and Use the current picture for inter prediction to decode (2490) a subsequent picture from the encoded data representation, the subsequent picture being decoded after the output picture is generated.

3. The method according to any one of claims 1 to 2, wherein The digital generator includes a linear feedback shift register.

4. The method according to any one of claims 1 to 2, further comprising: Obtain (2662) a film grain seed length syntax element from the encoded data representation; and Determine (2664) a film grain seed length value L1 by decoding the film grain seed length syntax element, wherein the seed syntax element includes L1 bits.

5. The method according to claim 4, wherein Determining the seed value by decoding the seed syntax element includes determining the seed value as (O << L1) + D, where O is a value derived from a first set of decoded syntax elements in the encoded data representation, and where D is the value of the seed syntax element.

6. The method according to claim 5, wherein The first set of decoded syntax elements includes at least one of the following: The seed syntax element; The layer ID of the current picture; The temporal sub-layer ID of the current picture; A slice type value; A quantization parameter value; The slice address of the slice of the current picture; The sub-picture ID of the sub-picture of the current picture; and The identifier value of the current picture.

7. The method according to claim 6, wherein The identifier value of the current picture is the least significant bit of the picture order count of the current picture.

8. The method according to any one of claims 1 to 2, further comprising: Decode (2410) a film grain enable flag from the adaptive parameter set APS; and Determine (2420) that a film grain output process is enabled based on the film grain enable flag, wherein obtaining the film grain model syntax element from the adaptive parameter set APS in the encoded data representation is performed in response to determining that the film grain output process is enabled.

9. A method for encoding a picture performed by an encoder, the method comprising: Obtain (2430) a film grain model syntax element from an adaptive parameter set APS in the encoded data representation; Determine (2440) a film grain model value by decoding the film grain model syntax element; Obtain a seed syntax element from the picture header or sequence header represented by the encoded data; Determine (2564) a seed value by decoding the seed syntax element; Decode (2450) the current picture from the encoded data representation; Generate (2566) film grains from a digital generator based on the seed value; Generate (2460) an output picture by applying the generated film grains to the current picture; and Output (2480) the output picture, wherein the APS includes an APS set identifier syntax element and an APS type syntax element, the APS type syntax element includes a value equal to a film grain type value, and wherein the picture header or sequence header includes a film grain parameter set identifier syntax element, the film grain parameter set identifier syntax element includes a value equal to the value of the APS set identifier syntax element.

10. The method according to claim 9, wherein, The digital generator includes a linear feedback shift register.

11. The method according to any one of claims 9 to 10, further comprising: Obtain (2662) a film grain seed length syntax element from the encoded data representation; and Determine (2664) a film grain seed length value L1 by decoding the film grain seed length syntax element, wherein the seed syntax element includes L1 bits.

12. The method according to claim 11, wherein, Determining the seed value by decoding the seed syntax element includes determining the seed value as (O << L1) + D, where O is a value derived from a first set of decoded syntax elements in the encoded data representation, and where D is the value of the seed syntax element.

13. A decoder (2200) for decoding an encoded picture, the decoder comprising: Processing circuitry (2203); A memory (2205), coupled to the processing circuitry, wherein the memory includes instructions that, when executed by the processing circuitry, cause the decoder to perform operations including the following: Obtain (2430) a film grain model syntax element from an adaptive parameter set APS in the encoded data representation; Determine (2440) a film grain model value by decoding the film grain model syntax element; Obtain a seed syntax element from the picture header or sequence header represented by the encoded data; Determine (2564) a seed value by decoding the seed syntax element; Decode (2450) the current picture from the encoded data representation; Generate (2566) film grains from a digital generator based on the seed value; Generate (2460) an output picture by applying the generated film grains to the current picture; and Output (2480) the output picture, wherein the APS includes an APS set identifier syntax element and an APS type syntax element, the APS type syntax element includes a value equal to a film grain type value, and wherein the picture header or sequence header includes a film grain parameter set identifier syntax element, the film grain parameter set identifier syntax element includes a value equal to the value of the APS set identifier syntax element.

14. The decoder according to claim 13, wherein the operation further comprises the operation according to any one of claims 2 to 8.

15. An encoder (2300) for encoding a picture, the encoder comprising: Processing circuitry (2303); A memory (2305), coupled to the processing circuitry, wherein the memory includes instructions that, when executed by the processing circuitry, cause the encoder to perform operations including the following: Obtain (2430) a film grain model syntax element from an adaptive parameter set APS in the encoded data representation; Determine (2440) a film grain model value by decoding the film grain model syntax element; Obtain a seed syntax element from a picture header or a film header of the encoded data representation; Determine (2564) a seed value by decoding the seed syntax element; Decode (2450) a current picture from the encoded data representation; Generate (2566) film grains from a digital generator based on the seed value; Generate (2460) an output picture by applying the generated film grains to the current picture; and Output (2480) the output picture, wherein the APS includes an APS set identifier syntax element and an APS type syntax element, the APS type syntax element includes a value equal to a film grain type value, and wherein the picture header or the film header includes a film grain parameter set identifier syntax element, the film grain parameter set identifier syntax element includes a value equal to the value of the APS set identifier syntax element.

16. The encoder according to claim 15, wherein the operation further comprises the operation according to any one of claims 10 to 12.

17. A computer program product, comprising a non-transitory storage medium (2205), the non-transitory storage medium (2205) comprising program code to be executed by a processing circuit (2203) of a decoder (2200), whereby execution of the program code causes the decoder to perform operations comprising: Obtaining (2430) a film grain model syntax element from an adaptive parameter set APS in an encoded data representation; Determining (2440) a film grain model value by decoding the film grain model syntax element; Obtaining a seed syntax element from a picture header or a sequence header of the encoded data representation; Determining (2564) a seed value by decoding the seed syntax element; Decoding (2450) a current picture from the encoded data representation; Generating (2566) film grains from a digital generator based on the seed value; Generating (2460) an output picture by applying the generated film grains to the current picture; and Outputting (2480) the output picture, wherein, The APS includes an APS set identifier syntax element and an APS type syntax element, the APS type syntax element includes a value equal to a film grain type value, and wherein the picture header or the film header includes a film grain parameter set identifier syntax element, the film grain parameter set identifier syntax element includes a value equal to the value of the APS set identifier syntax element.

18. The computer program product according to claim 17, wherein the operation further comprises the operation according to any one of claims 2 to 8.

19. A computer program product comprising a non-transitory storage medium (2305), the non-transitory storage medium (2305) including program code to be executed by a processing circuit (2303) of an encoder (2300), whereby execution of the program code causes the encoder to perform operations including the following: Obtain (2430) a film grain model syntax element from an adaptive parameter set APS in an encoded data representation; Determine (2440) a film grain model value by decoding the film grain model syntax element; Obtain a seed syntax element from a picture header or a film header of the encoded data representation; Determine (2564) a seed value by decoding the seed syntax element; Decode (2450) a current picture from the encoded data representation; Generate (2566) film grains from a digital generator based on the seed value; Generate (2460) an output picture by applying the generated film grains to the current picture; and Output (2480) the output picture, wherein, The APS includes an APS set identifier syntax element and an APS type syntax element, the APS type syntax element includes a value equal to a film grain type value, and wherein the picture header or the film header includes a film grain parameter set identifier syntax element, the film grain parameter set identifier syntax element includes a value equal to the value of the APS set identifier syntax element.

20. The computer program product according to claim 19, wherein the operation further comprises the operation according to any one of claims 10 to 12.

Images