YU HAOPING (US)
US20170064336A1 | 2017-03-02 |
Claims 1. A method for decoding a video, the method comprising: accessing a binary string representing a partition of the video, the partition comprising a plurality of coding tree units (CTUs); decoding each CTU of the plurality of CTUs in the partition, decoding the CTU comprising decoding a transform unit (TU) of the CTU by: updating a replacement variable HistValue for calculating Rice parameters for the TU, wherein updating the replacement variable HistValue is performed independently of another TU of the CTU that precedes the TU and another CTU of the plurality of CTUs that precedes the CTU; calculating the Rice parameters for the TU in the CTU based on the updated replacement variable HistValue; and decoding the binary string corresponding to the TU in the CTU into coefficient values of the TU based on the calculated Rice parameters; and determining pixel values for the TU in the CTU from the coefficient values; and outputting a decoded partition of the video comprising the decoded plurality of CTUs in the partition. 2. The method of claim 1, wherein updating the replacement variable HistValue for the TU comprises calculating the replacement variable HistValue of the TU as an absolution value of the quantization level at a position within the TU, wherein a transform coefficient at the position is the the first non-zero Golomb-Rice coded transform coefficient in the TU that is coded as abs_remainder or dec_abs_level. 3. The method of claim 1, wherein updating the replacement variable HistValue for the TU comprises calculating the replacement variable HistValue of the TU as an absolution value of the quantization level at a position within the TU, wherein the quantization level at the position is the the first non-zero quantized level in the TU. 4. The method of claim 3, wherein updating the replacement variable HistValue is performed in response to at least one of: determining that a flag for updating the replacement variable HistValue is true; or determining that a flag for enabling Rice parameter derivation is true and a current position has the first non-zero quantized level. 5. The method of claim 1, wherein updating the replacement variable HistValue comprises: updating a history counter StatCoeff for a color component; and prior to calculating a next Rice parameter, updating the replacement variable HistValue based on the updated history counter StatCoeff for the color component by: HistValue [cIdx] = 1 << StatCoeff[cIdx]. 6. The method of claim 5, wherein updating the history counter StatCoeff comprises: in response to determining that a first non-zero Golomb-Rice coded transform coefficient in a TU is coded as abs_remainder, updating a history counter StatCoeff for a color component cIdx as: StatCoeff[cIdx] = (StatCoeff_init[cIdx]+Floor(Log2(abs_remainder[cIdx ])) + 2)>>1; and in response to determining that the first non-zero Golomb-Rice coded transform coefficient in the TU is coded as dec_abs_level, updating the history counter StatCoeff for a color component cIdx as: StatCoeff[cIdx] = ( StatCoeff_init [cIdx] + Floor(Log2(dec_abs_level[cIdx]))) >> 1, wherein Floor(x) represents the largest integer less than or equal to x, and Log2(x) is base-2 logarithm of x, wherein StatCoeff_init is an initial value of the history counter StatCoeff. 7. The method of claim 6, wherein the StatCoeff_init for a color component cIdx is determined for the partition based on at least one of: statCoeff_init[ idx ] = 2 * Floor( Log2( BitDepth − 10 )) or statCoeff_init[ idx ] = Clip(MIN_Stat, MAX_Stat, (int) ((19 - QP) / 6))-1 wherein BitDepth specifies the bit depth of the samples of the luma or chroma arrays, and Floor( x ) represents the largest integer less than or equal to x, and wherein MIN_Stat, MAX_Stat are two predefined integers, respectively, QP is the initial quantization parameter for each partition and Clip() is defined as follows: . 8. The method of claim 1, wherein the partition is a frame, a slice, or a tile. 9. The method of claim 1, further comprising setting the history counter StatCoeff to an initial value based on a bit depth of samples of luma and chroma arrays of the video or a quantization parameter of the current partition. 10. A non-transitory computer-readable medium having program code that is stored thereon, the program code executable by one or more processing devices for performing operations comprising: accessing a binary string representing a partition of a video, the partition comprising a plurality of coding tree units (CTUs); decoding each CTU of the plurality of CTUs in the partition, decoding the CTU comprising decoding a transform unit (TU) of the CTU by: updating a replacement variable HistValue for calculating Rice parameters for the TU, wherein updating the replacement variable HistValue is performed independently of another TU of the CTU that precedes the TU and another CTU of the plurality of CTUs that precedes the CTU; calculating the Rice parameters for the TU in the CTU based on the updated replacement variable HistValue; and decoding the binary string corresponding to the TU in the CTU into coefficient values of the TU based on the calculated Rice parameters; and determining pixel values for the TU in the CTU from the coefficient values; and outputting a decoded partition of the video comprising the decoded plurality of CTUs in the partition. 11. The non-transitory computer-readable medium of claim 10, wherein updating the replacement variable HistValue for the TU comprises calculating the replacement variable HistValue of the TU as an absolution value of the quantization level at a position within the TU, wherein a transform coefficient at the position is the the first non-zero Golomb-Rice coded transform coefficient in the TU that is coded as abs_remainder or dec_abs_level. 12. The non-transitory computer-readable medium of claim 10, wherein updating the replacement variable HistValue for the TU comprises calculating the replacement variable HistValue of the TU as an absolution value of the quantization level at a position within the TU, wherein the quantization level at the position is the the first non-zero quantized level in the TU. 13. The non-transitory computer-readable medium of claim 12, wherein updating the replacement variable HistValue is performed in response to at least one of: determining that a flag for updating the replacement variable HistValue is true; or determining that a flag for enabling Rice parameter derivation is true and a current position has the first non-zero quantized level. 14. The non-transitory computer-readable medium of claim 10, wherein updating the replacement variable HistValue comprises: updating a history counter StatCoeff for a color component based on an initial value of the history counter StatCoeff; and prior to calculating a next Rice parameter, updating the replacement variable HistValue based on the updated history counter StatCoeff for the color component by: HistValue [cIdx] = 1 << StatCoeff[cIdx]. 15. A system comprising: a processing device; and a non-transitory computer-readable medium communicatively coupled to the processing device, wherein the processing device is configured to execute program code stored in the non-transitory computer-readable medium and thereby perform operations comprising: accessing a binary string representing a partition of a video, the partition comprising a plurality of coding tree units (CTUs); decoding each CTU of the plurality of CTUs in the partition, decoding the CTU comprising decoding a transform unit (TU) of the CTU by: updating a replacement variable HistValue for calculating Rice parameters for the TU, wherein updating the replacement variable HistValue is performed independently of another TU of the CTU that precedes the TU and another CTU of the plurality of CTUs that precedes the CTU; calculating the Rice parameters for the TU in the CTU based on the updated replacement variable HistValue; and decoding the binary string corresponding to the TU in the CTU into coefficient values of the TU based on the calculated Rice parameters; and determining pixel values for the TU in the CTU from the coefficient values; and outputting a decoded partition of the video comprising the decoded plurality of CTUs in the partition. 16. The system of claim 15, wherein updating the replacement variable HistValue for the TU comprises calculating the replacement variable HistValue of the TU as an absolution value of the quantization level at a position within the TU, wherein a transform coefficient at the position is the the first non-zero Golomb-Rice coded transform coefficient in the TU that is coded as abs_remainder or dec_abs_level. 17. The system of claim 15, wherein updating the replacement variable HistValue for the TU comprises calculating the replacement variable HistValue of the TU as an absolution value of the quantization level at a position within the TU, wherein the quantization level at the position is the the first non-zero quantized level in the TU. 18. The system of claim 17, wherein updating the replacement variable HistValue is performed in response to at least one of: determining that a flag for updating the replacement variable HistValue is true; or determining that a flag for enabling Rice parameter derivation is true and a current position has the first non-zero quantized level. 19. The system of claim 15, wherein updating the replacement variable HistValue comprises: updating a history counter StatCoeff for a color component based on an initial value of the history counter StatCoeff; and prior to calculating a next Rice parameter, updating the replacement variable HistValue based on the updated history counter StatCoeff for the color component by: HistValue [cIdx] = 1 << StatCoeff[cIdx]. 20. The system of claim 15, wherein the partition is a frame, a slice, or a tile. 21. A method for encoding a video, the method comprising: accessing a partition of the video, the partition comprising a plurality of coding tree units (CTUs); processing the partition of the video to generate a binary representation of the partition, the processing comprising: encoding each CTU of the plurality of CTUs in the partition, encoding the CTU comprising encoding a transform unit (TU) of the CTU by: updating a replacement variable HistValue for calculating Rice parameters for the TU, wherein updating the replacement variable HistValue is performed independently of (a) another TU of the CTU that precedes the TU and (b) another CTU of the plurality of CTUs that precedes the CTU; calculating the Rice parameters for the TU in the CTU based on the updated replacement variable HistValue; and encoding coefficient values of the TU into a binary representation corresponding to the TU in the CTU based on the calculated Rice parameters; and encoding the binary representation of the partition into a bitstream of the video. 22. The method of claim 21, wherein updating the replacement variable HistValue for the TU comprises calculating the replacement variable HistValue of the TU as an absolution value of the quantization level at a position within the TU, wherein a transform coefficient at the position is the the first non-zero Golomb-Rice coded transform coefficient in the TU that is coded as abs_remainder or dec_abs_level. 23. The method of claim 21, wherein updating the replacement variable HistValue for the TU comprises calculating the replacement variable HistValue of the TU as an absolution value of the quantization level at a position within the TU, wherein the quantization level at the position is the the first non-zero quantized level in the TU. 24. The method of claim 23, wherein updating the replacement variable HistValue is performed in response to at least one of: determining that a flag for updating the replacement variable HistValue is true; or determining that a flag for enabling Rice parameter derivation is true and a current position has the first non-zero quantized level. 25. The method of claim 21, wherein updating the replacement variable HistValue comprises: updating a history counter StatCoeff for a color component; and prior to calculating a next Rice parameter, updating the replacement variable HistValue based on the updated history counter StatCoeff for the color component by: HistValue [cIdx] = 1 << StatCoeff[cIdx]. 26. The method of claim 25, wherein updating the history counter StatCoeff comprises: in response to determining that a first non-zero Golomb-Rice coded transform coefficient in a TU is coded as abs_remainder, updating a history counter StatCoeff for a color component cIdx as: StatCoeff[cIdx] = (StatCoeff_init[cIdx]+Floor(Log2(abs_remainder[cIdx ])) + 2)>>1; and in response to determining that the first non-zero Golomb-Rice coded transform coefficient in the TU is coded as dec_abs_level, updating the history counter StatCoeff for a color component cIdx as: StatCoeff[cIdx] = ( StatCoeff_init [cIdx] + Floor(Log2(dec_abs_level[cIdx]))) >> 1, wherein Floor(x) represents the largest integer less than or equal to x, and Log2(x) is base-2 logarithm of x, wherein StatCoeff_init is an initial value of the history counter StatCoeff. 27. The method of claim 26, wherein the StatCoeff_init for a color component cIdx is determined for the partition based on at least one of: statCoeff_init[ idx ] = 2 * Floor( Log2( BitDepth − 10 )) or statCoeff_init[ idx ] = Clip(MIN_Stat, MAX_Stat, (int) ((19 - QP) / 6))-1 wherein BitDepth specifies the bit depth of the samples of the luma or chroma arrays, and Floor( x ) represents the largest integer less than or equal to x, and wherein MIN_Stat, MAX_Stat are two predefined integers, respectively, QP is the initial quantization parameter for each partition and Clip() is defined as follows: ; z < x ; z > y . ; otherwise 28. The method of claim 21, wherein the partition is a frame, a slice, or a tile. 29. The method of claim 1, further comprising setting the history counter StatCoeff to an initial value based on a bit depth of samples of luma and chroma arrays of the video or a quantization parameter of the current partition. 30. A non-transitory computer-readable medium having program code that is stored thereon, the program code executable by one or more processing devices for performing operations comprising: accessing a partition of the video, the partition comprising a plurality of coding tree units (CTUs); processing the partition of the video to generate a binary representation of the partition, the processing comprising: encoding each CTU of the plurality of CTUs in the partition, encoding the CTU comprising encoding a transform unit (TU) of the CTU by: updating a replacement variable HistValue for calculating Rice parameters for the TU, wherein updating the replacement variable HistValue is performed independently of another TU of the CTU that precedes the TU and another CTU of the plurality of CTUs that precedes the CTU; calculating the Rice parameters for the TU in the CTU based on the updated replacement variable HistValue; and encoding coefficient values of the TU into a binary representation corresponding to the TU in the CTU based on the calculated Rice parameters; and encoding the binary representation of the partition into a bitstream of the video. 31. The non-transitory computer-readable medium of claim 30, wherein updating the replacement variable HistValue for the TU comprises calculating the replacement variable HistValue of the TU as an absolution value of the quantization level at a position within the TU, wherein a transform coefficient at the position is the the first non-zero Golomb-Rice coded transform coefficient in the TU that is coded as abs_remainder or dec_abs_level. 32. The non-transitory computer-readable medium of claim 30, wherein updating the replacement variable HistValue for the TU comprises calculating the replacement variable HistValue of the TU as an absolution value of the quantization level at a position within the TU, wherein the quantization level at the position is the the first non-zero quantized level in the TU. 33. The non-transitory computer-readable medium of claim 32, wherein updating the replacement variable HistValue is performed in response to at least one of: determining that a flag for updating the replacement variable HistValue is true; or determining that a flag for enabling Rice parameter derivation is true and a current position has the first non-zero quantized level. 34. The non-transitory computer-readable medium of claim 30, wherein updating the replacement variable HistValue comprises: updating a history counter StatCoeff for a color component based on an initial value of the history counter StatCoeff; and prior to calculating a next Rice parameter, updating the replacement variable HistValue based on the updated history counter StatCoeff for the color component by: HistValue [cIdx] = 1 << StatCoeff[cIdx]. 35. A system comprising: a processing device; and a non-transitory computer-readable medium communicatively coupled to the processing device, wherein the processing device is configured to execute program code stored in the non-transitory computer-readable medium and thereby perform operations comprising: accessing a partition of the video, the partition comprising a plurality of coding tree units (CTUs); processing the partition of the video to generate a binary representation of the partition, the processing comprising: encoding each CTU of the plurality of CTUs in the partition, encoding the CTU comprising encoding a transform unit (TU) of the CTU by: updating a replacement variable HistValue for calculating Rice parameters for the TU, wherein updating the replacement variable HistValue is performed independently of another TU of the CTU that precedes the TU and another CTU of the plurality of CTUs that precedes the CTU; calculating the Rice parameters for the TU in the CTU based on the updated replacement variable HistValue; and encoding coefficient values of the TU into a binary representation corresponding to the TU in the CTU based on the calculated Rice parameters; and encoding the binary representation of the partition into a bitstream of the video. 36. The system of claim 35, wherein updating the replacement variable HistValue for the TU comprises calculating the replacement variable HistValue of the TU as an absolution value of the quantization level at a position within the TU, wherein a transform coefficient at the position is the the first non-zero Golomb-Rice coded transform coefficient in the TU that is coded as abs_remainder or dec_abs_level. 37. The system of claim 35, wherein updating the replacement variable HistValue for the TU comprises calculating the replacement variable HistValue of the TU as an absolution value of the quantization level at a position within the TU, wherein the quantization level at the position is the the first non-zero quantized level in the TU. 38. The system of claim 37, wherein updating the replacement variable HistValue is performed in response to at least one of: determining that a flag for updating the replacement variable HistValue is true; or determining that a flag for enabling Rice parameter derivation is true and a current position has the first non-zero quantized level. 39. The system of claim 35, wherein updating the replacement variable HistValue comprises: updating a history counter StatCoeff for a color component based on an initial value of the history counter StatCoeff; and prior to calculating a next Rice parameter, updating the replacement variable HistValue based on the updated history counter StatCoeff for the color component by: HistValue [cIdx] = 1 << StatCoeff[cIdx]. 40. The system of claim 35, wherein the partition is a frame, a slice, or a tile. |
statCoeff_init specifies the value used for calculating HistValue used for the residual_coding( ) syntax structure in the current slice. When not present, the value of statCoeff_init is inferred to be equal to 0. [0071] Before coding each TU, the history value HistValue is calculated according to Eqn. (8). The calculated history value is used to derive the Rice parameter for coding the first abs_remainder or dec_abs_level syntax element for each TU if possible. In another example, if the last significant coefficient (e.g., last non-zero coefficient) in a TU has abs_remainder[] part in its level coding, the calculated history value may be used to derive the Rice parameter for coding the remaining level of the last significant coefficient. HistValue = 1 << StatCoeff_init[cIdx] (8) [0072] While in the above example, StatCoeff_init[cIdx] is defined for each slice in the slice header, it can be defined for other types of partition, such as a frame or a tile. [0073] Update of StatCoeff [0074] In one embodiment, the history counter StatCoeff is updated for each TU that requires history-based Rice parameter derivation based on the initial history counter value StatCoeff_init rather than the history counter StatCoeff from the previous TU. Once the history counter StatCoeff is updated, the replacement variable HistValue is updated based on the value of the history counter StatCoeff. In this way, the remaining positions within the current TU are coded using the updated history counter StatCoeff and the corresponding updated replacement variable HistValue until the replacement variable HistValue and the history counter StatCoeff are updated again. As a result, the history counter StatCoeff is independent of the history counter StatCoeff of the previous TU. Likewise, the derived replacement variable HistValue is also independent of the replacement variable HistValue from the previous TUs or CTUs. [0075] In this embodiment, when the first, non-zero, Golomb-Rice coded transform coefficient in TU is coded as abs_remainder, the history counter for color component cIdx is updated as following: StatCoeff[cIdx] = (9) ( StatCoeff_init[cIdx] + Floor(Log2(abs_remainder[cIdx])) + 2 ) >> 1 When the first, non-zero, Golomb-Rice coded transform coefficient in TU is coded as dec_abs_level, the history counter for color component cIdx is updated as the following: StatCoeff[cIdx] = ( StatCoeff_init [cIdx] + Floor(Log2(dec_abs_level[cIdx])) ) ) > Once the history counter StatCoeff[cIdx] is updated, the HistValue will be updated conjunctionally according to Eqn. (2) and the updated HistValue will be used in the derivation of Rice parameters for remaining abs_remainder and dec_abs_level syntax elements till the new StatCoeff[cIdx] and HistValue are updated again. [0076] Example changes to the VVC specification are specified as follows. Change clause 7.3.11.11 (Residual coding syntax) as follows (additions are underlined):
[0077] In another embodiment, the replacement variable HistValue for each TU is updated based on the quantized level of the first non-zero Golomb-Rice coded transform coefficient in the TU that is coded as abs_remainder or dec_abs_level. Because the quantized levels of the first non-zero Golomb-Rice coded transform coefficient that is coded as abs_remainder or dec_abs_level in different TUs are independent of each other, the derived replacement variable HistValues are also independent of each other. As a result, the history-based Rice parameter derivation for each TU is independent of the Rice parameter derivation for other TUs. [0078] In this embodiment, when the first non-zero Golomb-Rice coded transform coefficient in TU is coded as abs_remainder or dec_abs_level, the HistValue will be updated based on the quantized level of the transform coefficient according to Eqn. (11) and the updated HistValue will be used in the derivation of Rice parameter for remaining abs_remainder and dec_abs_level syntax elements, HistValue = abs(level) (11) where abs(x) represents the absolute value of x, level is the quantized level at the current position (i.e., the quantized level of the first non-zero Golomb-Rice coded transform coefficient in the TU that is coded as abs_remainder or dec_abs_level). [0079] Example changes to VVC specification are specified as follows. Change clause 7.3.11.11 (Residual coding syntax) as follows (additions are underlined and removals are shown in strikethrough):
[0080] In a further embodiment, the replacement variable HistValue for each TU is updated based on the first non-zero quantized level in the TU. Because the first non-zero quantized levels in different TUs are independent of each other, the derived replacement variable HistValues are also independent of each other. As a result, the history-based Rice parameter derivation for each TU is independent of the Rice parameter derivation for other TUs. Further, because the last significant coefficient (the first non-zero coefficient to be coded) in the TU is closer to the boundary of the TU, it is a better estimate of the neighboring coefficient values outside the TU boundary as shown in FIG. 6. Using the quantized level of the last significant coefficient as the HistValue can thus provide a better estimate for the out-of-boundary neighboring coefficient which leads to a more accurate estimate of the Rice parameter. [0081] In this embodiment, after the last significant coefficient (the first non-zero quantized level, level) in TU is coded, the HistValue will be updated with the absolute level of last significant coefficient as shown in Eqn. (12) and the updated HistValue will be used in the derivation of Rice parameter for remaining abs_remainder and dec_abs_level syntax elements within the current TU. HistValue = abs(level) (12) where abs(x) represent the absolute value of x. [0082] Example changes to VVC specification are specified as follows. Change clause 7.3.11.11 (Residual coding syntax) as follows (additions are underlined and removals are shown in strikethrough):
In this example, the replacement variable HistValue is updated in response to determining that the Rice parameter derivation is enabled (indicated by sps_persistent_rice_adaptation_enabled_flag) and that the current position is the last significant coefficient. The flag updateHist is no longer needed and thus can be removed. [0083] In another example, changes to the VVC specification can be made as follows: Change clause 7.3.11.11 (Residual coding syntax) as follows (additions are underlined and removals are shown in strikethrough):
In this example, the replacement variable HistValue is updated in response to determining that the flag updateHist indicates that the replacement variable HistValue has not been updated (e.g., having a value 1). After the HistValue is updated, the flag updateHist is changed to 0 to indicate that the replacement variable HistValue for this TU has been updated so that HistValue does not need to be updated again for the TU. [0084] In a further example, changes to the VVC specification can be made as follows: Change clause 7.3.11.11 (Residual coding syntax) as follows (additions are underlined and removals are shown in strikethrough): In this example, an initial value for the replacement variable HistValue is calculated for the whole partition (e.g., a slice, a frame, or a tile) as follows: HistValue = sps_persistent_rice_adaptation_enabled_flag ? (13) 1<<statCoeff_init[cIdx] : 0 Before coding each TU, the initial history value may be used to derive the Rice parameter for coding the first abs_remainder or dec_abs_level syntax element for each TU if possible. In another case, if the last significant coefficient in a TU has abs_remainder[] part in its level coding, the calculated history value may be used to derive the Rice parameter for coding the remaining level of the last significant coefficient. Since the initial value of the replacement variable HistValue is defined at the partition level, there is no need to initialize it for each TU. The initialization of the HistValue in the above table is therefore removed. [0085] As can be seen from the above examples of this embodiment, by updating the HistValue based on the first non-zero quantized level in the TU, the calculation and update of the history counter StatCoeff can be eliminated thereby reducing the computational complexity of the coding process. [0086] FIG. 7 depicts an example of a process 700 for encoding a partition for a video, according to some embodiments of the present disclosure. One or more computing devices (e.g., the computing device implementing the video encoder 100) implement operations depicted in FIG. 7 by executing suitable program code (e.g., the program code implementing the entropy coding module 116). For illustrative purposes, the process 700 is described with reference to some examples depicted in the figures. Other implementations, however, are possible. [0087] At block 702, the process 700 involves accessing a partition of a video signal. The partition can be a video frame, a slice, or a tile or any type of partition processed by a video encoder as a unit when performing the encoding. The partition includes a set of CTUs. Each CTU includes one or more CUs, and each CU includes multiple TUs for encoding as shown in the example of FIG. 6. [0088] At block 704, which includes 706-712, the process 700 involves processing each CTU of the set of CTUs in the partition to encode the partition into bits. At block 706, the process 700 involves updating the replacement variable HistValue for a TU in the CTU independently of the previous TU or CTU. As discussed above, in some embodiments, updating the replacement variable HistValue can be performed whenever the history counter StatCoeff is updated. For example, updating the history counter StatCoeff is performed according to Eqn. (9) and Eqn. (10) when the first, non-zero, Golomb-Rice coded transform coefficient in a TU is coded as abs_remainder and dec_abs_level, respectively. [0089] In another embodiment, updating the replacement variable HistValue can be based on the the first non-zero Golomb-Rice coded transform coefficient in the TU that is coded as abs_remainder or dec_abs_level. The HistValue can be updated based on the quantized level of the transform coefficient according to Eqn. (11) and the updated HistValue will be used in the derivation of Rice parameter for remaining abs_remainder and dec_abs_level syntax elements. In further embodiments, the HistValue is updated with the absolute level of last significant coefficient of the TU as shown in Eqn. (12) and the updated HistValue will be used in the derivation of Rice parameter for remaining abs_remainder and dec_abs_level syntax elements within the current TU. [0090] At block 708, the Rice parameters for the TUs in the CTU are calculated as discussed above based on the updated replacement variable HistValue. At block 710, the process 700 involves encoding the TUs in the CTU into binary representation based on the calculated Rice parameters, such as through a combination of truncated Rice (TR) and limited k-th order EGK as specified in the VVC specification. At block 712, the process 700 involves encoding the binary representation of the CTU into the bits for inclusion in the bitstream of the video. The encoding can be performed, for example, using the context- adaptive binary arithmetic coding (CABAC) discussed above. At block 714, the process 700 involves outputting the encoded video bitstream. [0091] FIG. 8 depicts an example of a process 800 for decoding a partition for a video, according to some embodiments of the present disclosure. One or more computing devices implement operations depicted in FIG.8 by executing suitable program code. For example, a computing device implementing the video decoder 200 may implement the operations depicted in FIG. 8 by executing the program code for the entropy decoding module 216, the inverse quantization module 218, and the inverse transform module 219. For illustrative purposes, the process 800 is described with reference to some examples depicted in the figures. Other implementations, however, are possible. [0092] At block 802, the process 800 involves accessing a binary string or a binary representation that represents a partition of a video signal. The partition can be a video frame, a slice, or a tile or any type of partition processed by a video encoder as a unit when performing the encoding. The partition includes a set of CTUs. Each CTU includes one or more CUs and each CU includes multiple TUs for encoding as shown in the example of FIG.6. [0093] At block 804, which includes 806-812, the process 800 involves processing the binary string for each CTU of the set of CTUs in the partition to generate decoded samples for the partition. At block 806, the process 800 involves updating the replacement variable HistValue for a TU in the CTU independently of the previous TU or CTU. As discussed above, in some embodiments, updating the replacement variable HistValue can be performed whenever the history counter StatCoeff is updated. For example, updating the history counter StatCoeff is performed according to Eqn. (9) and Eqn. (10) when the first non-zero Golomb-Rice coded transform coefficient in a TU is coded as abs_remainder and dec_abs_level, respectively. [0094] In another embodiment, updating the replacement variable HistValue can be based on the the first non-zero Golomb-Rice coded transform coefficient in the TU that is coded as abs_remainder or dec_abs_level. The HistValue can be updated based on the quantized level of the transform coefficient according to Eqn. (11) and the updated HistValue will be used in the derivation of Rice parameter for remaining abs_remainder and dec_abs_level syntax elements. In further embodiments, the HistValue is updated with the absolute level of last significant coefficient of the TU as shown in Eqn. (12) and the updated HistValue will be used in the derivation of Rice parameter for remaining abs_remainder and dec_abs_level syntax elements within the current TU. [0095] At block 808, the process 800 involves calculating the Rice parameters for the TU in the CTU as discussed above based on the updated replacement variable HistValue. At block 810, the process 800 involves decoding the binary strings or binary representations of TU in the CTU into coefficient values based on the calculated Rice parameters, such as through a combination of truncated Rice (TR) and limited k-th order EGK as specified in the VVC specification. At block 812, the process 800 involves reconstructing the pixel values for the TU in the CTU through, for example, reverse quantization and reversion transformation as discussed above with respect to FIG. 2. At block 814, the process 800 involves outputting the decoded partition of the video. [0096] While in the above description, TUs are described and illustrated in the figures (e.g., FIG. 6), the same techniques can be applied to transform blocks (TBs). In other words, in the embodiments presented above (including the figures), TUs can also represent TBs. [0097] Computing System Example for Implementing Dependent Quantization for Video Coding [0098] Any suitable computing system can be used for performing the operations described herein. For example, FIG. 9 depicts an example of a computing device 900 that can implement the video encoder 100 of FIG. 1 or the video decoder 200 of FIG. 2. In some embodiments, the computing device 900 can include a processor 912 that is communicatively coupled to a memory 914 and that executes computer-executable program code and/or accesses information stored in the memory 914. The processor 912 may comprise a microprocessor, an application-specific integrated circuit (“ASIC”), a state machine, or other processing device. The processor 912 can include any of a number of processing devices, including one. Such a processor can include or may be in communication with a computer-readable medium storing instructions that, when executed by the processor 912, cause the processor to perform the operations described herein. [0099] The memory 914 can include any suitable non-transitory computer-readable medium. The computer-readable medium can include any electronic, optical, magnetic, or other storage device capable of providing a processor with computer-readable instructions or other program code. Non-limiting examples of a computer-readable medium include a magnetic disk, memory chip, ROM, RAM, an ASIC, a configured processor, optical storage, magnetic tape or other magnetic storage, or any other medium from which a computer processor can read instructions. The instructions may include processor-specific instructions generated by a compiler and/or an interpreter from code written in any suitable computer-programming language, including, for example, C, C++, C#, Visual Basic, Java, Python, Perl, JavaScript, and ActionScript. [0100] The computing device 900 can also include a bus 916. The bus 916 can communicatively couple one or more components of the computing device 900. The computing device 900 can also include a number of external or internal devices such as input or output devices. For example, the computing device 900 is shown with an input/output (“I/O”) interface 918 that can receive input from one or more input devices 920 or provide output to one or more output devices 922. The one or more input devices 920 and one or more output devices 922 can be communicatively coupled to the I/O interface 918. The communicative coupling can be implemented via any suitable manner (e.g., a connection via a printed circuit board, connection via a cable, communication via wireless transmissions, etc.). Non-limiting examples of input devices 920 include a touch screen (e.g., one or more cameras for imaging a touch area or pressure sensors for detecting pressure changes caused by a touch), a mouse, a keyboard, or any other device that can be used to generate input events in response to physical actions by a user of a computing device. Non-limiting examples of output devices 922 include an LCD screen, an external monitor, a speaker, or any other device that can be used to display or otherwise present outputs generated by a computing device. [0101] The computing device 900 can execute program code that configures the processor 912 to perform one or more of the operations described above with respect to FIGS. 1-8. The program code can include the video encoder 100 or the video decoder 200. The program code may be resident in the memory 914 or any suitable computer-readable medium and may be executed by the processor 912 or any other suitable processor. [0102] The computing device 900 can also include at least one network interface device 924. The network interface device 924 can include any device or group of devices suitable for establishing a wired or wireless data connection to one or more data networks 928. Non-limiting examples of the network interface device 924 include an Ethernet network adapter, a modem, and/or the like. The computing device 900 can transmit messages as electronic or optical signals via the network interface device 924. [0103] General Considerations [0104] Numerous specific details are set forth herein to provide a thorough understanding of the claimed subject matter. However, those skilled in the art will understand that the claimed subject matter may be practiced without these specific details. In other instances, methods, apparatuses, or systems that would be known by one of ordinary skill have not been described in detail so as not to obscure claimed subject matter. [0105] Unless specifically stated otherwise, it is appreciated that throughout this specification discussions utilizing terms such as “processing,” “computing,” “calculating,” “determining,” and “identifying” or the like refer to actions or processes of a computing device, such as one or more computers or a similar electronic computing device or devices, that manipulate or transform data represented as physical electronic or magnetic quantities within memories, registers, or other information storage devices, transmission devices, or display devices of the computing platform. [0106] The system or systems discussed herein are not limited to any particular hardware architecture or configuration. A computing device can include any suitable arrangement of components that provide a result conditioned on one or more inputs. Suitable computing devices include multi-purpose microprocessor-based computer systems accessing stored software that programs or configures the computing system from a general purpose computing apparatus to a specialized computing apparatus implementing one or more embodiments of the present subject matter. Any suitable programming, scripting, or other type of language or combinations of languages may be used to implement the teachings contained herein in software to be used in programming or configuring a computing device. [0107] Embodiments of the methods disclosed herein may be performed in the operation of such computing devices. The order of the blocks presented in the examples above can be varied—for example, blocks can be re-ordered, combined, and/or broken into sub-blocks. Some blocks or processes can be performed in parallel. [0108] The use of “adapted to” or “configured to” herein is meant as open and inclusive language that does not foreclose devices adapted to or configured to perform additional tasks or steps. Additionally, the use of “based on” is meant to be open and inclusive, in that a process, step, calculation, or other action “based on” one or more recited conditions or values may, in practice, be based on additional conditions or values beyond those recited. Headings, lists, and numbering included herein are for ease of explanation only and are not meant to be limiting. [0109] While the present subject matter has been described in detail with respect to specific embodiments thereof, it will be appreciated that those skilled in the art, upon attaining an understanding of the foregoing, may readily produce alterations to, variations of, and equivalents to such embodiments. Accordingly, it should be understood that the present disclosure has been presented for purposes of example rather than limitation, and does not preclude the inclusion of such modifications, variations, and/or additions to the present subject matter as would be readily apparent to one of ordinary skill in the art.