WO2010085125A2 - 영상의 변환 방법 및 장치, 역변환 방법 및 장치 - Google Patents

영상의 변환 방법 및 장치, 역변환 방법 및 장치 Download PDF

Info

Publication number
WO2010085125A2
WO2010085125A2 PCT/KR2010/000443 KR2010000443W WO2010085125A2 WO 2010085125 A2 WO2010085125 A2 WO 2010085125A2 KR 2010000443 W KR2010000443 W KR 2010000443W WO 2010085125 A2 WO2010085125 A2 WO 2010085125A2
Authority
WO
WIPO (PCT)
Prior art keywords
matrix
nxn
transform
inverse
transformation
Prior art date
Application number
PCT/KR2010/000443
Other languages
English (en)
French (fr)
Other versions
WO2010085125A3 (ko
WO2010085125A9 (ko
Inventor
이태미
김일구
천민수
홍윤미
Original Assignee
삼성전자 주식회사
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by 삼성전자 주식회사 filed Critical 삼성전자 주식회사
Priority to KR1020107017851A priority Critical patent/KR101480412B1/ko
Publication of WO2010085125A2 publication Critical patent/WO2010085125A2/ko
Publication of WO2010085125A9 publication Critical patent/WO2010085125A9/ko
Publication of WO2010085125A3 publication Critical patent/WO2010085125A3/ko
Priority to US13/188,868 priority patent/US8483501B2/en

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F17/00—Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G06F17/10—Complex mathematical operations
    • G06F17/14—Fourier, Walsh or analogous domain transformations, e.g. Laplace, Hilbert, Karhunen-Loeve, transforms
    • G06F17/147—Discrete orthonormal transforms, e.g. discrete cosine transform, discrete sine transform, and variations therefrom, e.g. modified discrete cosine transform, integer transforms approximating the discrete cosine transform
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04N—PICTORIAL COMMUNICATION, e.g. TELEVISION
    • H04N19/00—Methods or arrangements for coding, decoding, compressing or decompressing digital video signals
    • H04N19/60—Methods or arrangements for coding, decoding, compressing or decompressing digital video signals using transform coding

Definitions

  • the present invention relates to an image encoding and decoding method and apparatus, and more particularly, to an improved transform and inverse transform method and apparatus for a large block.
  • video signals are hierarchically divided into sequences, frames, slices, macro blocks, and blocks, with blocks becoming the minimum processing unit.
  • encoding through intra-frame or inter-frame prediction, the predictive residual error of the block is obtained, and the block transform is performed so that energy can be concentrated on a few coefficients, and quantization, scanning, run length coding (Run Length) Coding) and entropy coding, the image data is compressed and recorded in a coded bitstream.
  • decoding the processing procedure is reversed. First, the block transform coefficients of entropy coding are extracted from the bit stream.
  • the conversion module is the basis of video compression, and the conversion performance directly affects the general performance of the codec.
  • DCT Discrete cosine transform
  • An object of the present invention is to provide a method and apparatus for transforming and inversely transforming an image using a more efficient discrete cosine transform.
  • the present invention reduces the computational complexity by using a modified transformation matrix in which irrational components of the transformation matrix are substituted by rational numbers, and by reducing the number of multiplication operations during transformation.
  • a scaling factor may be used to compensate for an error value from a conversion process based on floating-point arithmetic, thereby providing a more efficient image transformation and inverse transformation method while reducing complexity.
  • FIG. 1 illustrates an image encoding apparatus according to an embodiment of the present invention.
  • FIG. 2 shows a flow graph of four point, eight point, sixteen point, and 32 point discrete cosine transform.
  • FIG. 3 is a flowchart illustrating an image conversion method according to an embodiment of the present invention.
  • FIG. 4 is a reference diagram illustrating elements of a substituted N ⁇ N transformation matrix A in which trigonometric components included in elements of a 16 ⁇ 16 transformation matrix are substituted with variables according to an embodiment of the present invention.
  • FIG. 5 is a flowchart illustrating a quantization process according to an embodiment of the present invention.
  • FIG. 6 is a flowchart illustrating a quantization process according to another embodiment of the present invention.
  • FIG. 7 shows an example of a scaling matrix MF according to the quantization parameter QP used in the conversion of a 16x16 block according to one embodiment of the present invention.
  • FIG. 8 illustrates an inverse scaling matrix V according to a quantization parameter QP applied to a 16 ⁇ 16 block according to an embodiment of the present invention.
  • FIG. 9 to 14 show examples of a scaling matrix MF according to a quantization parameter QP applied to a 32x32 block according to an embodiment of the present invention.
  • FIG. 15 shows a flow graph of a 32 point discrete cosine transform in accordance with another embodiment of the present invention.
  • FIG. 16 is a reference diagram illustrating a calculation process of a butterfly structure constituting the 32 point discrete cosine transform of FIG. 15.
  • 17 is a flowchart illustrating a method of converting an image, according to another exemplary embodiment.
  • FIG. 18 is a view showing a modified butterfly structure according to an embodiment of the present invention.
  • FIG. 19 is a view showing a modified butterfly structure according to another embodiment of the present invention.
  • FIG. 20 is a view showing a modified butterfly structure according to another embodiment of the present invention.
  • 21 is a view showing a modified butterfly structure according to another embodiment of the present invention.
  • 22 through 27 show an example of the scaling matrix MF according to the quantization parameter QP for a 32 ⁇ 32 input block when applying the modified butterfly structure shown on the right side of FIG. 18.
  • 34 through 39 show examples of inverse scaling matrix v according to quantization parameter QP for a 32x32 input block when applying the modified butterfly structure shown on the right side of FIG.
  • 40-45 show an example of the inverse scaling matrix V according to the quantization parameter QP for a 32x32 input block when applying the modified butterfly structure shown on the right side of FIG.
  • 46 through 51 show an example of a scaling matrix MF according to the quantization parameter QP for a 32x32 input block when applying the modified butterfly structure shown on the right side of FIG.
  • 52 to 57 show an example of the scaling matrix MF according to the quantization parameter QP for the 32x32 input block when applying the modified butterfly structure shown on the right side of FIG. 19.
  • 58 through 63 show an example of an inverse scaling matrix v according to the quantization parameter QP for a 32 ⁇ 32 input block when applying the modified butterfly structure shown on the right side of FIG. 18.
  • 64 to 69 show an example of an inverse scaling matrix V according to the quantization parameter QP for a 32x32 input block when applying the modified butterfly structure shown on the right side of FIG. 19.
  • 70 to 75 show an example of the scaling matrix MF according to the quantization parameter QP for a 32x32 input block when applying the modified butterfly structure shown on the right side of FIG.
  • 82 to 87 show an example of the inverse scaling matrix v according to the quantization parameter QP for a 32 ⁇ 32 input block when applying the modified butterfly structure shown on the right side of FIG. 18.
  • 100 is a block diagram illustrating an image decoding apparatus according to an embodiment of the present invention.
  • 101 is a flowchart illustrating an inverse transform method of an image according to an embodiment of the present invention.
  • 102 is a flowchart illustrating an inverse transform method of an image according to another embodiment of the present invention.
  • an image transformation method replaces elements of an NxN transformation matrix used for one-dimensional discrete cosine transformation of a block of size NxN (N is an integer) by substituting values based on N variables.
  • Generating an NxN transform matrix Obtaining a multiplication matrix of the transposed matrix of the substituted NxN transform matrix and the substituted NxN transform matrix; Obtaining the N variables such that the sum of squares of the remaining elements except for the diagonal component of the obtained multiplication matrix is minimized; And converting the block of size NxN using an NxN transformation matrix substituted with values based on the obtained N variables.
  • a method of converting an image includes performing one-dimensional discrete cosine transform on any one of a row unit and a column unit of a block of size N ⁇ N (where N is an integer), wherein the one-dimensional discrete cosine transform is performed.
  • the cosine transform is performed by substituting the rational components of the multiplication factor of the butterfly structure with rational numbers, and the four multiplication operations and the two addition operations of the butterfly structure as three multiplication operations and three addition operations. Characterized in that it is carried out on the basis of an alternative modified butterfly structure.
  • an image conversion apparatus replaces elements constituting an NxN transformation matrix used for one-dimensional discrete cosine transformation of a block of size NxN (where N is an integer) with values based on N variables.
  • Generate an NxN transform matrix obtain a multiplication matrix of the transposed matrix of the substituted NxN transform matrix and the substituted NxN transform matrix, and minimize the sum of squares of the remaining elements except the diagonal components of the obtained multiplication matrix.
  • an image converting apparatus substitutes a rational number of trigonometric components among multiplication factors of a butterfly structure, and performs four multiplication operations and two addition operations of the butterfly structure with three multiplication operations.
  • Inverse transform method of the image comprises the steps of receiving quantized transform coefficients of the NxN (N is an integer) size block constituting the image to be decoded; Inverse quantization of the received quantized transform coefficients; And generating a substituted NxN transformation matrix by replacing elements constituting the NxN transformation matrix used for the one-dimensional discrete cosine transformation of the NxN block with values based on N variables, and generating the substituted NxN transformation matrix.
  • an inverse transform method of an image includes: receiving quantized transform coefficients of a block of size NxN (where N is an integer) constituting a decoded image; Inverse quantization of the received quantized transform coefficients; And performing a one-dimensional discrete cosine inverse transform on the inverse quantized transform coefficients, wherein performing the one-dimensional discrete cosine inverse transform comprises substituting a rational number component of a trigonometric function component of a multiplication factor of a butterfly structure, The multiplication and two addition operations of the butterfly structure are performed based on the modified butterfly structure, which is replaced by three multiplication and three addition operations.
  • the inverse transform apparatus of an image includes elements of an NxN transform matrix used for one-dimensional discrete cosine transform of an NxN (N is integer) sized block constituting a decoded image into N variables. Substituting the based values to produce a substituted NxN transformation matrix, obtaining a multiplication matrix of the transposed matrix of the substituted NxN transformation matrix and the substituted NxN transformation matrix, and obtaining the multiplication matrix of the remaining elements except the diagonal component of the obtained multiplication matrix.
  • an inverse transform apparatus for an image replaces a trigonometric function component of a multiplication factor of a butterfly structure with a rational number, and performs four multiplication operations and two addition operations of the butterfly structure with three multiplication operations.
  • FIG. 1 illustrates an image encoding apparatus according to an embodiment of the present invention.
  • the image encoding apparatus 100 may include a predictor 110, a subtractor 115, a transformer 120, a quantizer 130, and an entropy encoder 140. ).
  • the prediction unit 110 divides the input image into blocks having a predetermined size, and generates a prediction block through inter prediction or intra prediction for each of the divided blocks.
  • the prediction unit 110 generates the prediction block through a motion prediction and compensation process of generating a motion vector indicating a region similar to the current block within a predetermined search range of a previously encoded and reconstructed reference picture. And intra prediction for generating a prediction block using data of the neighboring block adjacent to the current block.
  • the subtraction unit 115 generates a residual obtained by subtracting the prediction block of the current block and the original image data.
  • the converter 120 converts the residual into the frequency domain.
  • embodiments of the present invention extend a discrete cosine transform matrix defined for relatively small sizes of 4x4 and 8x8 to provide a new discrete cosine transform scheme that can be applied to large blocks of 16x16 or more.
  • the transform unit 120 replaces elements of the transformation matrix used for the discrete cosine transform with rational values, thereby performing integer-based addition and subtraction operations rather than floating-point operations. Performing the discrete cosine transform by shift operation reduces the complexity of the operation and increases the computation speed.
  • the transform unit 120 replaces the trigonometric component of the multiplication factor of the butterfly structure with rational numbers during the one-dimensional discrete cosine transformation of the butterfly structure, and performs four multiplication operations of the butterfly structure.
  • the conversion is performed based on the modified butterfly structure, which replaces the two and two addition operations with three multiplication operations and three addition operations, thereby reducing the computational complexity and reducing the overall computational complexity.
  • the quantization unit 130 quantizes the converted residual.
  • the quantization unit 130 may reduce the error value between the transformed value using the transform matrix approximated by the transform unit 120 and the discrete cosine transform based on the actual floating point operation. Apply a predetermined scaling factor to the transform value.
  • the quantization unit 130 according to an embodiment of the present invention uses the scaling factor to determine an error value between the result of the discrete cosine transform based on the floating point operation and the result of the approximated discrete cosine transform based on the rational number. Decreases. Specific scaling and quantization processes will be described later.
  • the entropy encoder 140 generates a bitstream by performing variable length encoding on the quantized image data.
  • DCT is an effective coding technique for image compression.
  • DCT converts the image from the spatial domain to the frequency domain. Since the image data is small, the low frequency, especially the zero frequency (DC) component has a large value. In addition, since the high frequency component has a relatively low value, most of the information is concentrated toward the low frequency, and if the quantization process is performed properly, a high quality compression image can be obtained at a high compression ratio.
  • DC zero frequency
  • Each DCT method typically performs one-dimensional (1-D) DCT on a column and row basis.
  • FIG. 2 shows a flow graph of four point, eight point, sixteen point, and 32 point discrete cosine transform.
  • f0 to f31 represent input values of the one-dimensional transform.
  • f0 to f31 may be output values of the one-dimensional inverse transform.
  • F0 to F31 represent output values of the one-dimensional transform and are input values of the one-dimensional inverse transform.
  • the data processing direction is from left to right during conversion, and the data processing direction is from right to left during inverse conversion.
  • the two lines intersecting at the point represent the addition of two numbers.
  • the value above each line represents the multiplication by the corresponding coefficient.
  • c ⁇ represents cos ⁇ , s ⁇ represents sin ⁇ , and '-' represents negation.
  • Reference numeral 210 denoted by a dotted line indicates a flowchart of a four point one-dimensional transform
  • reference numeral 220 denotes a flowchart of an eight point one-dimensional transform
  • reference numeral 230 denotes a flowchart of a 16 point one-dimensional transform
  • reference numeral 240 denotes a flowchart of a 32 point one-dimensional transform.
  • a disadvantage of the discrete cosine transform is that computational complexity may increase because c ⁇ and s ⁇ may be irrational numbers depending on the value of ⁇ . As a result, even if the input value is an integer, the final conversion result can be mapped to an irrational number.
  • This discrete cosine transform increases the complexity when implemented in hardware. Accordingly, the image conversion method according to an embodiment of the present invention provides an integer conversion method that has a result value as close as possible to the original discrete cosine transform by coefficients substituted with rational values instead of irrational numbers used for discrete cosine transform. do.
  • FIG. 3 is a flowchart illustrating an image conversion method according to an embodiment of the present invention.
  • step 310 elements constituting the NxN transformation matrix Original_A used for one-dimensional discrete cosine transform of a block of size NxN (where N is an integer) are N variables (ai, i are 0 to N). Substituting values based on an integer up to -1) to produce a substituted NxN transformation matrix (A).
  • N 16 rows and 16 columns of the input block according to the flowchart shown by reference numeral 230.
  • One-dimensional discrete cosine transform is performed.
  • cos ⁇ and sin ⁇ may be irrational numbers according to the value of ⁇
  • cos ⁇ and sin ⁇ included in elements of the transformation matrix Original_A are replaced with rational values.
  • the components cos ( ⁇ x (i / 2) / N) (i is an integer from 0 to N-1) of the elements constituting the NxN transformation matrix Original_A are replaced with rational N ai variables. .
  • FIG. 4 is a reference diagram illustrating elements of a substituted N ⁇ N transformation matrix A in which trigonometric components included in elements of a 16 ⁇ 16 transformation matrix are substituted with variables according to an embodiment of the present invention.
  • elements constituting the original 16 ⁇ 16 transformation matrix may be represented by values based on 16 variables ai.
  • a multiplication matrix AxA T of a substituted NxN transform matrix A and a transpose matrix A T of the substituted NxN transform matrix is obtained in step 320.
  • the transformation matrix A is orthogonality.
  • the values of the remaining elements except for the diagonal component of the matrix according to the multiplication result of the transformation matrix A and the transpose matrix A T must be 0.
  • the values of the remaining elements except for the diagonal component among the elements of the multiplication matrix AxA T may not be zero.
  • N variables ai are obtained such that the sum of squares of the remaining elements except the diagonal component of the multiplication matrix AxA T is minimized.
  • Ai for minimizing the value of f in the above equation may be calculated by applying various optimization algorithms.
  • the optimization algorithm it is preferable that the ai variables are rational and the denominator has a power of 2 to enable a shift operation.
  • the reason for setting the constraint that the variable ai is a dyadic rational that is a power of 2 is because the denominator can be implemented using only the light shift operation (>>) when the denominator is a power of 2. .
  • a block of size NxN is transformed using the NxN transformation matrix A substituted with values based on the N variables ai obtained in step 340. That is, if the input value is X, N point one-dimensional discrete cosine transform can be performed by calculating AX.
  • Such a transformation matrix A may be obtained in advance through the above-described process and then stored in a predetermined memory and then applied to an input block having a predetermined size so that the transformation may be performed. That is, the transformation matrix is not calculated every time for the transformation process, but the transformation matrix previously obtained and stored according to an embodiment of the present invention may be used for input blocks of various sizes.
  • X0 to X15 are input values to be transformed
  • the x >> y operation is performed as (x + (1 ⁇ (y-1)). ) >> y or (abs (x) + (1 ⁇ (y-1))) >> y.
  • N when N is 32, similarly to the case where N is 16, the elements constituting the 32x32 transform matrix Original_A used for the one-dimensional discrete cosine transform of a 32x32 block are divided into 32 variables (ai). , i is substituted with values based on an integer from 0 to 31 to generate a substituted N ⁇ N transformation matrix A.
  • N when N is 32, i.e., when performing a one-dimensional discrete cosine transform for an input block of size 32x32, 32 row units and 32 column units of the input block according to the flowchart shown by reference numeral 240. One-dimensional discrete cosine transform is performed.
  • the transformation matrix representing the transformation process for the input value according to is Original_A
  • the components cos ( ⁇ x (i / 2) / 32) (i is an integer from 0 to 31) of the elements constituting the 32x32 transformation matrix (Original_A) are replaced with 32 rational variables.
  • a 32x32 block is transformed using a 32x32 transformation matrix A substituted with values based on the 32 acquired variables ai.
  • N described above is 32, that is, performing a one-dimensional discrete cosine transform using a 32x32 transform matrix A for a 32x32 input block
  • X0 to X31 are input values to be transformed
  • A0 to B31, B0 to When B31, C0 to C31, D0 to D31, E0 to E31, F0 to F31, G0 to G31, H0 to H31 are intermediate values, and Y0 to Y31 are converted values, they can be expressed as the following calculation process. have.
  • E1 (181 * (D0-D1)) >> 8;
  • E2 (236 * D3 + 97 * D2) >> 8;
  • G10 (120 * F10 + 225 * F13) >> 8;
  • G11 (244 * F11 + 74 * F12) >> 8;
  • N when N is 64, cos ( ⁇ x (i / 2) / 64) of the elements constituting the 64x64 transform matrix (Original_A) used for the one-dimensional discrete cosine transform of a 64x64 block, i is 0 to 0.
  • a 64x64 transformation matrix (A) that is substituted by substituting components of integers up to 63 with 64 ai variables, which are rational numbers, and transpose the substituted 64x64 transformation matrix (A) with the substituted 64x64 transformation matrix.
  • Applying an optimization algorithm to obtain the multiplication matrix AxA T of (A T ) and 64 variables (ai) to minimize the sum of squares of the elements of the multiplication matrix AxA T except for the diagonal component.
  • a 64x64 block is transformed using a 64x64 transformation matrix A substituted with values based on the 64 variables ai.
  • N is 64 described above, that is, performing a one-dimensional discrete cosine transform using a 64x64 transform matrix A for a 64x64 input block
  • X0 to X63 are input values to be transformed
  • Y0 to Y63 are converted values, It can be expressed as the operation process of.
  • NxN is applied by applying a scaling matrix and a shift operation to correct a difference between the original NxN transform matrix Original_A and the substituted NxN transform matrix A used for the discrete cosine transform. Quantization is performed on a transform block having a transformed block of size.
  • the original NxN transformation matrix Original_A is substituted with the transformation matrix.
  • the result value by (A) produces an error. Therefore, according to an embodiment of the present invention, the error is minimized by applying a scaling matrix in the scaling step performed with the quantization step in the quantization step.
  • FIG. 5 is a flowchart illustrating a quantization process according to an embodiment of the present invention.
  • step 510 an NxN sized transformation matrix in which an element of each i th row is substituted with each element of an NxN sized intermediate matrix S having a value of Si (i is an integer from 1 to N).
  • a conversion error matrix Original_A-S_A that is a difference between the values S_A multiplied by elements of the same position in (A) and the original NxN transformation matrix Original_A is obtained.
  • X represents an element-by-element multiplication (element-wise multiplication) operation, in which elements at the same position in the matrix are multiplied.
  • an intermediate matrix S having a size of 16 ⁇ 16 is as follows.
  • Si values are obtained such that the sum of squares of the remaining elements excluding the diagonal components of the transformation error matrix Original_A-S_A is minimized.
  • Si values can be determined using various optimization algorithms. As an example, Si values may be determined by setting an initial value of S1 to (1/4 * 2 ⁇ (1/2)) and applying an optimization algorithm such as the Nelder-Mead Sipmlex method.
  • a scaling matrix MF and a shift operation are applied to perform quantization on a transform block obtained by transforming a block of size N ⁇ N.
  • the quantization is performed by multiplying a scaling matrix MF and a transform block obtained by transforming a block of size N ⁇ N, and adding a predetermined offset to the following equation;
  • '.MF' means a vector product operation of multiplying elements of the same position of the matrix. As described above, the vector product operation may be expressed as x.
  • FIG. 7 shows an example of a scaling matrix MF according to the quantization parameter QP used in the conversion of a 16x16 block according to one embodiment of the present invention.
  • m 10 when calculating the scaling matrix.
  • the scaling matrix as shown in FIG. 7 is defined for the first six steps of Qstep values (0.625, 0.6875, 0.8125, 0.875, 1, 1.25) without having to be defined for all quantization steps. Because if the quantization parameter QP increases by 6, the quantization step Qstep is doubled, so the scaling matrix MF is defined for the first six steps of Qstep values, and the scaling matrix MF according to the remaining QP is (QP mod 6) can be selected according to the value.
  • Such a scaling matrix MF can be obtained through a process similar to the process of obtaining the scaling matrix for the 16x16 block described above for the 32x32 block or the 64x64 block.
  • 9 to 14 show examples of a scaling matrix MF according to a quantization parameter QP applied to a 32x32 block obtained through such a process.
  • the scaling matrix MF according to the quantization parameter QP applied to the 64x64 block may be defined as follows.
  • the # value of Q # is (QP mod 6), and ONES represents a 64x64 matrix with all elements of 1.
  • inverse quantization is performed by applying an inverse scaling matrix and a shift operation to correct a difference value between an original NxN inverse transform matrix used for discrete cosine inverse transform and an NxN inverse transform matrix, which is an inverse of the substituted NxN transform matrix. do.
  • the inverse scaling matrix V is the same position of each element of the intermediate matrix S and the transpose matrix S T of the intermediate matrix, which is also used in generating the aforementioned scaling matrix MF. It can be generated based on PF which is a matrix (SxS T ) multiplied by each element of.
  • a quantization step is a Qstep, a matrix obtained by multiplying each element of the intermediate matrix S and the elements of the same position of the transpose matrix S T of the intermediate matrix, respectively, where PF and n are positive integers.
  • inverse quantization is equal to floor (QP / 6) (floor [x] is less than or equal to x for a value multiplied by the inverse scaling matrix V and the quantized transform coefficients.
  • FIG. 8 illustrates an inverse scaling matrix V according to a quantization parameter QP applied to a 16 ⁇ 16 block according to an embodiment of the present invention.
  • the inverse scaling matrix (V) does not need to be defined for all quantization steps like the scaling matrix of FIG. 7, but can also be defined for the first six steps of Qstep values (0.625, 0.6875, 0.8125, 0.875, 1, 1.25). have.
  • the inverse scaling matrix V according to the remaining QP may be selected according to the (QP mod 6) value.
  • the inverse scaling matrix V according to the quantization parameter applied to the 32x32 input block and the 64x64 block may also be obtained through a process similar to the calculation process of the inverse scaling matrix V applied to the 16x16 block described above.
  • 94 through 99 show an example of an inverse scaling matrix V according to a quantization parameter QP applied to a 32x32 block according to an embodiment of the present invention.
  • the inverse scaling matrix V according to the quantization parameter QP applied to the 64x64 block may be defined as follows.
  • the # value of Q # is the value of (QP mod 6), and ONES represents a 64x64 matrix with all elements of 1.
  • FIG. 6 is a flowchart illustrating a quantization process according to another embodiment of the present invention.
  • the quantization process according to another embodiment of the present invention of FIG. 6 differs from the process of generating the intermediate matrix S used for generating the scaling matrix, when compared to the quantization process according to the embodiment of the present invention of FIG. 5.
  • the rest of the process is similar to the quantization process according to an embodiment of the present invention of FIG. 5 described above.
  • each element of the original N ⁇ N transform matrix Original_A used for the discrete cosine transform is divided into elements of the same position of the substituted N ⁇ N transform matrix A to form an intermediate matrix ( S) Acquire.
  • step 620 on the basis of the intermediate matrix (S) matrix (SxS T) obtained by multiplying each of the elements at the same position of the pre matrix (S T) of the elements of the intermediate matrix generated in step 610 and generates a scaling matrix .
  • a scaling matrix MF and a shift operation are applied to perform quantization on the transform block obtained by transforming a block of size N ⁇ N.
  • the quantization is performed by the following equation for a value obtained by adding a predetermined offset to a value obtained by multiplying a scaling matrix MF and a transform block obtained by transforming a block of size N ⁇ N;
  • '.MF' means a vector product operation of multiplying elements of the same position of the matrix.
  • FIG. 15 shows a flow graph of a 32 point discrete cosine transform in accordance with another embodiment of the present invention.
  • x0 to x31 represent input values.
  • y0 to y31 represent output values of the discrete cosine transform.
  • the data processing direction is from left to right during conversion, and the data processing direction is from right to left during inverse conversion.
  • the two lines intersecting at the point represent the addition of two numbers. '-' Indicates negation.
  • the value R ( ⁇ ) on each line represents a calculation process based on the butterfly structure as shown in FIG.
  • FIG. 16 is a reference diagram illustrating a calculation process of a butterfly structure constituting the 32 point discrete cosine transform of FIG. 15.
  • the operation of the butterfly structure is performed by the following equation for the input values [X1, X2]; It outputs the output value [Y1, Y2] through the same operation.
  • a total of four multiplication operations and two addition operations are performed in the process of mapping two input values to two output values.
  • the image conversion method according to another embodiment of the present invention is based on a modified butterfly structure in which four multiplication operations and two addition operations based on the butterfly structure are replaced by three multiplication operations and three addition operations. Perform image conversion.
  • FIG. 17 is a flowchart illustrating a method of converting an image, according to another exemplary embodiment.
  • a trigonometric function component of a multiplication factor of a butterfly structure is replaced with a rational number in step 1710.
  • cos ⁇ and sin ⁇ are used to calculate the 32 point discrete cosine transform as shown in FIG. 15 in accordance with R ( ⁇ ).
  • the following approximated rational numbers may be used as cos ⁇ and sin ⁇ values according to the ⁇ values.
  • the rational number to be approximated as described below it is preferable to use a rational ratio whose denominator is a power of two.
  • step 1720 a row of blocks of size NxN (N is an integer) based on the modified butterfly structure replacing four multiply and two add operations of the butterfly structure with three multiply and three add operations.
  • a one-dimensional discrete cosine transform is performed on either unit or column unit.
  • FIG. 18 is a view showing a modified butterfly structure according to an embodiment of the present invention.
  • the resultant values Y1 and Y2 of the input values X1 and X2 by the operation of the butterfly structure 1810 as shown on the left side may be expressed by the following equations.
  • the modified butterfly structure 1820 may improve computation speed by reducing complex multiplication operations while having the same result value.
  • the modified butterfly structure 1820 shown in the right side of FIG. 18 is applied to the 32 point discrete cosine transform of FIG. 15, there is an operation that requires a linear combination of sine and cosine. In this case, it is preferable to use the following approximated glass values.
  • FIG. 19 is a view showing a modified butterfly structure according to another embodiment of the present invention.
  • the resultant values Y1 and Y2 of the input values X1 and X2 by the operation of the butterfly structure 1910 as shown on the left side are represented by the following equations.
  • the modified butterfly structure 1920 shown on the right is left. Outputs the same result as the butterfly structure 1910 shown in FIG. In the operation of the modified butterfly structure 1920 shown in the right side, a total of three multiplication operations and three addition or subtraction operations are required. Accordingly, the modified butterfly structure 1920 may improve computation speed by reducing complex multiplication operations while having the same result value.
  • the modified butterfly structure as shown in the right side of FIG. 19 is applied to the 32-point discrete cosine transform of FIG. 15, there are operations requiring fractional and tangent values of sine and cosine. In this case, it is preferable to use the following approximated glass values.
  • each operation result is cos ⁇ and (1 / (1-cos ⁇ )) as indicated by reference numeral 2025 before the final result values Y1 and Y2 are obtained.
  • multiplication operations are performed.
  • the multiplication operation indicated by the reference numeral 2025 is not performed during the conversion process but may be reflected in the scaling matrix performed during the quantization process.
  • the multiplication operation in the transform step may be reduced, and the multiplication operation may instead be integrated into the quantization process.
  • the butterfly structure according to FIG. 20 may consist of only two multiplications and two addition operations.
  • 21 is a view showing a modified butterfly structure according to another embodiment of the present invention.
  • the calculation by the structure 2120 also shows that the same result as the calculation by the butterfly structure 2110 shown on the left side can be obtained.
  • the total number of operations may be reduced compared to the butterfly structure 2110 shown on the left side.
  • X0 to X31 are input values to be converted
  • A0 To A31, B0 to B31, C0 to C31, D0 to D31, E0 to E31, F0 to F31 are intermediate values
  • t is an auxiliary variable
  • Y0 to Y31 are converted values. It can be obtained through the operation of.
  • X0 to X31 are input values to be converted.
  • A0 to A31, B0 to B31, C0 to C31, D0 to D31, E0 to E31, F0 to F31, and G0 to G31 are intermediate values
  • Y0 to Y31 represent converted values
  • the conversion result Y0 to Y31 is It can be obtained through the following calculation process.
  • E12 D12 + D13
  • E13 D12-D13
  • E28 ((D28 + D31) * 181) >> 8;
  • E31 ((-D28 + D31) * 181) >> 8;
  • G16 F16-((F17 * 25) >> 7);
  • G17 F17 + ((G16 * 3) >> 4);
  • G28 F28-((F29 * 171) >> 8);
  • G29 F29 + ((G28 * 59) >> 7);
  • G30 F30-((F31 * 25) >> 7);
  • G31 F31 + ((G30 * 3) >> 4);
  • A is a modified discrete cosine transform matrix for transforming a 32x32 block based on the modified butterfly structure shown in FIGS. 18 and 19, it is used for discrete cosine transform of a 32x32 block corresponding to FIG. 15.
  • a quantization may be performed on a transform block obtained by transforming an N ⁇ N block by applying a scaling matrix and a shift operation to correct a difference between the original N ⁇ N transform matrix Original_A and the modified discrete cosine transform matrix A.
  • the scaling matrix includes a discrete cosine transform matrix A of each element of an intermediate matrix S of size NxN having an i-th value of Si (i is an integer from 1 to N).
  • Obtain a transform error matrix Original_A-SxA which is the difference between the elements of the same position of S (S) A, and the original N ⁇ N transform matrix, and obtain the transform error matrix Original_A-SxA.
  • Si values are obtained such that the sum of squares of the remaining elements excluding the diagonal component is minimized, and the same position of each element of the intermediate matrix S of NxN size and the transpose matrix S T of the intermediate matrix to which the obtained Si values are applied.
  • the elements S may be generated based on a matrix S ⁇ S T multiplied by elements. Except that the original N ⁇ N transformation matrix Original_A differs, the detailed process is the same as in steps 530 and 540 of FIG.
  • inverse quantization is performed by applying an inverse scaling matrix and a shift operation to correct a difference value between an original NxN inverse transform matrix used for discrete cosine inverse transform and an NxN inverse transform matrix, which is an inverse of the substituted NxN transform matrix. do.
  • the inverse scaling matrix is also changed because the matrix representing the discrete cosine transform is changed.
  • Inverse scaling matrix (V) is obtained by multiplying each of the elements at the same position of the pre matrix (S T) of the medium to be used in the generation of the above-described scaling matrix (MF) matrix (S) and the intermediate matrix, the matrix (T SxS) It may be generated based on the PF corresponding to.
  • the quantization step is multiplied by Qstep, the intermediate matrix S and the elements of the same position of the transpose matrix S T of the intermediate matrix, respectively, PF and n is a positive integer
  • inverse quantization is equal to floor (QP / 6) (floor [x] is less than or equal to x for a value multiplied by the inverse scaling matrix V and the quantized transform coefficients.
  • the scaling matrix is equal to each element of the intermediate matrix obtained by dividing each element of the original N ⁇ N transform matrix used for the discrete cosine transform by the elements in the same position of the modified discrete cosine transform matrix A. It may be a matrix obtained by multiplying elements of the same position of the transpose matrix of the intermediate matrix.
  • the modified discrete cosine transform matrix A which represents the N point one-dimensional discrete cosine transform, to which the modified butterfly structure shown in the right side of FIGS. 18 and 19 is applied to the algorithm of FIG. 15 is different. 6 is the same as in FIG. 6, and thus, a detailed description thereof will be omitted.
  • the scaling matrix divides each element of the intermediate matrix obtained by dividing each element of the original N ⁇ N transform matrix used for the discrete cosine transform by the elements in the same position of the modified discrete cosine transform matrix A.
  • the inverse scaling matrix uses each element of the original 32 point discrete cosine inverse transformation matrix (Original_InverseA) instead of using the intermediate matrix (S), and the present invention.
  • the intermediate matrix R may be determined by directly dividing an element of the same position of the 32-point discrete cosine transform matrix InverseA corresponding to the changed butterfly structure.
  • 100 is a block diagram illustrating an image decoding apparatus according to an embodiment of the present invention.
  • an image decoding apparatus 10000 includes an entropy decoding unit 10010, an inverse quantization unit 10020, an inverse transform unit 10030, and a prediction unit 10040.
  • the entropy decoder 10010 extracts prediction mode information, reference picture information, and residual information of the current block to be decoded from the input bitstream.
  • the inverse transform unit 10030 inversely transforms the inverse quantized transform coefficients. As a result of the inverse transform, residual values for a block unit are restored.
  • the inverse transform process may be performed through N point discrete cosine inverse transform using the inverse matrix A ⁇ 1 of the N ⁇ N transform matrix A obtained through various embodiments of the present invention.
  • X0 to X15 must be inverse transformed.
  • B0 to B15, C0 to C15, D0 to D15, E0 to E15, F0 to F15, G0 to G15 are intermediate values, and Y0 to Y15 are inversely converted values, are expressed as in the following calculation process Can be.
  • X0 to X31 must be inverse transformed.
  • A0 to A31, B0 to B31, C0 to C31, D0 to D31, E0 to E31, F0 to F31, G0 to G31, H0 to H31 are intermediate values, and Y0 to Y31 are inversely converted values. , Can be expressed as the following operation process.
  • X0 to X63 When performing the one-dimensional discrete cosine inverse transformation using the inverse transformation matrix A -1 of the substituted 64x64 transformation matrix A with respect to the transformed 64x64 input block according to the embodiment of FIG. 3 described above, X0 to X63 must be inversely transformed.
  • A0 to A63, B0 to B63, C0 to C63, D0 to D63, E0 to E63, F0 to F63, G0 to G63, H0 to H63, I0 to I63, O0 to O63 are intermediate values
  • Y0 to Y63 Is expressed as an inversely transformed value it can be expressed as
  • X0 to X31 are input values to be inversely transformed, A0 to A31, and B0.
  • C0 to C31, D0 to D31, E0 to E31, F0 to F31, G0 to G31, H0 to H31 are intermediate values
  • t is an auxiliary variable
  • Y0 to Y31 are inverse transformed values. It can be expressed as a process.
  • X0 to X31 are input values to be inversely transformed, A0 to A31, B0.
  • C0 to C31, D0 to D31, E0 to E31, F0 to F31, G0 to G31, H0 to H31 are intermediate values
  • t is an auxiliary variable
  • Y0 to Y31 are inverse transformed values. It can be expressed as a process.
  • the prediction unit 10040 generates a prediction block of the current block decoded through inter prediction or intra prediction, and reconstructs the current block by adding the residual value and the prediction block output from the inverse transformer 10030.
  • 101 is a flowchart illustrating an inverse transform method of an image according to an embodiment of the present invention.
  • quantized transform coefficients of a block of size NxN (N is an integer) constituting a decoded image are received.
  • step 10120 inverse quantizes the received quantized transform coefficients.
  • inverse quantization is the floor (QP / 6) (floor [x] is the largest integer less than or equal to x, and QP is the quantization parameter) bit for the value of the inverse scaling matrix (V) multiplied by the quantized transform coefficient. As long as the bit shift can be performed.
  • step 10130 the elements constituting the NxN transformation matrix used for the one-dimensional discrete cosine transform of the NxN size block are replaced with values based on N variables to generate a substituted NxN transformation matrix, and Obtain a multiply matrix of the transpose matrix of the substituted N ⁇ N transform matrix, obtain N variables such that the sum of squares of the elements except the diagonal component of the obtained multiply matrix is minimized, and obtain values based on the obtained N variables. using the inverse matrix of the substituted NxN transformation matrix (a) NxN inverse matrix (a -1) and inverse transformation blocks of de-quantized transform coefficients of size NxN.
  • 102 is a flowchart illustrating an inverse transform method of an image according to another embodiment of the present invention.
  • NxN (N is an integer) quantized transform coefficients of a block constituting an image to be decoded are received.
  • inverse quantization may be performed using an inverse of the transformation matrix corresponding to the modified butterfly structure corresponding to FIGS. 18 and 19.
  • the modified butterfly replaces the trigonometric component of the multiplication factor of the butterfly structure with a rational number and replaces the four multiplication and two addition operations of the butterfly structure with three multiplication and three addition operations.
  • a one-dimensional discrete cosine inverse transform on the dequantized transform coefficients is performed based on the structure.
  • each transformation process is expressed as the product of the dyadic rational, whose denominator is a power of 2, and the median. If you decompose a constant in the form of a dyadic rational with a denominator of 2 in the form of addition and subtraction only for fractions with a numerator of 1, the operation can be performed by addition, subtraction, and shift operations without multiplication. have. In addition, if the number of terms is minimized during decomposition, the number of addition, subtraction, and shift operations can be reduced.
  • 59/64 one of the dyadic rationals whose denominator is a power of 2, can be changed to (1-1 / 16-1 / 64).
  • the 255/256, 131/256, 999/1024, and 75/1024, the dyadic rationals of the denominator of 2 are the numerator of 1 and the denominator of 2, respectively: It can be resolved in the form of addition and subtraction of dyadic rational.
  • the system according to the present invention can be embodied as computer readable codes on a computer readable recording medium.
  • the computer-readable recording medium includes all kinds of recording devices in which data that can be read by a computer system is stored. Examples of the recording medium include ROM, RAM, CD-ROM, magnetic tape, floppy disk, optical data storage device and the like.
  • the computer readable recording medium can also be distributed over network coupled computer systems so that the computer readable code is stored and executed in a distributed fashion.
  • the present invention can be used in the process of converting and inverting still images and videos.

Landscapes

  • Physics & Mathematics (AREA)
  • Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Mathematical Physics (AREA)
  • Data Mining & Analysis (AREA)
  • Mathematical Optimization (AREA)
  • Mathematical Analysis (AREA)
  • Pure & Applied Mathematics (AREA)
  • Computational Mathematics (AREA)
  • Theoretical Computer Science (AREA)
  • General Engineering & Computer Science (AREA)
  • Databases & Information Systems (AREA)
  • Software Systems (AREA)
  • Discrete Mathematics (AREA)
  • Algebra (AREA)
  • Multimedia (AREA)
  • Signal Processing (AREA)
  • Compression Or Coding Systems Of Tv Signals (AREA)
  • Complex Calculations (AREA)
  • Compression Of Band Width Or Redundancy In Fax (AREA)
  • Compression, Expansion, Code Conversion, And Decoders (AREA)
  • Image Processing (AREA)

Abstract

영상의 변환, 역변환 방법 및 장치가 개시된다. 본 발명에 따르면 NxN(N은 정수) 크기의 블록의 1차원 이산 코사인 변환에 이용되는 NxN 변환 행렬을 구성하는 원소들을 N개의 변수들에 기초한 값들로 치환하여 치환된 NxN 변환 행렬을 생성하고, 치환된 NxN 변환 행렬과 치환된 NxN 변환 행렬의 전치 행렬의 곱셈 행렬을 획득하며, 획득된 곱셈 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 N개의 변수들에 기초한 값들로 치환된 NxN 변환 행렬을 이용하여 NxN 크기의 블록을 변환하는 것을 특징으로 한다.

Description

영상의 변환 방법 및 장치, 역변환 방법 및 장치
본 발명은 영상 부호화, 복호화 방법 및 장치에 관한 것으로, 보다 상세히는 큰 크기의 블록에 대한 향상된 변환, 역변환 방법 및 장치에 관한 것이다.
H.264 및 MPEG-4와 같은, 현재 국제 비디오 코딩 표준에서, 비디오 신호는 시퀀스, 프레임, 슬라이스, 매크로 블록 및 블록으로 계층적으로 분할되며, 블록은 최소 처리 유닛이 된다. 인코딩 측면에서, 인트라-프레임 또는 인터-프레임 예측을 통하여, 블록의 예측 잔류 오류가 획득되며, 블록 변환은 에너지가 소수의 계수에 집중될 수 있도록 실행되고, 양자화, 스캐닝, 런 렝스 코딩(Run Length Coding) 및 엔트로피 코딩을 통하여, 이미지 데이터는 압축되며, 코딩된 비트스트림으로 기록된다. 디코딩 측면에서, 처리 절차는 반대가 된다. 우선, 엔트로피 코딩의 블록 변환 계수가 비트 스트림으로부터 추출된다. 그리고 나서, 역양자화 및 역변환을 통하여, 블록의 예측 잔류 오류는 재구성되며, 예측 정보는 블록의 비디오 데이터를 재구성하기 위하여 사용된다. 인코딩-디코딩 처리절차에서, 변환 모듈은 비디오 압축의 기초이며, 변환성능은 코덱의 일반적인 성능에 직접적으로 영향을 준다.
이산 코사인 변환(DCT)은 MPEG-1 및 H.261과 같은 초기 비디오 코딩 표준에서 채택되었다. 1974년 이산 코사인 변환의 제안 이후에, DCT는 이미지 및 비디오 코딩 분야에서 널리 사용되었다. 변환 도메인 내의 이미지 요소의 상관성을 제거하며, 고효율 이미지 압축을 위한 기반을 마련하기 때문에, 그것의 변환 성능은 모든 차선 변환(sub-optimal transform)중 우수하다. 그러나, DCT 변환 행렬은 부동 소수점 수(floating point number)로 표현되기 때문에, 대량의 부동 소수점 계산으로 인하여 많은 시스템 자원이 소모된다. 변환 효율을 개선하는 한편, 큰 크기의 블록에 대한 변환을 수행하기 위하여 새로운 DCT 변환 알고리즘의 필요성이 증가되었다.
본 발명이 해결하고자 하는 기술적 과제는 보다 효율적인 이산 코사인 변환을 이용하여 영상을 변환, 역변환하는 방법 및 장치를 제공하는 데 있다.
본 발명은 변환 행렬의 무리수 성분을 유리수로 치환한 변경된 변환 행렬을 이용하고, 변환시 곱셈 연산의 횟수를 줄임으로써 연산 복잡도를 감소시킨다.
본 발명에 따르면 큰 크기의 블록에 대한 변환 및 역변환시에 부동 소수점 연산이 아닌 정수 기반의 연산 과정을 통해서 복잡도를 감소시키고 연산 속도를 증가시키는 영상의 변환 및 역변환 방법을 제공할 수 있다.
또한, 본 발명에 따르면 스케일링 팩터를 통해 부동 소수점 연산에 기반한 변환 과정과의 오차값을 보상함으로써 복잡도를 감소시키면서 보다 효율적인 영상의 변환 및 역변환 방법을 제공할 수 있다.
도 1은 본 발명의 일 실시예에 따른 영상 부호화 장치를 도시한다.
도 2는 4 포인트, 8 포인트, 16 포인트, 32 포인트 이산 코사인 변환의 흐름도(flow graph)를 도시한다.
도 3은 본 발명의 일 실시예에 따른 영상 변환 방법을 나타낸 플로우 차트이다.
도 4는 본 발명의 일 실시예에 따라서 16x16 변환 행렬의 원소에 구비된 삼각함수 성분을 변수들로 치환한 치환된 NxN 변환 행렬(A)의 원소들을 나타낸 참조도이다.
도 5는 본 발명의 일 실시예에 따른 양자화 과정을 나타낸 플로우 차트이다.
도 6은 본 발명의 다른 실시예에 따른 양자화 과정을 나타낸 플로우 차트이다.
도 7은 본 발명의 일 실시예에 따라서 16x16 블록의 변환시에 이용되는 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예를 도시한다.
도 8은 본 발명의 일 실시예에 따라서 16x16 블록에 적용되는 양자화 파라메터(QP)에 따른 역스케일링 행렬(V)을 도시한다.
도 9 내지 도 14는 본 발명의 일 실시예에 따른 32x32 블록에 적용되는 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예를 도시한다.
도 15는 본 발명의 다른 실시예에 따른 32 포인트 이산 코사인 변환의 흐름도(flow graph)를 도시한다.
도 16은 도 15의 32 포인트 이산 코사인 변환을 구성하는 버터플라이 구조의 연산 과정을 나타낸 참조도이다.
도 17은 본 발명의 다른 실시예에 따른 영상 변환 방법을 나타낸 플로우 차트이다.
도 18은 본 발명의 일 실시예에 따른 변경된 버터플라이 구조를 나타낸 도면이다.
도 19는 본 발명의 다른 실시예에 따른 변경된 버터플라이 구조를 나타낸 도면이다.
도 20은 본 발명의 또 다른 실시예에 따른 변경된 버터 플라이 구조를 나타낸 도면이다.
도 21은 본 발명의 또 다른 실시예에 따른 변경된 버터 플라이 구조를 나타낸 도면이다.
도 22 내지 도 27은 도 18의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예를 도시한다.
도 28 내지 도 33은 도 19의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예를 도시한다.
도 34 내지 도 39는 도 18의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 역스케일링 행렬 (v)의 예를 도시한다.
도 40 내지 도 45는 도 19의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 역스케일링 행렬 (V)의 예를 도시한다.
도 46 내지 도 51은 도 18의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예를 도시한다.
도 52 내지 도 57은 도 19의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예를 도시한다.
도 58 내지 도 63은 도 18의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 역스케일링 행렬 (v)의 예를 도시한다.
도 64 내지 도 69는 도 19의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 역스케일링 행렬 (V)의 예를 도시한다.
도 70 내지 도 75는 도 18의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예를 도시한다.
도 76 내지 도 81은 도 19의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예를 도시한다.
도 82 내지 도 87은 도 18의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 역스케일링 행렬 (v)의 예를 도시한다.
도 88 내지 도 93은 도 19의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 역스케일링 행렬 (V)의 예를 도시한다.
도 94 내지 도 99는 본 발명의 일 실시예에 따라서 32x32 블록에 적용되는 양자화 파라메터(QP)에 따른 역스케일링 행렬(V)의 예를 도시한다.
도 100은 본 발명의 일 실시예에 따른 영상 복호화 장치를 나타낸 블록도이다.
도 101은 본 발명의 일 실시예에 따른 영상의 역변환 방법을 나타낸 플로우 차트이다.
도 102는 본 발명의 다른 실시예에 다른 영상의 역변환 방법을 나타낸 플로우 차트이다.
본 발명의 일 실시예에 따른 영상의 변환 방법은 NxN(N은 정수) 크기의 블록의 1차원 이산 코사인 변환에 이용되는 NxN 변환 행렬을 구성하는 원소들을 N개의 변수들에 기초한 값들로 치환하여 치환된 NxN 변환 행렬을 생성하는 단계; 상기 치환된 NxN 변환 행렬과 상기 치환된 NxN 변환 행렬의 전치 행렬의 곱셈 행렬을 획득하는 단계; 상기 획득된 곱셈 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 상기 N개의 변수들을 획득하는 단계; 및 상기 획득된 N개의 변수들에 기초한 값들로 치환된 NxN 변환 행렬을 이용하여 상기 NxN 크기의 블록을 변환하는 단계를 포함하는 것을 특징으로 한다.
본 발명의 다른 실시예에 따른 영상의 변환 방법은 NxN 크기(N은 정수)의 블록의 행 단위 및 열 단위 중 어느 하나에 대한 1차원 이산 코사인 변환을 수행하는 단계를 포함하며, 상기 1차원 이산 코사인 변환을 수행하는 단계는 버터플라이 구조의 곱셈 인수 중 삼각 함수 성분을 유리수로 치환하고, 상기 버터플라이 구조의 4개의 곱셈 연산과 2개의 덧셈 연산 과정을 3개의 곱셈 연산과 3개의 덧셈 연산 과정으로 대체한 변경된 버터플라이 구조에 기초하여 수행되는 것을 특징으로 한다.
본 발명의 일 실시예에 따른 영상의 변환 장치는 NxN(N은 정수) 크기의 블록의 1차원 이산 코사인 변환에 이용되는 NxN 변환 행렬을 구성하는 원소들을 N개의 변수들에 기초한 값들로 치환하여 치환된 NxN 변환 행렬을 생성하고, 상기 치환된 NxN 변환 행렬과 상기 치환된 NxN 변환 행렬의 전치 행렬의 곱셈 행렬을 획득하며, 상기 획득된 곱셈 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 상기 N개의 변수들을 획득하고 상기 획득된 N개의 변수들에 기초한 값들로 치환함으로써 획득된 치환된 NxN 변환 행렬을 이용하여 상기 NxN 크기의 블록을 변환하는 변환부를 포함하는 것을 특징으로 한다.
본 발명의 다른 실시예에 따른 영상의 변환 장치는 버터플라이 구조의 곱셈 인수 중 삼각 함수 성분을 유리수로 치환하고, 상기 버터플라이 구조의 4개의 곱셈 연산과 2개의 덧셈 연산 과정을 3개의 곱셈 연산과 3개의 덧셈 연산 과정으로 대체한 변경된 버터플라이 구조에 기초하여 NxN 크기(N은 정수)의 블록의 행 단위 및 열 단위 중 어느 하나에 대한 1차원 이산 코사인 변환을 수행하는 변환부를 포함하는 것을 특징으로 한다.
본 발명의 일 실시예에 따른 영상의 역변환 방법은 복호화되는 영상을 구성하는 NxN(N은 정수) 크기의 블록의 양자화된 변환 계수들을 수신하는 단계; 상기 수신된 양자화된 변환 계수들을 역양자화하는 단계; 및 상기 NxN 크기의 블록의 1차원 이산 코사인 변환에 이용되는 NxN 변환 행렬을 구성하는 원소들을 N개의 변수들에 기초한 값들로 치환하여 치환된 NxN 변환 행렬을 생성하고, 상기 치환된 NxN 변환 행렬과 상기 치환된 NxN 변환 행렬의 전치 행렬의 곱셈 행렬을 획득하며, 상기 획득된 곱셈 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 상기 N개의 변수들을 획득하고, 상기 획득된 N개의 변수들에 기초한 값들로 치환된 NxN 변환 행렬의 역행렬인 NxN 역변환 행렬을 이용하여 상기 NxN 크기의 블록의 역양자화된 변환 계수들을 역변환하는 단계를 포함하는 것을 특징으로 한다.
본 발명의 다른 실시예에 따른 영상의 역변환 방법은 복호화되는 영상을 구성하는 NxN(N은 정수) 크기의 블록의 양자화된 변환 계수들을 수신하는 단계; 상기 수신된 양자화된 변환 계수들을 역양자화하는 단계; 및 역양자화된 변환 계수들에 대한 1차원 이산 코사인 역변환을 수행하는 단계를 포함하며, 상기 1차원 이산 코사인 역변환을 수행하는 단계는 버터플라이 구조의 곱셈 인수 중 삼각 함수 성분을 유리수로 치환하고, 상기 버터플라이 구조의 4개의 곱셈 연산과 2개의 덧셈 연산 과정을 3개의 곱셈 연산과 3개의 덧셈 연산 과정으로 대체한 변경된 버터플라이 구조에 기초하여 수행되는 것을 특징으로 한다.
본 발명의 일 실시예에 따른 영상의 역변환 장치는 복호화되는 영상을 구성하는 NxN(N은 정수) 크기의 블록의 1차원 이산 코사인 변환에 이용되는 NxN 변환 행렬을 구성하는 원소들을 N개의 변수들에 기초한 값들로 치환하여 치환된 NxN 변환 행렬을 생성하고, 상기 치환된 NxN 변환 행렬과 상기 치환된 NxN 변환 행렬의 전치 행렬의 곱셈 행렬을 획득하며, 상기 획득된 곱셈 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 상기 N개의 변수들을 획득하고, 상기 획득된 N개의 변수들에 기초한 값들로 치환된 NxN 변환 행렬의 역행렬인 NxN 역변환 행렬을 이용하여, 상기 NxN 크기의 블록의 역양자화된 변환 계수들을 역변환하는 역변환부를 포함하는 것을 특징으로 한다.
본 발명의 다른 실시예에 따른 영상의 역변환 장치는 버터플라이 구조의 곱셈 인수 중 삼각 함수 성분을 유리수로 치환하고, 상기 버터플라이 구조의 4개의 곱셈 연산과 2개의 덧셈 연산 과정을 3개의 곱셈 연산과 3개의 덧셈 연산 과정으로 대체한 변경된 버터플라이 구조에 기초하여 복호화되는 NxN 크기(N은 정수)의 블록의 행 단위 및 열 단위 중 어느 하나에 대한 1차원 이산 코사인 역변환을 수행하는 역변환부를 포함하는 것을 특징으로 한다.
이하, 첨부된 도면을 참조하여 본 발명의 바람직한 실시예들에 대하여 구체적으로 설명한다.
도 1은 본 발명의 일 실시예에 따른 영상 부호화 장치를 도시한다.
도 1을 참조하면, 본 발명의 일 실시예에 따른 영상 부호화 장치(100)는 예측부(110), 감산부(115), 변환부(120), 양자화부(130) 및 엔트로피 부호화부(140)를 포함한다.
예측부(110)는 입력 영상을 소정 크기의 블록들로 분할하고, 분할된 각 블록에 대하여 인터 예측 또는 인트라 예측을 통해 예측 블록을 생성한다. 구체적으로, 예측부(110)는 이전에 부호화된 후 복원된 참조 픽처의 소정 탐색 범위 내에서 현재 블록과 유사한 영역을 가리키는 움직임 벡터를 생성하는 움직임 예측 및 보상 과정을 통해 예측 블록을 생성하는 인터 예측 및 현재 블록에 인접한 주변 블록의 데이터를 이용하여 예측 블록을 생성하는 인트라 예측을 수행한다.
감산부(115)는 현재 블록의 예측 블록과 원 영상 데이터를 감산한 레지듀얼을 생성한다.
변환부(120)는 레지듀얼을 주파수 영역으로 변환한다. 특히, 본 발명의 실시예들에서는 기존의 4x4, 8x8의 상대적으로 작은 크기에 대해서 정의되었던 이산 코사인 변환 행렬을 확장하여 16x16 이상의 큰 크기의 블록에도 적용될 수 있는 새로운 이산 코사인 변환 방식을 제공한다. 후술되는 바와 같이 본 발명의 일 실시예에 따른 변환부(120)는 기존의 이산 코사인 변환에 이용되는 변환 행렬의 원소들을 유리수 값으로 치환함으로써, 부동 소수점 연산이 아닌 정수 기반의 덧셈 및 뺄셈 연산과 시프트 연산에 의하여 이산 코사인 변환을 수행함으로써 연산의 복잡도를 감소시키는 한편 연산 속도를 증가시킨다. 또한, 본 발명의 다른 실시예에 따른 변환부(120)는 버터 플라이 구조의 1차원 이산 코사인 변환시에 버터플라이 구조의 곱셈 인수 중 삼각 함수 성분을 유리수로 치환하고, 버터플라이 구조의 4개의 곱셈 연산과 2개의 덧셈 연산 과정을 3개의 곱셈 연산과 3개의 덧셈 연산 과정으로 대체한 변경된 버터플라이 구조에 기초하여 변환을 수행함으로써 하드웨어적으로 복잡도가 큰 곱셈의 연산을 감소시키며 전체적인 연산 복잡도를 감소시킨다.
양자화부(130)는 변환된 레지듀얼을 양자화한다. 특히, 본 발명의 일 실시예에 따른 양자화부(130)는 변환부(120)에서 근사화된 변환 행렬을 이용하여 변환된 값과 실제 부동 소수점 연산에 기반한 이산 코사인 변환 사이의 오차값을 감소시키기 위하여 소정의 스케일링 팩터를 변환값에 적용한다. 이와 같이 본 발명의 일 실시예에 따른 양자화부(130)는 스케일링 팩터를 이용하여 부동 소수점 연산에 기반한 이산 코사인 변환에 의한 결과값과 유리수 기반의 근사화된 이산 코사인 변환에 의한 결과값 사이의 오차값을 감소시킨다. 구체적인 스케일링 및 양자화 과정에 대해서는 후술한다.
엔트로피 부호화부(140)는 양자화된 영상 데이터에 대하여 가변 길이 부호화를 수행하여 비트스트림을 생성한다.
이하, 본 발명의 일 실시예에 따른 영상 변환 방법에 대하여 구체적으로 설명한다.
DCT는 영상 압축을 위한 효과적인 코딩 기술인데, DCT를 이용하면 영상을 공간 영역에서 주파수 영역으로 변환할 수 있으며, 영상 데이터는 변화가 적으므로 낮은 주파수, 특히 0 주파수(DC) 성분이 큰 값을 가지게 되고, 높은 주파수 성분은 상대적으로 낮은 값을 갖게 되므로서, 대부분의 정보가 낮은 주파수 쪽으로 몰리게 되어 양자화 과정을 적절히 거치면 높은 압축율로 우수한 화질의 압축 이미지를 얻을 수 있다.
영상 부호화시에 다양한 DCT 방법이 있다. 그 종류로는 처리 속도면에서는 빠르지만 정확성이 조금 떨어지는 정수(integer)를 사용하는 방법, 그리고 처리 속도는 느리지만 정확성이 뛰어난 부동 소수점(floating-point) 연산을 사용하는 방법 등이 있다. 각각의 DCT 방법은 열 단위 및 행 단위로, 즉 1차원(1-D) DCT를 수행하는 것이 일반적이다.
도 2는 4 포인트, 8 포인트, 16 포인트, 32 포인트 이산 코사인 변환의 흐름도(flow graph)를 도시한다.
도 2를 참조하면, f0 내지 f31은 일차원 변환의 입력값들을 나타낸다. 동시에 f0 내지 f31은 일차원 역변환의 출력값이 될 수 있다. F0 내지 F31은 일차원 변환의 출력값들을 나타내는 동시에 일차원 역변환의 입력값이다. 변환시에 데이터 처리 방향은 좌측에서 우측이며, 역변환시에 데이터 처리 방향은 우측에서 좌측이다. 점에서 교차하는 2개의 라인은 2개의 수의 덧셈을 나타낸다. 각 라인 위의 값은 해당 계수에 의한 곱셈을 나타낸다. cθ는 cosθ, sθ는 sinθ를 나타내며, '-'는 부정(negation)을 나타낸다. 점선으로 표시된 도면 부호 210은 4 포인트 일차원 변환의 흐름도, 도면 부호 220은 8 포인트 일차원 변환의 흐름도, 도면 부호 230은 16 포인트 일차원 변환의 흐름도, 도면 부호 240은 32 포인트 일차원 변환의 흐름도를 나타낸다.
흐름도(200)에 도시된 바와 같이 이산 코사인 변환의 단점은 cθ 및 sθ가 θ의 값에 따라서 무리수(irrational number)가 될 수 있기 때문에 연산 복잡도가 증가할 수 있다는 것이다. 이로 인해서 입력값이 정수라고 하더라도 최종 변환 결과값은 무리수로 매핑될 수 있다. 이러한 이산 코사인 변환 과정은 하드웨어로 구현시에 복잡도를 증가시킨다. 따라서, 본 발명의 일 실시예에 따른 영상 변환 방법은 이산 코사인 변환에 이용되는 무리수 대신에 유리수 값으로 치환된 계수들에 의하여 원래의 이산 코사인 변환과 최대한 유사한 결과값을 갖도록 하는 정수 변환 방법을 제공한다.
도 3은 본 발명의 일 실시예에 따른 영상 변환 방법을 나타낸 플로우 차트이다.
도 3을 참조하면, 단계 310에서 NxN(N은 정수) 크기의 블록의 1차원 이산 코사인 변환에 이용되는 NxN 변환 행렬(Original_A)을 구성하는 원소들을 N개의 변수들(ai, i는 0부터 N-1까지의 정수)에 기초한 값들로 치환하여 치환된 NxN 변환 행렬(A)을 생성한다.
다시 도 2를 참조하면, N이 16인 경우, 즉 16x16 크기의 입력 블록에 대한 1차원 이산 코사인 변환 수행시에 도면 부호 230으로 도시된 흐름도를 따라서 입력 블록의 16개의 행 단위 및 16개의 열 단위 별로 1차원 이산 코사인 변환이 수행된다. 16개의 입력값을 f=[f0, f1, f2, ..., f14, f15]T, 변환 결과값을 F=[F0, F1, F2, ..., F14, F15]T, 도면 부호 230에 따른 입력값에 대한 변환 과정을 나타낸 변환 행렬을 Original_A라고 한다면 1차원 이산 코사인 변환은 F=Original_Axf 로 표현된다.
전술한 바와 같이, cosθ 및 sinθ는 θ의 값에 따라서 무리수가 될 수 있기 때문에, 본 발명의 일 실시예에 따르면 변환 행렬(Original_A)의 원소들에 포함된 cosθ 및 sinθ를 유리수 값으로 치환한다. 구체적으로, NxN 변환 행렬(Original_A)을 구성하는 원소들의 cos(πx(i/2)/N)(i는 0부터 N-1까지의 정수)인 성분을 유리수인 N개의 ai 변수들로 치환된다. 전술한 예에서, N=16인 경우라면, cos 0은 a0으로, cos(πx(1/2)/16)은 a1으로, cos(πx(2/2)/16)은 a2로, cos(πx(3/2)/16)은 a3로, cos(πx(4/2)/16)는 a4로, cos(πx(5/2)/16)는 a5로, cos(πx(6/2)/16)는 a6로, cos(πx(7/2)/16)는 a7, cos(πx(8/2)/16)는 a8, cos(πx(9/2)/16)는 a9, cos(πx(10/2)/16)는 a10, cos(πx(11/2)/16)는 a11, cos(πx(12/2)/16)는 a12, cos(πx(13/2)/16)는 a13, cos(πx(14/2)/16)는 a14, cos(πx(15/2)/16)는 a15로 치환된다. sinθ 성분은 sinθ=cos(90-θ)와 같은 관계를 이용하여 마찬가지로 ai 변수들로 치환될 수 있다.
도 4는 본 발명의 일 실시예에 따라서 16x16 변환 행렬의 원소에 구비된 삼각함수 성분을 변수들로 치환한 치환된 NxN 변환 행렬(A)의 원소들을 나타낸 참조도이다. 도 4를 참조하면, 원래의 16x16 변환 행렬을 구성하는 원소들은 16개의 변수들 ai에 기초한 값들로 표현될 수 있다.
다시 도 3을 참조하면, 단계 320에서 치환된 NxN 변환 행렬(A)과 치환된 NxN 변환 행렬의 전치 행렬(transpose)(AT)의 곱셈 행렬(AxAT)을 획득한다.
변환 행렬(A)이 갖추어야 할 조건 중 하나는 직교성(orthogonality)이다. 변환 행렬(A)이 직교성을 갖기 위해서는 변환 행렬(A)과 그 전치 행렬(AT)의 곱셈 결과에 따른 행렬의 원소들 중 대각 성분을 제외한 나머지 원소의 값이 0이어야 한다. 본 발명의 일 실시예에서는 원래 무리수였던 값을 유리수인 변수들 ai로 치환하였기 때문에 곱셈 행렬(AxAT)의 원소들 중 대각 성분을 제외한 나머지 원소의 값이 0이 아닐 수 있다. 그러나, 최대한 직교성을 갖도록 하기 위해서, 단계 330에서 곱셈 행렬(AxAT)의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 N개의 변수들(ai)을 획득한다. 전술한 도 4와 같은 16x16 크기의 블록에 대한 변환 행렬과 그 전치 행렬과의 곱셈 행렬(AxAT)을 계산한 다음, 곱셈 행렬(AxAT)의 대각 성분을 제외한 나머지 원소들의 제곱합은 다음의 수학식 f와 같다.
f = 128*a8^4*a15^2*a4^2*a11^2*a12^2+128*a8^4*a1^2*a4^2*a5^2*a12^2-64*a8^2*a13^2*a9^2-64*a5^2*a4^4*a7^2*a8^2+32*a11^2*a12^2*a9^2*a4^2+128*a8^4* a15^2*a12^2*a3^2*a4^2+64*a8^4*a5^2*a12^4*a7^2+64*a8^4*a5^2*a4^4*a7^2+128*a1^2*a4^2*a7^2*a8^2*a12^2+32*a15^2*a12^2*a9^2*a4^2-256*a8^2*a2^2*a6^2+256*a8^4 *a14^2*a10^2-256*a14^2*a10^2*a8^2+16*a15^2*a13^2+16*a7^2*a12^4*a11^2+ 16*a9^2*a4^4*a5^2+16*a11^2*a4^4*a7^2+16*a5^2*a12^4*a9^2-64*a8^2*a11^2*a9^2-64*a8^2*a5^2*a7^2+64*a8^4*a5^2*a7^2+64*a8^2*a13^2*a11^2+64*a8^4*a13^2*a11^2-32*a11^2*a12^2*a13^2+16*a11^2*a12^4*a13^2-32*a5^2*a4^2*a3^2+16 *a5^2*a4^4*a3^2-32*a3^2*a12^2*a5^2+16*a3^2*a12^4*a5^2-32*a13^2*a4^2 *a11^2+64*a8^2*a3^2*a5^2+64*a8^4*a3^2*a5^2+16*a15^2*a11^2+16*a1^2*a5^2+64*a2^2*a10^2-32*a7^2*a12^2*a1^2+16*a7^2*a12^4*a1^2-32*a9^2*a4^2*a15^2+16*a9^2*a4^4 *a15^2-32*a15^2*a12^2*a9^2+16*a15^2*a12^4*a9^2-32*a1^2*a4^2*a7^2+16*a1^2 *a4^4*a7^2+64*a8^2*a15^2*a9^2+64*a8^4*a15^2*a9^2+64*a8^2*a1^2*a7^2+64*a8^4*a1^2*a7^2+64*a8^4*a13^2*a9^2+16*a15^2*a12^4*a11^2+16*a1^2*a4^4*a5^2+16*a15^2*a4^4*a11^2+16*a1^2*a12^4*a5^2-64*a8^2*a15^2*a5^2-64*a8^2*a1^2*a11^2+64*a8^4 *a1^2*a11^2+64*a8^2*a13^2*a5^2+64*a8^4*a13^2*a5^2-32*a3^2*a12^2*a11^2+16 *a3^2*a12^4*a11^2-32*a3^2*a4^2*a11^2+16*a3^2*a4^4*a11^2-32*a13^2*a4^2*a5^2+16 *a13^2*a4^4*a5^2-32*a13^2*a12^2*a5^2+16*a13^2*a12^4*a5^2+16*a3^2* a12^4*a7^2+16*a13^2*a4^4*a9^2+16*a3^2*a4^4*a7^2+16*a13^2*a12^4*a9^2-64*a8^2*a3^2*a9^2+64*a8^4*a3^2*a9^2+64*a8^4*a13^2*a7^2+64*a8^4*a3^2*a11^2+16*a11^2*a9^2+16*a3^2*a7^2-64*a8^2*a15^2*a3^2+64*a8^4*a15^2*a3^2-64*a8^2* a1^2*a13^2+64*a8^4*a1^2*a13^2+16*a1^2*a4^4*a3^2+16*a15^2*a4^4*a13^2+16*a1^2*a12^4*a3^2+16*a15^2*a12^4*a13^2-256*a2^2*a10^2*a8^2+16*a15^2*a7^2+ 128*a8^4*a1^2*a4^2*a13^2*a12^2+16*a5^2*a9^2+16*a3^2*a5^2-64*a7^2*a12^4* a11^2*a8^2+64*a8^4*a7^2*a12^4*a11^2+64*a13^2*a4^4*a5^2*a8^2+32*a3^2*a4^2*a11^2*a12^2+64*a3^2*a4^4*a11^2*a8^2+64*a3^2*a12^4*a11^2*a8^2-128*a8^4*a13^2* a5^2*a4^2-128*a8^4*a13^2*a5^2*a12^2+32*a13^2*a12^2*a7^2*a4^2+ 64*a2^2*a6^2+64*a8^4*a11^2*a4^4*a7^2-128*a8^4*a15^2*a7^2*a12^2 +32*a1^2*a4^2*a9^2*a12^2+64*a1^2*a4^4*a9^2*a8^2+64*a1^2*a12^4*a9^2*a8^2+32*a15^2*a12^2*a7^2*a4^2+64*a15^2*a12^4*a7^2*a8^2+64*a8^4*a15^2*a4^4*a7^2+16*a1^2*a4^4*a9^2-128*a1^2*a12^2*a5^2*a8^2*a4^2-128*a15^2*a4^2*a11^2*a8^2*a12^2-64*a1^2*a4^4*a5^2*a8^2+16*a15^2*a5^2+16*a13^2*a11^2+64*a14^2*a10^2+128*a3^2*a4^2*a11^2*a8^2*a12^2+16*a1^2*a12^4*a13^2+128*a13^2*a4^2*a11^2*a8^2*a12^2+128*a3^2*a12^2*a5^2*a8^2*a4^2-128*a3^2*a4^2*a7^2*a8^2*a12^2 +16*a3^2*a9^2+32*a5^2*a4^2*a7^2*a12^2-128*a1^2*a12^2*a3^2*a8^2* a4^2+128*a1^2*a4^2*a9^2*a8^2*a12^2-128*a15^2*a12^2*a13^2*a8^2*a4^2+ 16*a15^2*a3^2+64*a5^2*a4^4*a3^2*a8^2-128*a11^2*a12^2*a13^2*a8^2+64*a11^2* a12^4*a13^2*a8^2-128*a8^4*a13^2*a11^2*a4^2-128*a8^4*a13^2*a11^2 *a12^2+64*a8^4*a3^2*a12^4*a5^2-128*a3^2*a4^2*a9^2*a8^2*a12^2-128*a8^2*a1^2*a9^2*a4^2+64*a8^4*a5^2*a9^2+64*a8^4*a11^2*a7^2-64*a8^2*a11^2*a7^2+16*a5^2*a4^4*a7^2+16*a5^2*a12^4*a7^2+16*a11^2*a12^4*a9^2+128*a8^4*a3^2*a12^2*a11^2*a4^2+64*a8^4*a3^2*a4^4*a11^2+64*a8^4*a3^2*a12^4*a11^2+16*a13^2*a5^2+64*a8^4*a5^2*a4^4*a3^2+128*a8^4*a3^2*a12^2*a5^2*a4^2+256*a8^4*a14^2*a6^2+64*a8^4*a3^2*a12^4*a7^2+64*a8^4*a3^2*a4^4*a7^2-256*a8^2*a14^2*a6^2+32*a5^2*a12^2*a9^2*a4^2+128*a15^2*a12^2*a7^2*a8^2*a4^2+16*a15^2*a4^4*a7^2-32*a15^2*a4^2*a7^2+64*a15^2*a4^4*a7^2*a8^2+ 256*a8^4*a2^2*a10^2+64*a8^4*a15^2*a12^4*a3^2+64*a8^4*a15^2*a4^4*a3^2+64*a8^4*a1^2*a4^4*a13^2+64*a8^4*a1^2*a12^4*a13^2+32*a1^2*a12^2*a5^2*a4^2-64*a1^2*a12^4*a5^2*a8^2+32*a15^2*a4^2*a11^2*a12^2-64*a15^2*a4^4*a11^2*a8^2-64*a15^2*a12^4*a11^2*a8^2+64*a8^4*a15^2*a4^4*a11^2+64*a8^4*a1^2*a4^4*a5^2+64*a8^4*a1^2*a12^4*a5^2-64*a8^2*a15^2*a13^2+64*a8^4*a15^2*a13^2-64*a8^2*a1^2*a3^2+64*a8^4*a1^2*a3^2+16*a15^2*a12^4*a3^2+16*a15^2*a4^4*a3^2+16*a1^2*a4^4*a13^2-128*a1^2*a12^2*a11^2*a8^2*a4^2-64*a1^2*a4^4*a11^2*a8^2-64*a13^2*a12^4*a7^2*a8^2-64*a13^2*a4^4*a7^2*a8^2+64*a8^4*a3^2*a7^2-64*a8^2*a3^2*a7^2+16*a13^2*a12^4*a7^2+16*a3^2*a4^4*a9^2+16*a3^2*a12^4*a9^2-64*a15^2*a4^4*a5^2*a8^2-64*a15^2*a12^4*a5^2*a8^2+64*a8^4*a15^2*a12^4*a5^2 +64*a8^4*a15^2*a4^4*a5^2-128*a1^2*a12^2*a13^2*a8^2*a4^2-64*a1^2*a12^4*a13^2*a8^2-64*a1^2*a4^4*a13^2*a8^2+16*a1^2*a3^2-64*a8^2*a5^2*a9^2+16*a13^2*a7^2-64*a1^2*a5^2*a8^2-64*a15^2*a11^2*a8^2 +64*a8^4*a1^2*a5^2+64*a8^4*a15^2*a11^2+16*a1^2*a12^4*a11^2+16*a1^2*a4^4*a11^2-128*a5^2*a12^2*a9^2*a8^2*a4^2-128*a11^2*a4^2*a7^2*a8^2*a12^2-64*a5^2*a12^4*a9^2*a8^2+32*a11^2*a4^2*a7^2*a12^2-64*a11^2*a4^4*a7^2*a8^2-64*a9^2*a4^4*a5^2*a8^2+64*a8^4*a15^2*a5^2-128*a8^2*a1^2*a7^2*a4^2-128*a8^2*a1^2*a7^2*a12^2-128*a8^4*a1^2*a7^2*a12^2-128*a8^4*a1^2*a7^2*a4^2-128*a8^2*a15^2*a9^2*a12^2-128*a8^2*a15^2*a9^2*a4^2-128*a8^4*a15^2*a9^2*a4^2-128*a8^4*a15^2*a9^2*a12^2+32*a1^2*a4^2*a7^2*a12^2+64*a1^2*a4^4*a7^2*a8^2+128*a8^4*a5^2*a12^2*a7^2*a4^2+128*a8^4*a15^2*a12^2*a13^2*a4^2+64*a8^4*a9^2*a4^4*a15^2+64*a8^4*a15^2*a12^4*a9^2+64*a8^4*a3^2*a12^4*a9^2+128*a8^4*a3^2*a4^2*a9^2*a12^2+128*a8^4*a13^2*a4^2*a7^2*a12^2+16*a13^2*a9^2+128*a8^4*a7^2*a12^2*a11^2*a4^2+64*a8^4*a5^2*a12^4*a9^2+64*a8^4*a9^2*a4^4*a5^2+16*a5^2*a7^2+64*a14^2*a6^2+32*a15^2*a4^2*a3^2*a12^2-64*a15^2*a4^4*a3^2*a8^2-64*a15^2*a12^4*a3^2*a8^2+ 16*a15^2*a4^4*a5^2+16*a15^2*a12^4*a5^2+32*a15^2*a4^2*a5^2*a12^2+64*a8^4*a1^2*a4^4*a3^2+64*a8^4*a1^2*a12^4*a3^2+64*a8^4*a7^2*a12^4*a1^2+128*a8^4*a7^2*a12^2*a1^2*a4^2+32*a1^2*a12^2*a13^2*a4^2-128*a8^2*a3^2*a11^2*a12^2-128*a8^4* a3^2*a11^2*a12^2-128*a8^4*a3^2*a11^2*a4^2+32*a13^2*a12^2*a5^2*a4^2-128*a13^2*a12^2*a5^2*a8^2+64*a13^2*a12^4*a5^2*a8^2+64*a8^2*a3^2*a11^2-128*a8^2*a3^2*a11^2*a4^2+128*a8^4*a9^2*a4^2*a15^2*a12^2+64*a8^4*a15^2*a12^4*a11^2-64*a1^2*a4^4*a3^2*a8^2+64*a8^4*a15^2*a12^4*a13^2+64*a8^4*a15^2 *a4^4*a13^2+16*a1^2*a13^2+64*a8^4*a11^2*a9^2+128*a8^4*a15^2*a4^2*a7^2*a12^2+64*a8^4*a15^2*a12^4*a7^2+64*a8^4*a1^2*a12^4*a9^2+64*a8^4*a1^2*a4^4*a9^2-128*a15^2*a4^2*a5^2*a8^2*a12^2+32*a15^2*a12^2*a13^2*a4^2-64*a15^2*a12^4*a13^2*a8^2+32*a1^2*a12^2*a3^2*a4^2-64*a1^2*a12^4*a3^2*a8^2-64*a15^2*a4^4*a13^2*a8^2+64*a8^4*a13^2*a4^4*a5^2+64*a8^4*a13^2*a12^4*a5^2+16*a3^2*a11^2-64*a13^2*a12^4*a9^2*a8^2+64*a8^4*a13^2*a4^4*a11^2+64*a8^4 *a11^2*a12^4*a13^2-128*a11^2*a12^2*a9^2*a8^2*a4^2-64*a11^2*a12^4*a9^2*a8^2-64*a11^2*a4^4*a9^2*a8^2+64*a8^4*a11^2*a4^4*a9^2+64*a8^4*a11^2*a12^4*a9^2+16*a11^2*a4^4*a9^2-128*a5^2*a4^2*a7^2*a8^2*a12^2-64*a5^2*a12^4*a7^2*a8^2 +128*a8^4*a15^2*a12^2*a5^2*a4^2+128*a8^4*a11^2*a4^2*a9^2*a12^2+16*a11^2*a7^2+128*a8^4*a13^2*a4^2*a5^2*a12^2+64*a8^4*a1^2*a4^4*a7^2-128*a15^2 *a4^2*a3^2*a8^2*a12^2+16*a15^2*a9^2-128*a8^2*a3^2*a5^2*a12^2-128*a8^2 *a3^2*a5^2*a4^2-128*a8^4*a3^2*a5^2*a12^2-128*a8^4*a3^2*a5^2*a4^2 +32*a13^2*a4^2*a11^2*a12^2-128*a13^2*a4^2*a11^2*a8^2+64*a13^2*a4^4*a11^2*a8^2 +32*a3^2*a12^2*a5^2*a4^2+64*a3^2*a12^4*a5^2*a8^2-128*a13^2*a12^2*a7^2*a8^2 *a4^2+16*a13^2*a4^4*a7^2+128*a8^4*a1^2*a4^2*a3^2*a12^2+256*a8^4*a2^2*a6^2+16*a1^2*a11^2-64*a3^2*a12^4*a7^2*a8^2+64*a8^4*a13^2*a4^4*a9^2 +64*a8^4*a13^2*a12^4*a9^2+128*a8^4*a1^2*a12^2*a9^2*a4^2+16*a1^2*a7^2+128*a15^2*a12^2*a9^2*a8^2*a4^2+64*a15^2*a12^4*a9^2*a8^2+64*a9^2*a4^4*a15^2*a8^2+64*a7^2*a12^4*a1^2*a8^2+128*a13^2*a12^2*a5^2*a8^2*a4^2-128*a13^2*a4^2*a5^2*a8^2 +128*a8^4*a1^2*a4^2*a11^2*a12^2+128*a8^4*a13^2*a4^2*a9^2*a12^2+64*a8^4*a1^2*a9^2+64*a8^2*a1^2*a9^2+64*a8^4*a15^2*a7^2+64*a8^2*a15^2*a7^2-32*a1^2*a4^2*a9^2+16*a1^2*a12^4*a9^2-32*a1^2*a12^2*a9^2+16*a15^2*a12^4*a7^2-32*a15^2*a12^2*a7^2-128*a13^2*a12^2*a9^2*a8^2*a4^2+64*a8^4*a1^2*a4^4*a11^2 +64*a8^4*a1^2*a12^4*a11^2-64*a8^2*a13^2*a7^2+32*a13^2*a12^2*a9^2 *a4^2+32*a3^2*a4^2*a9^2*a12^2-64*a3^2*a4^4*a9^2*a8^2-64*a3^2*a12^4*a9^2*a8^2+64*a8^4*a3^2*a4^4*a9^2+64*a8^4*a13^2*a4^4*a7^2+64*a8^4*a13^2*a12^4*a7^2+128*a8^4*a13^2*a4^2*a11^2*a12^2+128*a8^4*a5^2*a12^2*a9^2*a4^2+16*a13^2*a4^4*a11^2+32*a1^2*a12^2*a11^2*a4^2-64*a1^2*a12^4*a11^2*a8^2-128*a8^2*a1^2*a9^2*a12^2-128*a8^4*a1^2*a9^2*a12^2-128*a8^4*a1^2*a9^2*a4^2-128*a8^2*a15^2*a7^2*a12^2-128*a8^2*a15^2*a7^2*a4^2+16*a1^2*a9^2-128*a8^4*a15^2*a7^2*a4^2+32*a3^2*a4^2*a7^2*a12^2-64*a3^2*a4^4*a7^2*a8^2-64*a13^2*a4^4*a9^2*a8^2+128*a8^4*a3^2*a12^2*a7^2*a4^2
전술한 수학식의 f값이 최소가 되도록 하는 ai는 다양한 최적화 알고리즘을 적용하여 계산될 수 있다. 최적화 알고리즘 적용시에 ai 변수들은 유리수이면서, 분모는 쉬프트(shift) 연산이 가능한 2의 거듭제곱 형태의 값을 갖는 것이 바람직하다. 이와 같이 변수 ai가 2의 거듭제곱 형태인 유리수(dyadic rational)인 제한 조건을 설정하는 이유는, 분모가 2의 거듭제곱 형태인 경우 라이트 쉬프트 연산(>>)만을 이용하여 구현될 수 있기 때문이다.
일 예로, N은 16인 경우, 최적화 알고리즘을 적용하면 16개의 변수들 ai는 다음의 값들; a1=63/64, a2= 62/64, a3= 61/64, a4 = 59/64, a5 = 56/64, a6 = 53/64, a7 = 49/64, a8 = 45/64, a9 = 40/64, a10 = 35/64, a11 = 30/64, a12 = 24/64, a13 = 18/64, a14 = 12/64 및 a15 = 6/64을 갖을 수 있다.
단계 340에서 획득된 N개의 변수들(ai)에 기초한 값들로 치환된 NxN 변환 행렬(A)을 이용하여 NxN 크기의 블록을 변환한다. 즉, 입력값이 X라면 AX를 계산함으로써 N 포인트 1차원 이산 코사인 변환을 할 수 있다. 이와 같은 변환 행렬(A)는 전술한 과정을 통해 미리 획득된 다음 소정의 메모리에 저장된 후 소정 크기의 입력 블록에 적용되어 변환이 수행되도록 할 수 있다. 즉, 변환 과정을 위해서 매번 변환 행렬이 계산되는 것이 아니라, 다양한 크기의 입력 블록에 대하여 본 발명의 일 실시예에 따라서 미리 획득되어 저장된 변환 행렬이 이용되도록 할 수 있다.
전술한 예와 같이 N이 16인 경우, 즉 16x16 입력 블록에 대하여 치환된 16x16 변환 행렬(A)를 이용한 1차원 이산 코사인 변환을 수행하는 단계는, X0 내지 X15은 변환되어야 할 입력값, B0 내지 B15, C0 내지 C15, D0 내지 D15, E0 내지 E15, F0 내지 F15, G0 내지 G15은 중간값, Y0 내지 Y15은 변환된 값을 나타낸다고 할 때, 다음의 연산 과정과 같이 표현될 수 있다.
B0 = X0+X15; B15 = X0-X15; B1 = X1+X14; B14 = X1-X14; B2 = X2+X13;
B13 = X2-X13; B3 = X3+X12; B12 = X3-X12; B4 = X4+X11; B11 = X4-X11;
B5 = X5+X10; B10 = X5-X10; B6 = X6+X9; B9 = X6-X9; B7 = X7+X8;
B8 = X7-X8; C7 = B0-B7; C1 = B1+B6; C6 = B1-B6; C2 = B2+B5; C5 = B2-B5;
C3 = B3+B4; C4 = B3-B4; C8 = B8; C14 = B14; C10 = (45*(B13-B10)) >> 6;
C13 = (45*(B13+B10)) >> 6; C9 = B9;C15 = B15; C11 = (45*(B12-B11)) >> 6
C12 = (45*(B12+B11)) >> 6; D0 = C0+C3 ;D3 = C0-C3; D8 = C8+C11;
D11 = C8-C11; D12 = C15-C12; D15 = C15+C12; D1 = C1+C2; D2 = C1-C2;
D9 = C9+C10; D10 = C9-C10; D13 = C14-C13; D14 = C14+C13; D4 = C4;
D5 = (45*(C6-C5)) >> 6; D6 = (45*(C6+C5)) >> 6;
D7 = C7; E0 = (45*(D0+D1)) >> 6; E1 = (45*(D0-D1)) >> 6;
E2 = (59*D3+24*D2) >> 6; E3 = (24*D3-59*D2) >> 6; E4 = D4+D5;
E5 = D4-D5; E6 = D7-D6; E7 = D7+D6; E8 = D8; E9 = (24*D14-59*D9) >> 6;
E10 = (-59*D13-24*D10) >> 6; E11 = D11; E12 = D12;
E13 = (24*D13-59*D10) >> 6; E14 = (59*D14+24*D9) >> 6; E15 = D15
F0 = E0; F1 = E1; F2 = E2; F3 = E3; F4 = (12*E4+62*E7) >> 6
F5 = (53*E5+35*E6) >> 6; F6 = (53*E6-35*E5) >> 6
F7 = (12*E7-62*E4) >> 6; F8 = E8+E9; F9 = E8-E9; F10 = E11-E10
F11 = E11+E10; F12 = E12+E13; F13 = E12-E13; F14 = E15-E14;
F15 = E15+E14; G0 = F0; G1 = F1; G2 = F2; G3 = F3; G4 = F4
G5 = F5; G6 = F6; G7 = F7; G8 = (6*F8+63*F15) >> 6
G9 = (49*F9+40*F14) >> 6; G10 = (30*F10+56*F13) >> 6
G11 = (61*F11+18*F12) >> 6; G12 = (61*F12-18*F11) >> 6
G13 = (30*F13-56*F10) >> 6; G14 = (49*F14-40*F9) >> 6
G15 = (6*F15-63*F8) >> 6
Y0 = G0; Y1 = G8; Y2 = G4; Y3 = G12; Y4 = G2; Y5 = G10; Y6 = G6
Y7 = G14; Y8 = G1; Y9 = G9; Y10 = G5; Y11 = G13; Y12 = G3
Y13 = G11; Y14 = G7; Y15 = G15;
상기 연산 과정에서 결과값이 변함없는 연산 과정, 예를 들어 F0=E0=GO=Y0와 같이 동일한 값이 계속 매핑되는 것에 불과한 연산 과정의 경우 중간 과정을 생략하고 바로 F0가 결과값 Y0로 매핑되도록 할 수 있다.
또한, 전술한 연산 과정에서 나눗셈에 대응되는 라이트 쉬프트 연산(>>)과 관련하여, 반올림 오차(rounding error)를 감소시키기 위하여 x>>y 연산은 (x+(1<<(y-1)))>>y 또는 (abs(x)+(1<<(y-1)))>>y 연산 형태로 대체될 수 있다.
다른 예로서 N이 32인 경우도 전술한 N이 16인 경우와 유사하게, 32x32 크기의 블록의 1차원 이산 코사인 변환에 이용되는 32x32 변환 행렬(Original_A)을 구성하는 원소들을 32개의 변수들(ai, i는 0부터 31까지의 정수)에 기초한 값들로 치환하여 치환된 NxN 변환 행렬(A)을 생성한다. 도 2를 다시 참조하면, N이 32인 경우, 즉 32x32 크기의 입력 블록에 대한 1차원 이산 코사인 변환 수행시에 도면 부호 240으로 도시된 흐름도를 따라서 입력 블록의 32개의 행 단위 및 32개의 열 단위 별로 1차원 이산 코사인 변환이 수행된다. 32개의 입력값을 f=[f0, f1, f2, ..., f30, f31]T, 변환 결과값을 F=[F0, F1, F2, ..., F30, F31]T, 도면 부호 240에 따른 입력값에 대한 변환 과정을 나타낸 변환 행렬을 Original_A라고 한다면 1차원 이산 코사인 변환은 F=Original_Axf 로 표현된다. 32x32 변환 행렬(Original_A)을 구성하는 원소들의 cos(πx(i/2)/32)(i는 0부터 31까지의 정수)인 성분을 유리수인 32개의 ai 변수들로 치환된다. 치환된 32x32 변환 행렬(A)과 치환된 32x32 변환 행렬의 전치 행렬(transpose)(AT)의 곱셈 행렬(AxAT)을 획득하고, 곱셈 행렬(AxAT)의 원소들 중 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 32개의 변수들(ai)을 최적화 알고리즘을 적용하여 획득한다.
N이 32인 경우, 최적화 알고리즘을 적용하면 32개의 변수들 ai는 다음의 값들; a1 = 255/256, a2 = 254/256, a3 = 253/256, a4 = 251/256, a5 = 248/256, a6 = 244/256, a7 = 241/256, a8 = 236/256, a9 = 231/256, a10 = 225/256, a11 = 219/256, a12 = 212/256, a13 = 205/256, a14 = 197/256, a15 = 189/256, a16 = 181/256, a17 = 171/256, a18 = 162/256, a19 = 152/256, a20 = 142/256, a21 = 131/256, a22 = 120/256, a23 = 109/256, a24 = 97/256, a25 = 86/256, a26 = 74/256, a27 = 62/256, a28 = 49/256, a29 = 37/256, a30 = 25/256 및 a31 = 12/256 을 갖을 수 있다.
다음 획득된 32개의 변수들(ai)에 기초한 값들로 치환된 32x32 변환 행렬(A)을 이용하여 32x32 크기의 블록을 변환한다.
전술한 N이 32인 경우, 즉 32x32 입력 블록에 대하여 치환된 32x32 변환 행렬(A)를 이용한 1차원 이산 코사인 변환을 수행하는 단계는 X0 내지 X31은 변환되어야 할 입력값, A0내지 B31, B0 내지 B31, C0 내지 C31, D0 내지 D31, E0 내지 E31, F0 내지 F31, G0 내지 G31, H0 내지 H31은 중간값, Y0 내지 Y31은 변환된 값을 나타낸다고 할 때, 다음의 연산 과정과 같이 표현될 수 있다.
A0 = X0+X31; A31 = X0-X31; A1 = X1+X30; A30 = X1-X30; A2 = X2+X29;
A29 = X2-X29; A3 = X3+X28; A28 = X3-X28; A4 = X4+X27; A27 = X4-X27
A5 = X5+X26; A26 = X5-X26; A6 = X6+X25; A25 = X6-X25; A7 = X7+X24;
A24 = X7-X24; A8 = X8+X23; A23 = X8-X23; A9 = X9+X22; A22 = X9-X22;
A10 = X10+X21; A21 = X10-X21; A11 = X11+X20; A20 = X11-X20;
A12 = X12+X19; A19 = X12-X19; A13 = X13+X18; A18 = X13-X18;
A14 = X14+X17; A17 = X14-X17; A15 = X15+X16; A16 = X15-X16;
B0 = A0+A15; B15 = A0-A15; B1 = A1+A14; B14 = A1-A14; B2 = A2+A13;
B13 = A2-A13; B3 = A3+A12; B12 = A3-A12; B4 = A4+A11; B11 = A4-A11;
B5 = A5+A10; B10 = A5-A10; B6 = A6+A9; B9 = A6-A9; B7 = A7+A8;
B8 = A7-A8; B16 = A16; B28 = A28; B20 = (181*(A27-A20)) >> 8;
B27 = (181*(A27+A20)) >> 8; B17 = A17; B29 = A29;
B21 = (181*(A26-A21)) >> 8; B26 = (181*(A26+A21)) >> 8;
B18 = A18; B30 = A30; B22 = (181*(A25-A22)) >> 8;
B25 = (181*(A25+A22)) >> 8; B19 = A19; B31 = A31;
B23 = (181*(A24-A23)) >> 8; B24 = (181*(A24+A23)) >> 8;
C0 = B0+B7; C7 = B0-B7; C1 = B1+B6; C6 = B1-B6; C2 = B2+B5;
C5 = B2-B5; C3 = B3+B4; C4 = B3-B4; C8 = B8; C14 = B14;
C10 = (181*(B13-B10)) >> 8; C13 = (181*(B13+B10)) >> 8;
C9 = B9; C15 = B15; C11 = (181*(B12-B11)) >> 8;
C12 = (181*(B12+B11)) >> 8; C16 = B16+B23; C23 = B16-B23;
C24 = B31-B24; C31 = B31+B24; C17 = B17+B22; C22 = B17-B22;
C25 = B30-B25; C30 = B30+B25; C18 = B18+B21; C21 = B18-B21;
C26 = B29-B26; C29 = B29+B26; C19 = B19+B20; C20 = B19-B20;
C27 = B28-B27; C28 = B28+B27; D0 = C0+C3; D3 = C0-C3; D8 = C8+C11;
D11 = C8-C11; D12 = C15-C12; D15 = C15+C12; D1 = C1+C2; 2 = C1-C2;
D9 = C9+C10; D10 = C9-C10; D13 = C14-C13; D14 = C14+C13; D4 = C4;
D5 = (181*(C6-C5)) >> 8; D6 = (181*(C6+C5)) >> 8; D7 = C7;
D16 = C16; D18 = (97*C29-236*C18) >> 8; D20 = (-236*C27-97*C20) >> 8;
D22 = C22; D24 = C24; D26 = (-236*C21+97*C26) >> 8;
D28 = (97*C19+236*C28) >> 8; D30 = C30; D17 = C17;
D19 = (97*C28-236*C19) >> 8; D21 = (-236*C26-97*C21) >> 8;
D23 = C23; D25 = C25; D27 = (-236*C20+97*C27) >> 8;
D29 = (97*C18+236*C29) >> 8; D31 = C31; E0 = (181*(D0+D1)) >> 8;
E1 = (181*(D0-D1)) >> 8; E2 = (236*D3+97*D2) >> 8;
E3 = (97*D3-236*D2) >> 8; E4 = D4+D5; E5 = D4-D5; E6 = D7-D6;
E7 = D7+D6; E8 = D8; E9 = (97*D14-236*D9) >> 8;
E10 = (-236*D13-97*D10) >> 8; E11 = D11; E12 = D12;
E13 = (97*D13-236*D10) >> 8; E14 = (236*D14+97*D9) >> 8;
E15 = D15; E16 = D16+D19; E19 = D16-D19; E20 = D23-D20;E23 = D23+D20;
E24 = D24+D27; E27 = D24-D27; E28 = D31-D28; E31 = D31+D28;
E17 = D17+D18; E18 = D17-D18; E21 = D22-D21; E22 = D22+D21;
E25 = D25+D26; E26 = D25-D26; E29 = D30-D29; E30 = D30+D29;
F0 = E0; F1 = E1; F2 = E2; F3 = E3; F4 = (49*E4+251*E7) >> 8;
F5 = (212*E5+142*E6) >> 8; F6 = (212*E6-142*E5) >> 8
F7 = (49*E7-251*E4) >> 8; F8 = E8+E9; F9 = E8-E9; F10 = E11-E10;
F11 = E11+E10; F12 = E12+E13; F13 = E12-E13; F14 = E15-E14;
F15 = E15+E14; F16 = E16; F17 = (49*E30-251*E17) >> 8;
F18 = (-251*E29-49*E18) >> 8; F19 = E19; F20 = E20;
F21 = (212*E26-142*E21) >> 8; F22 = (-142*E25-212*E22) >> 8;
F23 = E23; F24 = E24; F25 = (212*E25-142*E22) >> 8;
F26 = (142*E26+212*E21) >> 8;
F27 = E27; F28 = E28; F29 = (49*E29-251*E18) >> 8;
F30 = (251*E30+49*E17) >> 8; F31 = E31; G0 = F0; G1 = F1;
G2 = F2; G3 = F3; G4 = F4; G5 = F5; G6 = F6; G7 = F7;
G8 = (25*F8+254*F15) >> 8; G9 = (197*F9+162*F14) >> 8;
G10 = (120*F10+225*F13) >> 8; G11 = (244*F11+74*F12) >> 8;
G12 = (244*F12-74*F11) >> 8; G13 = (120*F13-225*F10) >> 8;
G14 = (197*F14-162*F9) >> 8; G15 = (25*F15-254*F8) >> 8;
G16 = F16+F17; G17 = F16-F17; G18 = F19-F18; G19 = F19+F18;
G20 = F20+F21; G21 = F20-F21; G22 = F23-F22; G23 = F23+F22;
G24 = F24+F25; G25 = F24-F25; G26 = F27-F26; G27 = F27+F26;
G28 = F28+F29; G29 = F28-F29; G30 = F31-F30; G31 = F31+F30;
H0 = G0; H1 = G1; H2 = G2; H3 = G3; H4 = G4; H5 = G5; H6 = G6;
H7 = G7; H8 = G8; H9 = G9; H10 = G10; H11 = G11; H12 = G12;
H13 = G13; H14 = G14; H15 = G15; H16 = (12*G16+255*G31) >> 8;
H17 = (189*G17+171*G30) >> 8; H18 = (109*G18+231*G29) >> 8;
H19 = (241*G19+86*G28) >> 8; H20 = (62*G20+248*G27) >> 8;
H21 = (219*G21+131*G26) >> 8; H22 = (152*G22+205*G25) >> 8;
H23 = (253*G23+37*G24) >> 8; H24 = (253*G24-37*G23) >> 8;
H25 = (152*G25-205*G22) >> 8; H26 = (219*G26-131*G21) >> 8;
H27 = (62*G27-248*G20) >> 8; H28 = (241*G28-86*G19) >> 8;
H29 = (109*G29-231*G18) >> 8; H30 = (189*G30-171*G17) >> 8;
H31 = (12*G31-255*G16) >> 8;
Y0 = H0; Y1 = H16; Y2 = H8; Y3 = H24; Y4 = H4; Y5 = H20;
Y6 = H12; Y7 = H28; Y8 = H2; Y9 = H18; Y10 = H10; Y11 = H26
Y12 = H6; Y13 = H22; Y14 = H14; Y15 = H30; Y16 = H1;
Y17 = H17; Y18 = H9; Y19 = H25; Y20 = H5; Y21 = H21;
Y22 = H13; Y23 = H29; Y24 = H3; Y25 = H19; Y26 = H11;
Y27 = H27; Y28 = H7; Y29 = H23; Y30 = H15; Y31 = H31
또 다른 예로서 N이 64인 경우, 64x64 크기의 블록의 1차원 이산 코사인 변환에 이용되는 64x64 변환 행렬(Original_A)을 구성하는 원소들의 cos(πx(i/2)/64)(i는 0부터 63까지의 정수)인 성분을 유리수인 64개의 ai 변수들로 치환하여 치환된 64x64 변환 행렬(A)을 생성하고, 치환된 64x64 변환 행렬(A)과 치환된 64x64 변환 행렬의 전치 행렬(transpose)(AT)의 곱셈 행렬(AxAT)을 획득하고, 곱셈 행렬(AxAT)의 원소들 중 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 64개의 변수들(ai)을 최적화 알고리즘을 적용하여 획득한다.
N이 64인 경우, 최적화 알고리즘을 적용하면 64개의 변수들 ai는 다음의 값들; a1 =1024/1024, a2 = 1023/1024, a3 = 1021/1024, a4 = 1019/1024, a5 = 1016/1024, a6 = 1013/1024, a7 = 1009/1024, a8 = 1004/1024, a9 = 999 /1024, a10 =993 /1024, a11 =987 /1024, a12 =980 /1024, a13 =972 /1024, a14 =964 /1024, a15 =955 /1024, a16 =946 /1024, a17 =936 /1024, a18 =926 /1024, a19 =915 /1024, a20 =903 /1024, a21 =891 /1024, a22 =878 /1024, a23 =865 /1024, a24 =851 /1024, a25 =837 /1024, a26 =822 /1024, a27 =807 /1024, a28 =792 /1024, a29 =775 /1024, a30 =759 /1024, a31 =742 /1024, a32 =724 /1024, a33 =706 /1024, a34 =688 /1024, a35 =669 /1024, a36 =650 /1024, a37 =630 /1024, a38 =610 /1024, a39 =590 /1024, a40 =569 /1024, a41 =548 /1024, a42 =526 /1024, a43 =505 /1024, a44 =483 /1024, a45 =460 /1024, a46 =438 /1024, a47 =415 /1024, a48 =392 /1024, a49 =369 /1024, a50 =345 /1024, a51 =321 /1024, a52 =297 /1024, a53 =273 /1024, a54 =249 /1024, a55 =224 /1024, a56 =200 /1024, a57 =175 /1024, a58 =150/1024, a59 =125 /1024, a60 =100 /1024, a61 =75 /1024, a62 =50/1024 및 a63 =25/1024 을 갖을 수 있다.
다음 획득된 64개의 변수들(ai)에 기초한 값들로 치환된 64x64 변환 행렬(A)을 이용하여 64x64 크기의 블록을 변환한다.
전술한 N이 64인 경우, 즉 64x64 입력 블록에 대하여 치환된 64x64 변환 행렬(A)를 이용한 1차원 이산 코사인 변환을 수행하는 단계는 X0 내지 X63은 변환되어야 할 입력값, A0내지 B63, B0 내지 B63, C0 내지 C63, D0 내지 D63, E0 내지 E63, F0 내지 F63, G0 내지 G63, H0 내지 H63, I0내지 I63, O0내지 O63은 중간값, Y0 내지 Y63은 변환된 값을 나타낸다고 할 때, 다음의 연산 과정과 같이 표현될 수 있다.
O0 = X0+X63; O63 = X0-X63; O1 = X1+X62; O62 = X1-X62; O2 = X2+X61; O61 = X2-X61; O3 = X3+X60; O60 = X3-X60; O4 = X4+X59; O59 = X4-X59; O5 = X5+X58; O58 = X5-X58; O6 = X6+X57; O57 = X6-X57; O7 = X7+X56; O56 = X7-X56; O8 = X8+X55; O55 = X8-X55; O9 = X9+X54; O54 = X9-X54; O10 = X10+X53; O53 = X10-X53; O11 = X11+X52; O52 = X11-X52; O12 = X12+X51; O51 = X12-X51; O13 = X13+X50; O50 = X13-X50; O14 = X14+X49; O49 = X14-X49; O15 = X15+X48; O48 = X15-X48; O16 = X16+X47; O47 = X16-X47; O17 = X17+X46; O46 = X17-X46; O18 = X18+X45; O45 = X18-X45; O19 = X19+X44; O44 = X19-X44; O20 = X20+X43; O43 = X20-X43; O21 = X21+X42; O42 = X21-X42; O22 = X22+X41; O41 = X22-X41; O23 = X23+X40; O40 = X23-X40; O24 = X24+X39; O39 = X24-X39; O25 = X25+X38; O38 = X25-X38; O26 = X26+X37; O37 = X26-X37; O27 = X27+X36; O36 = X27-X36; O28 = X28+X35; O35 = X28-X35; O29 = X29+X34; O34 = X29-X34; O30 = X30+X33; O33 = X30-X33; O31 = X31+X32; O32 = X31-X32; ; A0 = O0+O31; A31 = O0-O31; A1 = O1+O30; A30 = O1-O30; A2 = O2+O29; A29 = O2-O29; A3 = O3+O28; A28 = O3-O28; A4 = O4+O27; A27 = O4-O27; A5 = O5+O26; A26 = O5-O26; A6 = O6+O25; A25 = O6-O25; A7 = O7+O24; A24 = O7-O24; A8 = O8+O23; A23 = O8-O23; A9 = O9+O22; A22 = O9-O22; A10 = O10+O21; A21 = O10-O21; A11 = O11+O20; A20 = O11-O20; A12 = O12+O19; A19 = O12-O19; A13 = O13+O18; A18 = O13-O18; A14 = O14+O17; A17 = O14-O17; A15 = O15+O16; A16 = O15-O16; A32 = O32; A56 = O56; A40 = (724*(O55-O40))>>10; A55 = (724*(O55+O40))>>10; A33 = O33; A57 = O57; A41 = (724*(O54-O41))>>10; A54 = (724*(O54+O41))>>10; A34 = O34; A58 = O58; A42 = (724*(O53-O42))>>10; A53 = (724*(O53+O42))>>10; A35 = O35; A59 = O59; A43 = (724*(O52-O43))>>10; A52 = (724*(O52+O43))>>10; A36 = O36; A60 = O60; A44 = (724*(O51-O44))>>10; A51 = (724*(O51+O44))>>10; A37 = O37; A61 = O61; A45 = (724*(O50-O45))>>10; A50 = (724*(O50+O45))>>10; A38 = O38; A62 = O62; A46 = (724*(O49-O46))>>10; A49 = (724*(O49+O46))>>10; A39 = O39; A63 = O63; A47 = (724*(O48-O47))>>10; A48 = (724*(O48+O47))>>10; B0 = A0+A15; B15 = A0-A15; B1 = A1+A14; B14 = A1-A14; B2 = A2+A13; B13 = A2-A13; B3 = A3+A12; B12 = A3-A12; B4 = A4+A11; B11 = A4-A11; B5 = A5+A10; B10 = A5-A10; B6 = A6+A9; B9 = A6-A9; B7 = A7+A8; B8 = A7-A8; B16 = A16; B28 = A28; B20 = (724*(A27-A20))>>10; B27 = (724*(A27+A20))>>10; B17 = A17; B29 = A29; B21 = (724*(A26-A21))>>10; B26 = (724*(A26+A21))>>10; B18 = A18; B30 = A30; B22 = (724*(A25-A22))>>10; B25 = (724*(A25+A22))>>10; B19 = A19; B31 = A31; B23 = (724*(A24-A23))>>10; B24 = (724*(A24+A23))>>10; B32 = A32+A47; B47 = A32-A47; B48 = A63-A48; B63 = A63+A48; B33 = A33+A46; B46 = A33-A46; B49 = A62-A49; B62 = A62+A49; B34 = A34+A45; B45 = A34-A45; B50 = A61-A50; B61 = A61+A50; B35 = A35+A44; B44 = A35-A44; B51 = A60-A51; B60 = A60+A51; B36 = A36+A43; B43 = A36-A43; B52 = A59-A52; B59 = A59+A52; B37 = A37+A42; B42 = A37-A42; B53 = A58-A53; B58 = A58+A53; B38 = A38+A41; B41 = A38-A41; B54 = A57-A54; B57 = A57+A54; B39 = A39+A40; B40 = A39-A40; B55 = A56-A55; B56 = A56+A55; C0 = B0+B7; C7 = B0-B7; C1 = B1+B6; C6 = B1-B6; C2 = B2+B5; C5 = B2-B5; C3 = B3+B4; C4 = B3-B4; C8 = B8; C14 = B14; C10 = (724*(B13-B10))>>10 ; C13 = (724*(B13+B10))>>10; C9 = B9; C15 = B15; C11 = (724*(B12-B11))>>10; C12 = (724*(B12+B11))>>10; C16 = B16+B23; C23 = B16-B23; C24 = B31-B24; C31 = B31+B24; C17 = B17+B22; C22 = B17-B22; C25 = B30-B25; C30 = B30+B25; C18 = B18+B21; C21 = B18-B21; C26 = B29-B26; C29 = B29+B26; C19 = B19+B20; C20 = B19-B20; C27 = B28-B27; C28 = B28+B27; C32 = B32; C36 = (392*B59-946*B36)>>10; C40 = (-946*B55-392*B40)>>10; C44 = B44; C48 = B48; ;C52 = (-946*B43+392*B52)>>10; C56 = (392*B39+946*B56)>>10; C60 = B60; C33 = B33; C37 = (392*B58-946*B37)>>10; C41 = (-946*B54-392*B41)>>10; C45 = B45; C49 = B49; C53 = (-946*B42+392*B53)>>10; C57 = (392*B38+946*B57)>>10; C61 = B61; C34 = B34; C38 = (392*B57-946*B38)>>10; C42 = (-946*B53-392*B42)>>10; C46 = B46; C50 = B50; C54 = (-946*B41+392*B54)>>10; C58 = (392*B37+946*B58)>>10; C62 = B62; C35 = B35; C39 = (392*B56-946*B39)>>10; C43 = (-946*B52-392*B43)>>10; C47 = B47; C51 = B51; C55 = (-946*B40+392*B55)>>10; C59 = (392*B36+946*B59)>>10; C63 = B63; D0 = C0+C3; D3 = C0-C3; D8 = C8+C11; D11 = C8-C11; D12 = C15-C12; D15 = C15+C12; D1 = C1+C2; D2 = C1-C2; D9 = C9+C10; D10 = C9-C10; D13 = C14-C13; D14 = C14+C13; D4 = C4; D5 = (724*(C6-C5))>>10; D6 = (724*(C6+C5))>>10; D7 = C7; D16 = C16; D18 = (392*C29-946*C18)>>10; D20 = (-946*C27-392*C20)>>10; D22 = C22; D24 = C24; D26 = (-946*C21+392*C26)>>10; D28 = (392*C19+946*C28)>>10; D30 = C30; D17 = C17; D19 = (392*C28-946*C19)>>10; D21 = (-946*C26-392*C21)>>10; D23 = C23; D25 = C25; D27 = (-946*C20+392*C27)>>10; D29 = (392*C18+946*C29)>>10; D31 = C31; D32 = C32+C39; D39 = C32-C39; D40 = C47-C40; D47 = C47+C40; D48 = C48+C55; D55 = C48-C55; D56 = C63-C56; D63 = C63+C56; D33 = C33+C38; D38 = C33-C38; D41 = C46-C41; D46 = C46+C41; D49 = C49+C54; D54 = C49-C54; D57 = C62-C57; D62 = C62+C57; D34 = C34+C37; D37 = C34-C37; D42 = C45-C42; D45 = C45+C42; D50 = C50+C53; D53 = C50-C53; D58 = C61-C58; D61 = C61+C58; D35 = C35+C36; D36 = C35-C36; D43 = C44-C43; D44 = C44+C43; D51 = C51+C52; D52 = C51-C52; D59 = C60-C59; D60 = C60+C59; E0 = (724*(D0+D1))>>10; E1 = (724*(D0-D1))>>10; E2 = (946*D3+392*D2)>>10; E3 = (392*D3-946*D2)>>10; E4 = D4+D5; E5 = D4-D5; E6 = D7-D6; E7 = D7+D6; E8 = D8; E9 = (392*D14-946*D9)>>10; E10 = (-946*D13-392*D10)>>10; E11 = D11; E12 = D12; E13 = (392*D13-946*D10)>>10; E14 = (946*D14+392*D9)>>10; E15 = D15; E16 = D16+D19; E19 = D16-D19; E20 = D23-D20; E23 = D23+D20; E24 = D24+D27; E27 = D24-D2; E28 = D31-D28; E31 = D31+D28; E17 = D17+D18; E18 = D17-D18; E21 = D22-D21; E22 = D22+D21; E25 = D25+D26; E26 = D25-D26; E29 = D30-D29; E30 = D30+D29; E32 = D32; E33 = D33; E34 = (200*D61-1004*D34)>>10; E35 = (200*D60-1004*D35)>>10; E36 = (-1004*D59-200*D36)>>10; E37 = (-1004*D58-200*D37)>>10; E38 = D38; E39 = D39; E40 = D40; E41 = D41; E42 = (851*D53-569*D42)>>10; E43 = (851*D52-569*D43)>>10; E44 = (-569*D51-851*D44)>>10; E45 = (-569*D50-851*D45)>>10; E46 = D46; E47 = D47; E48 = D48; E49 = D49; E50 = (851*D50-569*D45)>>10; E51 = (851*D51-569*D44)>>10; E52 = (569*D52+851*D43)>>10; E53 = (569*D53+851*D42)>>10; E54 = D54; E55 = D55; E56 = D56; E57 = D57; E58 = (200*D58-1004*D37)>>10; E59 = (200*D59-1004*D36)>>10; E60 = (1004*D60+200*D35)>>10; E61 = (1004*D61+200*D34)>>10; E62 = D62; E63 = D63; F0 = E0; F1 = E1; F2 = E2; F3 = E3; F4 = (200*E4+1004*E7)>>10; F5 = (851*E5+569*E6)>>10; F6 = (851*E6-569*E5)>>10; F7 = (200*E7-1004*E4)>>10; F8 = E8+E9; F9 = E8-E9; F10 = E11-E10; F11 = E11+E10; F12 = E12+E13; F13 = E12-E13; F14 = E15-E14; F15 = E15+E14; F16 = E16; F17 = (200*E30-1004*E17)>>10; F18 = (-1004*E29-200*E18)>>10; F19 = E19; F20 = E20; F21 = (851*E26-569*E21)>>10; F22 = (-569*E25-851*E22)>>10; F23 = E23; F24 = E24; F25 = (851*E25-569*E22)>>10; F26 = (569*E26+851*E21)>>10; F27 = E27; F28 = E28; F29 = (200*E29-1004*E18)>>10; F30 = (1004*E30+200*E17)>>10; F31 = E31; F32 = E32+E35; F33 = E33+E34; F34 = E33-E34; F35 = E32-E35; F36 = E39-E36; F37 = E38-E37; F38 = E38+E37; F39 = E39+E36; F40 = E40+E43; F41 = E41+E42; F42 = E41-E42; F43 = E40-E43; F44 = E47-E44; F45 = E46-E45; F46 = E46+E45; F47 = E47+E44; F48 = E48+E51; F49 = E49+E50; F50 = E49-E50; F51 = E48-E51; F52 = E55-E52; F53 = E54-E53; F54 = E54+E53; F55 = E55+E52; F56 = E56+E59; F57 =; E57+E58; F58 = E57-E58; F59 = E56-E59; F60 = E63-E60; F61 = E62-E61; F62 = E62+E61; F63 = E63+E60; G0 = F0; G1 = F1; G2 = F2; G3 = F3; G4 = F4; G5 = F5; G6 = F6; G7 = F7; G8 = (100*F8+1019*F15)>>10; G9 = (792*F9+650*F14)>>10; G10 = (483*F10+903*F13)>>10; G11 = (980*F11+297*F12)>>10; G12 = (980*F12-297*F11)>>10; G13 = (483*F13-903*F10)>>10; G14 = (792*F14-650*F9)>>10; G15 = (100*F15-1019*F8)>>10; G16 = F16+F17; G17 = F16-F17; G18 = F19-F18; G19 = F19+F18; G20 = F20+F21; G21 = F20-F21 ; G22 = F23-F22; G23 = F23+F22; G24 = F24+F25; G25 = F24-F25; G26 = F27-F26; G27 = F27+F26; G28 = F28+F29; G29 = F28-F29; G30 = F31-F30; G31 = F31+F30; G32 = F32; G33 = (100*F62-1019*F33)>>10; G34 = (-1019*F61-100*F34)>>10; G35 = F35; G36 = F36; G37 = (792*F58-650*F37)>>10; G38 = (-650*F57-792*F38)>>10; G39 = F39; G40 = F40; G41 = (483*F54-903*F41)>>10; G42 = (-903*F53-483*F42)>>10; G43 = F43; G44 = F44; G45 = (980*F50-297*F45)>>10; G46 = (-297*F49-980*F46)>>10; G47 = F47; G48 = F48; G49 = (980*F49-297*F46)>>10; G50 = (297*F50+980*F45)>>10; G51 = F51; G52 = F52; G53 = (483*F53-903*F42)>>10; G54 = (903*F54+483*F41)>>10; G55 = F55; G56 = F56; G57 = (792*F57-650*F38)>>10; G58 = (650*F58+792*F37)>>10; G59 = F59; G60 = F60; G61 = (100*F61-1019*F34)>>10; G62 = (1019*F62+100*F33)>>10; G63 = F63; H0 = G0;H1 = G1;H2 = G2;H3 = G3;H4 = G4;H5 = G5;H6 = G6;H7 = G7;H8 = G8;H9 = G9;H10 = G10;H11 = G11;H12 = G12;H13 = G13;H14 = G14;H15 = G15;H16 = (50*G16+1023*G31)>>10;H17 = (759*G17+688*G30)>>10;H18 = (438*G18+926*G29)>>10;H19 = (964*G19+345*G28)>>10;H20 = (249*G20+993*G27)>>10;H21 = (878*G21+526*G26)>>10;H22 = (610*G22+822*G25)>>10;H23 = (1013*G23+150*G24)>>10;H24 = (1013*G24-150*G23)>>10;H25 = (610*G25-822*G22)>>10;H26 = (878*G26-526*G21)>>10;H27 = (249*G27-993*G20)>>10;H28 = (964*G28-345*G19)>>10;H29 = (438*G29-926*G18)>>10;H30 = (759*G30-688*G17)>>10;H31 = (50*G31-1023*G16)>>10;H32 = G32+G33;H33 = G32-G33;H34 = G35-G34;H35 = G35+G34;H36 = G36+G37;H37 = G36-G37;H38 = G39-G38;H39 = G39+G38;H40 = G40+G41;H41 = G40-G41;H42 = G43-G42;H43 = G43+G42;H44 = G44+G45;H45 = G44-G45;H46 = G47-G46;H47 = G47+G46;H48 = G48+G49;H49 = G48-G49;H50 = G51-G50;H51 = G51+G50;H52 = G52+G53;H53 = G52-G53;H54 = G55-G54;H55 = G55+G54;H56 = G56+G57;H57 = G56-G57;H58 = G59-G58;H59 = G59+G58;H60 = G60+G61;H61 = G60-G61;H62 = G63-G62;H63 = G63+G62;;I0 = H0;I1 = H1;I2 = H2;I3 = H3;I4 = H4;I5 = H5;I6 = H6;I7 = H7;I8 = H8;I9 = H9;I10 = H10;I11 = H11;I12 = H12;I13 = H13;I14 = H14;I15 = H15;I16 = H16;I17 = H17;I18 = H18;I19 = H19;I20 = H20;I21 = H21;I22 = H22;I23 = H23;I24 = H24;I25 = H25;I26 = H26;I27 = H27;I28 = H28;I29 = H29;I30 = H30;I31 = H31;I32 = (25*H32+1024*H63)>>10;I33 = (742*H33+706*H62)>>10;I34 = (415*H34+936*H61)>>10;I35 = (955*H35+369*H60)>>10;I36 = (224*H36+999*H59)>>10;I37 = (865*H37+548*H58)>>10;I38 = (590*H38+837*H57)>>10;I39 = (1009*H39+175*H56)>>10;I40 = (125*H40+1016*H55)>>10;I41 = (807*H41+630*H54)>>10;I42 = (505*H42+891*H53)>>10;I43 = (987*H43+273*H52)>>10;I44 = (321*H44+972*H51)>>10;I45 = (915*H45+460*H50)>>10;I46 = (669*H46+775*H49)>>10;I47 = (1021*H47+75*H48)>>10;I48 = (1021*H48-75*H47)>>10;I49 = (669*H49-775*H46)>>10;I50 = (915*H50-460*H45)>>10;I51 = (321*H51-972*H44)>>10;I52 = (987*H52-273*H43)>>10;I53 = (505*H53-891*H42)>>10;I54 = (807*H54-630*H41)>>10;I55 = (125*H55-1016*H40)>>10;I56 = (1009*H56-175*H39)>>10;I57 = (590*H57-837*H38)>>10;I58 = (865*H58-548*H37)>>10;I59 = (224*H59-999*H36)>>10;I60 = (955*H60-369*H35)>>10;I61 = (415*H61-936*H34)>>10;I62 = (742*H62-706*H33)>>10;I63 = (25*H63-1024*H32)>>10;;Y0 = I0;Y1 = I32;Y2 = I16;Y3 = I48;Y4 = I8;Y5 = I40;Y6 = I24;Y7 = I56;Y8 = I4;Y9 = I36;Y10 = I20;Y11 = I52;Y12 = I12;Y13 = I44;Y14 = I28;Y15 = I60;Y16 = I2;Y17 = I34;Y18 = I18;Y19 = I50;Y20 = I10;Y21 = I42;Y22 = I26;Y23 = I58;Y24 = I6;Y25 = I38;Y26 = I22;Y27 = I54;Y28 = I14;Y29 = I46;Y30 = I30;Y31 = I62;Y32 = I1;Y33 = I33;Y34 = I17;Y35 = I49;Y36 = I9;Y37 = I41;Y38 = I25;Y39 = I57;Y40 = I5;Y41 = I37;Y42 = I21;Y43 = I53;Y44 = I13;Y45 = I45;Y46 = I29;Y47 = I61;Y48 = I3;Y49 = I35;Y50 = I19;Y51 = I51;Y52 = I11;Y53 = I43;Y54 = I27;Y55 = I59;Y56 = I7;Y57 = I39;Y58 = I23;Y59 = I55;Y60 = I15;Y61 = I47;Y62 = I31;Y63 = I63
다시 도 3을 참조하면, 단계 350에서 이산 코사인 변환에 이용되는 원래의 NxN 변환 행렬(Original_A)과 치환된 NxN 변환 행렬(A) 사이의 차이값을 보정하기 위한 스케일링 행렬 및 시프트 연산을 적용하여 NxN 크기의 블록을 변환한 변환 블록에 대한 양자화를 수행한다.
전술한 바와 같이, 본 발명의 일 실시예에 따르면 원래의 NxN 변환 행렬(Original_A)에 포함된 cosθ, sinθ 성분들을 유리수인 변수 ai로 치환하였기 때문에 원래의 NxN 변환 행렬(Original_A)과 치환된 변환 행렬(A)에 의한 결과값은 오차가 발생한다. 따라서, 본 발명의 일 실시예에 따르면 양자화 단계에서 양자화와 함께 수행되는 스케일링 단계에서 스케일링 행렬을 적용하여 이러한 오차를 최소화한다.
도 5는 본 발명의 일 실시예에 따른 양자화 과정을 나타낸 플로우 차트이다.
도 5를 참조하면, 단계 510에서 각 i번째 행의 원소가 Si(i는 1부터 N까지의 정수)의 값을 갖는 NxN 크기의 중간 행렬(S)의 각 원소와 치환된 NxN 크기의 변환 행렬(A)의 동일 위치의 원소들을 각각 곱한 값(SⓧA)과, 원래의 NxN 변환 행렬(Original_A) 사이의 차이인 변환 오차 행렬(Original_A-SⓧA )을 획득한다. ⓧ는 원소 단위 곱셈(element-by-element multiplication, element-wise multiplication) 연산을 나타내는 것으로, 행렬의 동일 위치의 원소가 곱해진다.
예를 들어, 16x16 크기의 중간 행렬(S)는 다음과 같다.
Figure PCTKR2010000443-appb-I000001
단계 520에서 변환 오차 행렬(Original_A-SⓧA)의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 Si 값들을 획득한다. Si 값들은 다양한 최적화 알고리즘을 이용하여 결정될 수 있다. 일 예로 S1의 초기값을 (1/4*2^(1/2))로 하고 Nelder-Mead Sipmlex 방법과 같은 최적화 알고리즘을 적용하여 Si값들을 결정할 수 있다.
단계 530에서 획득된 Si값들을 적용한 NxN 크기의 중간 행렬(S)의 각 원소와 중간 행렬(S)의 전치 행렬(ST)의 동일 위치의 원소들을 각각 곱한 행렬(SⓧST)에 기초하여 스케일링 행렬을 생성한다.
중간 행렬(S)의 각 원소와 중간 행렬의 전치 행렬(ST)의 동일 위치의 원소를 곱한 행렬(SⓧST)을 PF라고 하면, 스케일링 행렬(MF)는 다음의 수학식; MF=PF*2^m/Qstep 과 같이 계산될 수 있다. 여기서, Qstep은 양자화 스텝, m은 양의 정수이다.
단계 540에서, 스케일링 행렬(MF) 및 시프트 연산을 적용하여 NxN 크기의 블록을 변환한 변환 블록에 대한 양자화를 수행한다. 구체적으로 양자화는 스케일링 행렬(MF)와 NxN 크기의 블록을 변환한 변환 블록을 곱한 값에 소정의 오프셋을 더한 값을 다음의 수학식; q=floor(QP/6)+m 의 q 비트만큼 비트 시프트 연산함으로써 수행된다. Zij를 양자화된 계수값, Wij를 변환 계수, f를 오프셋이라고 하면,
Figure PCTKR2010000443-appb-I000002
이고,
Figure PCTKR2010000443-appb-I000003
이다. 여기서, '.MF'는 행렬의 동일 위치의 원소를 곱하는 벡터곱 연산을 의미한다. 전술한 바와 같이, 벡터곱 연산은 ⓧ와 같이 표현될 수도 있다.
도 7은 본 발명의 일 실시예에 따라서 16x16 블록의 변환시에 이용되는 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예를 도시한다. 도 7에서는 스케일링 행렬 계산시 m=10인 경우이다.
도 7에 도시된 바와 같은 스케일링 행렬은 모든 양자화 스텝에 대하여 정의될 필요없이 처음의 6단계의 Qstep 값인 (0.625, 0.6875, 0.8125, 0.875, 1, 1.25)에 대해서 정의된다. 왜냐하면 양자화 파라메터(QP)가 6 증가하면 양자화 스텝(Qstep)이 2배로 증가하기 때문에, 스케일링 행렬(MF)는 처음의 6단계의 Qstep 값에 대해서 정의되고, 나머지 QP에 따른 스케일링 행렬(MF)는 (QP mod 6) 값에 따라서 선택될 수 있다.
이와 같은 스케일링 행렬(MF)는 32x32 블록이나 64x64 블록에 대해서도 전술한 16x16 블록에 대한 스케일링 행렬을 구하는 과정과 유사한 과정을 통해 획득될 수 있다. 도 9 내지 도 14는 이와 같은 과정을 통해 획득된 32x32 블록에 적용되는 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예를 도시한다. 64x64 블록에 적용되는 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)는 다음과 같이 정의될 수 있다.
< 64x64 입력 블록에 대한 스케일링 행렬(MF)의 예>
m = 11 일 때, Q0 = 102*ONES / Q1 = 93*ONES / Q2 = 79*ONES / Q3 = 73*ONES / Q4 = 64*ONES / Q5 = 57*ONES
m = 10 일 때, Q0 = 51*ONES / Q1 = 47*ONES / Q2 = 39*ONES /
Q3 = 37*ONES / Q4 = 32*ONES / Q5 = 28*ONES
m = 9일 때, Q0 = 26*ONES / Q1 = 23*ONES / Q2 = 20*ONES /
Q3 = 18*ONES / Q4 = 16*ONES / Q5 = 14*ONES
상기 예에서 Q#의 #값은 (QP mod 6)이며, ONES는 모든 원소가 1인 64x64 행렬을 나타낸다.
한편, 역양자화 단계에서는 이산 코사인 역변환에 이용되는 원래의 NxN 역변환 행렬과 치환된 NxN 변환 행렬의 역행렬인 NxN 역변환 행렬 사이의 차이값을 보정하기 위한 역스케일링 행렬 및 시프트 연산을 적용하여 역양자화를 수행한다.
본 발명의 일 실시예에 따르면, 역스케일링 행렬(V)는 전술한 스케일링 행렬(MF)의 생성시에도 이용되는 중간 행렬(S)의 각 원소와 중간 행렬의 전치 행렬(ST)의 동일 위치의 원소를 각각 곱한 행렬(SⓧST)인 PF에 기초하여 생성될 수 있다. 구체적으로, 양자화 스텝을 Qstep, 중간 행렬(S)의 각 원소와 중간 행렬의 전치 행렬(ST)동일 위치의 원소들을 각각 곱한 행렬을 PF, n은 양의 정수라고 할 때, 역스케일링 행렬(V)은 다음의 수학식; V=Qstep*PF*2^n 을 통해 획득된다.
전술한 바와 같이 역스케일링 행렬(V)가 결정되면, 역양자화는 역스케일링 행렬(V)와 양자화된 변환 계수를 곱한 값에 대해서 floor(QP/6)(floor[x]는 x보다 작거나 같은 최대 정수, QP는 양자화 파라메터) 비트만큼 비트 시프트 연산을 통해 수행될 수 있다. 즉, Zij를 양자화된 계수값, Wij를 변환 계수라고 하면 다음의 수학식; Wij=(Zij)<<floor(QP/6)을 통해 양자화된 계수 Zij를 역양자화한 Wij를 획득할 수 있다.
도 8은 본 발명의 일 실시예에 따라서 16x16 블록에 적용되는 양자화 파라메터(QP)에 따른 역스케일링 행렬(V)을 도시한다. 도 8에서는 역스케일링 행렬 계산시 m=10인 경우를 나타낸다. 역스케일링 행렬(V) 역시 도 7의 스케일링 행렬과 같이 모든 양자화 스텝에 대하여 정의될 필요는 없고, 처음의 6단계의 Qstep 값인 (0.625, 0.6875, 0.8125, 0.875, 1, 1.25)에 대해서 정의될 수 있다. 나머지 QP에 따른 역스케일링 행렬(V)는 (QP mod 6) 값에 따라서 선택될 수 있다.
유사하게, 32x32 입력 블록 및 64x64 블록에 적용되는 양자화 파라메터에 따른 역스케일링 행렬(V)도 전술한 16x16 블록에 적용되는 역스케일링 행렬(V) 계산 과정과 유사한 과정을 통해 획득될 수 있다. 도 94 내지 도 99는 본 발명의 일 실시예에 따라서 32x32 블록에 적용되는 양자화 파라메터(QP)에 따른 역스케일링 행렬(V)의 예를 도시한다.
64x64 블록에 적용되는 양자화 파라메터(QP)에 따른 역스케일링 행렬(V)는 다음과 같이 정의될 수 있다.
< 64x64 입력 블록에 대한 역스케일링 행렬(V)의 예>
n = 11 일 때, Q0 = 40*ONES / Q1 = 44*ONES / Q2 = 52*ONES / Q3 = 56*ONES / Q4 = 64*ONES / Q5 = 72*ONES
n = 10 일 때, Q0 = 20*ONES / Q1 = 22*ONES / Q2 = 26*ONES /
Q3 = 28*ONES / Q4 = 32*ONES / Q5 = 36*ONES
n = 9일 때, Q0 = 10*ONES / Q1 = 11*ONES / Q2 = 13*ONES /
Q3 = 14*ONES / Q4 = 16*ONES / Q5 = 18*ONES
상기 예에서 Q#의 #값은 (QP mod 6)의 값이며, ONES는 모든 원소가 1인 64x64 행렬을 나타낸다.
도 6은 본 발명의 다른 실시예에 따른 양자화 과정을 나타낸 플로우 차트이다. 도 6의 본 발명의 다른 실시예에 따른 양자화 과정은 도 5의 본 발명의 일 실시예에 따른 양자화 과정과 비교할 때, 스케일링 행렬 생성에 이용되는 중간 행렬(S) 생성 과정에 있어서 차이가 나고, 나머지 과정은 전술한 도 5의 본 발명의 일 실시예에 따른 양자화 과정과 유사하다.
구체적으로, 도 6을 참조하면, 단계 610에서 이산 코사인 변환에 이용되는 원래의 NxN 변환 행렬(Original_A)의 각 원소를 치환된 NxN 변환 행렬(A)의 동일 위치의 원소들로 나눔으로써 중간 행렬(S) 획득한다.
단계 620에서, 단계 610에서 생성된 중간 행렬(S)의 각 원소와 중간 행렬의 전치 행렬(ST)의 동일 위치의 원소들을 각각 곱한 행렬(SⓧST)에 기초하여 스케일링 행렬을 생성한다. 구체적으로, 중간 행렬(S)과 중간 행렬의 전치 행렬(ST)의 동일 위치의 원소들을 각각 곱한 행렬(SⓧST)을 PF라고 하면, 스케일링 행렬(MF)는 다음의 수학식; MF=PF*2^m/Qstep 과 같이 계산될 수 있다. 여기서, Qstep은 양자화 스텝, m은 양의 정수이다.
단계 630에서, 스케일링 행렬(MF) 및 시프트 연산을 적용하여 NxN 크기의 블록을 변환한 변환 블록에 대한 양자화를 수행한다. 구체적으로 양자화는 스케일링 행렬(MF)와 NxN 크기의 블록을 변환한 변환 블록을 곱한 값에 소정의 오프셋을 더한 값에 대해서 다음의 수학식; q=floor(QP/6)+m 의 q 비트만큼 비트 시프트 연산을 통해 수행된다. Zij를 양자화된 계수값, Wij를 변환 계수, f를 오프셋이라고 하면,
Figure PCTKR2010000443-appb-I000004
이고,
Figure PCTKR2010000443-appb-I000005
이다. 여기서, '.MF'는 행렬의 동일 위치의 원소를 곱하는 벡터곱 연산을 의미한다.
도 15는 본 발명의 다른 실시예에 따른 32 포인트 이산 코사인 변환의 흐름도(flow graph)를 도시한다.
도 15를 참조하면, x0 내지 x31은 입력값들을 나타낸다. y0 내지 y31은 이산 코사인 변환의 출력값들을 나타낸다. 변환시에 데이터 처리 방향은 좌측에서 우측이며, 역변환시에 데이터 처리 방향은 우측에서 좌측이다. 점에서 교차하는 2개의 라인은 2개의 수의 덧셈을 나타낸다. '-'는 부정(negation)을 나타낸다. 각 라인 위의 값 R(θ)는 도 16에 도시된 바와 같은 버터플라이 구조에 기초한 연산 과정을 나타낸다.
도 16은 도 15의 32 포인트 이산 코사인 변환을 구성하는 버터플라이 구조의 연산 과정을 나타낸 참조도이다.
도 16을 참조하면, 버터 플라이 구조의 연산은 입력값 [X1,X2]에 대해서 다음의 수학식;
Figure PCTKR2010000443-appb-I000006
과 같은 연산을 통해 출력값 [Y1, Y2]를 출력하는 것이다. 이러한 버터 플라이 구조의 연산 과정은 2개의 입력값을 2개의 출력값에 매핑시키는 과정에서 총 4개의 곱셈 연산과 2개의 덧셈 연산을 하게 된다.
일반적으로 곱셈 연산은 덧셈, 뺄셈 및 쉬프트 연산에 비하여 연산이 복잡하고 연산 시간 역시 많이 소요되므로 전체적인 연산을 느리게 한다. 따라서, 본 발명의 다른 실시예에 따른 영상 변환 방법에서는 버터 플라이 구조에 기초한 4개의 곱셈 연산과 2개의 덧셈 연산 과정을 3개의 곱셈 연산과 3개의 덧셈 연산 과정으로 대체한 변경된 버터플라이 구조에 기초하여 영상 변환을 수행한다.
도 17은 본 발명의 다른 실시예에 따른 영상 변환 방법을 나타낸 플로우 차트이다. 도 17을 참조하면, 단계 1710에서 버터플라이 구조의 곱셈 인수 중 삼각 함수 성분을 유리수로 치환한다. 전술한 바와 같이 도 15에 도시된 바와 같은 32 포인트 이산 코사인 변환의 계산에는 R(θ)에 따라서, cosθ 및 sinθ가 이용된다. 본 발명의 다른 실시예에서는 상기 θ값에 따른 cosθ 및 sinθ 값으로서 다음과 같은 근사화된 유리수를 이용할 수 있다. 하기 기재된 바와 같이 근사화되는 유리수는 분모가 2의 거듭제곱꼴인 유리수(dyadic rational)를 이용하는 것이 바람직하다.
cos(pi/64) = 255/256;sin(pi/64) = 3/64;cos(pi*5/64) = 31/32;sin(pi*5/64) = 31/128;cos(pi*9/64) = 231/256 ;sin(pi*9/64) = 109/256;cos(pi*13/64) = 205/256;sin(pi*13/64) = 19/32;cos(pi*17/64) = 171/256;sin(pi*17/64) = 189/256;cos(pi*21/64) = 131/256;sin(pi*21/64) = 219/256 ;cos(pi*25/64) = 43/128 ;sin(pi*25/64) = 241/256;cos(pi*29/64) = 37/256;sin(pi*29/64) = 253/256;cos(pi*3/32) = 61/64;sin(pi*3/32) = 37/128;cos(pi*7/32) = 197/256;sin(pi*7/32) = 81/128;cos(pi*11/32) = 15/32;sin(pi*11/32) = 225/256;cos(pi*15/32) = 25/256;sin(pi*15/32) = 127/128;cos(pi/16) = 251/256;sin(pi/16) = 49/256;cos(pi*3/16) = 53/64 ;sin(pi*3/16) = 71/128;cos(pi*5/16) = 71/128;sin(pi*5/16) = 53/64;cos(pi*7/16) = 49/256;sin(pi*7/16) = 251/256;cos(pi/8) = 59/64;sin(pi/8) = 97/256;cos(pi*3/8) = 97/256;sin(pi*3/8) = 59/64;cos(pi/4) = 181/256;sin(pi/4) = 181/256;
단계 1720에서, 버터플라이 구조의 4개의 곱셈 연산과 2개의 덧셈 연산 과정을 3개의 곱셈 연산과 3개의 덧셈 연산 과정으로 대체한 변경된 버터플라이 구조에 기초하여 NxN 크기(N은 정수)의 블록의 행 단위 및 열 단위 중 어느 하나에 대한 1차원 이산 코사인 변환을 수행한다.
도 18은 본 발명의 일 실시예에 따른 변경된 버터플라이 구조를 나타낸 도면이다. 도 18을 참조하면, 좌측에 도시된 바와 같은 버터플라이 구조(1810)의 연산에 의한 입력값 X1, X2에 대한 결과값 Y1, Y2는 다음의 수학식과 같다.
Y1=a*X1+b*X2; Y2=b*X1-a*X2
도 18의 좌측에 도시된 바와 같은 버터플라이 구조(1810)의 연산에서는 결과값 Y1, Y2를 얻기 위해서 총 4번의 곱셈 연산과 2번의 덧셈 또는 뺄셈 연산이 필요하다. 우측에 도시된 변경된 버터플라이 구조(1820)의 연산에 의한 입력값 X1, X2에 대한 결과값 Y1, Y2는 다음의 수학식과 같다.
Y1=X1*(a-b)+b*(X1+X2)=a*X1+b*X2;
Y2=b*(X1+X2)-X2*(a+b)=b*X1-a*X2
우측에 도시된 변경된 버터플라이 구조(1820)의 연산 과정에서는 b*(X1+X2)의 계산에서 1번의 곱셈 연산이 수행되고 그 결과값이 Y1과 Y2의 계산에 모두 이용되므로 총 3번의 곱셈 연산과 3번의 덧셈 또는 뺄셈 연산이 필요하다. 따라서, 변경된 버터플라이 구조(1820)을 통해서 동일한 결과값을 가지면서도 복잡한 곱셈 연산 과정을 줄임으로써 연산 속도를 향상시킬 수 있다. 한편, 도 18의 우측에 도시된 바와 같은 변경된 버터플라이 구조(1820)를 도 15의 32 포인트 이산 코사인 변환에 적용할 때, sine과 cosine의 선형 조합값이 필요한 연산이 있다. 이 경우, 다음과 같은 근사화된 유리값을 이용하는 것이 바람직하다.
cos(pi*30/64) = 25/256;cos(pi*30/64)+sin(pi*30/64) = 279/256;cos(pi*30/64)-sin(pi*30/64) = -229/256;cos(pi*12/64) = 53/64;cos(pi*12/64)+sin(pi*12/64) = 355/256;cos(pi*12/64)-sin(pi*12/64) = 35/128;cos(pi*4/64) = 251/256;cos(pi*4/64)+sin(pi*4/64) = 301/256;cos(pi*4/64)-sin(pi*4/64) = 201/256;cos(pi*24/64) = 97/256;cos(pi*24/64)+sin(pi*24/64) = 167/128;cos(pi*24/64)-sin(pi*24/64) = -69/128;cos(pi*8/64) = 59/64;cos(pi*8/64)+sin(pi*8/64) = 167/128;cos(pi*8/64)-sin(pi*8/64) = 69/128; ;cos(pi*28/64) = 49/256;cos(pi*28/64)+sin(pi*28/64) = 301/256;cos(pi*28/64)-sin(pi*28/64) = -201/256;cos(pi*20/64) = 71/128;cos(pi*20/64)+sin(pi*20/64) = 355/256;cos(pi*20/64)-sin(pi*20/64) = -35/128;
도 19는 본 발명의 다른 실시예에 따른 변경된 버터플라이 구조를 나타낸 도면이다. 도 19를 참조하면, 좌측에 도시된 바와 같은 버터플라이 구조(1910)의 연산에 의한 입력값 X1, X2에 대한 결과값 Y1, Y2는 다음의 수학식과 같다.
Y1=cosθ*X1+sinθ*X2; Y2=-sinθ*X1+cosθ*X2
도 19의 좌측에 도시된 바와 같은 버터플라이 구조(1910)의 연산에서는 결과값 Y1, Y2를 얻기 위해서 총 4번의 곱셈 연산과 2번의 덧셈 또는 뺄셈 연산이 필요하다.
우측에 도시된 변경된 버터플라이 구조(1920)의 연산에 의한 입력값 X1, X2에 대한 결과값 Y1, Y2를 삼각함수 공식을 이용하여 정리하면, 우측에 도시된 변경된 버터플라이 구조(1920)는 좌측에 도시된 버터플라이 구조(1910)와 동일한 결과값을 출력한다. 우측에 도시된 변경된 버터플라이 구조(1920)의 연산 과정에서는 총 3번의 곱셈 연산과 3번의 덧셈 또는 뺄셈 연산이 필요하다. 따라서, 변경된 버터플라이 구조(1920)을 통해서 동일한 결과값을 가지면서도 복잡한 곱셈 연산 과정을 줄임으로써 연산 속도를 향상시킬 수 있다. 한편, 도 19의 우측에 도시된 바와 같은 변경된 버터플라이 구조를 도 15의 32 포인트 이산 코사인 변환에 적용할 때, sine과 cosine의 분수값 및 tangent 값이 필요한 연산이 있다. 이 경우, 다음과 같은 근사화된 유리값을 이용하는 것이 바람직하다.
(1-cos(pi*17/64))/sin(pi*17/64) = 113/256;(1-cos(pi*13/64))/sin(pi*13/64) = 21/64;(1-cos(pi*21/64))/sin(pi*21/64) = 145/256;(1-cos(pi*9/64))/sin(pi*9/64) = 57/256;(1-cos(pi*25/64))/sin(pi*25/64) = 45/64;(1-cos(pi*5/64))/sin(pi*5/64) = 31/256;(1-cos(pi*29/64))/sin(pi*29/64) = 55/64 ;(1-cos(pi*1/64))/sin(pi*1/64) = 3/128;(1-cos(pi*16/64))/sin(pi*16/64) = 53/128;tan(pi*8/64) = 53/128;sin(pi*8/64)*cos(pi*8/64) = 45/128;tan(pi*4/64) = 25/128 ;sin(pi*4/64)*cos(pi*4/64) = 3/16;tan(pi*12/64) = 171/256;sin(pi*12/64)*cos(pi*12/64) = 59/128 ;tan(pi*16/64) = 255/256;sin(pi*16/64)*cos(pi*16/64) = 1/2; ;(1-cos(pi*7/32))/sin(pi*7/32) = 91/256 ;sin(pi*7/32) = 81/128;(1-cos(pi*11/32))/sin(pi*11/32) = 153/256;sin(pi*11/32) = 225/256; ;(1-cos(pi*3/32))/sin(pi*3/32) = 37/256;sin(pi*3/32) = 37/128;;(1-cos(pi*15/32))/sin(pi*15/32) = 29/32;sin(pi*15/32) = 127/128;;(1-cos(pi*6/32))/sin(pi*6/32) = 77/256;sin(pi*6/32) = 71/128;;(1-cos(pi*2/32))/sin(pi*2/32) = 25/256;sin(pi*2/32) = 49/256; ;1/tan(pi*3/8) = 53/128 ;sin(pi*3/8)*cos(pi*3/8) = 45/128;
도 20은 본 발명의 또 다른 실시예에 따른 변경된 버터 플라이 구조를 나타낸 도면이다. 도 20을 참조하면, 좌측의 버터 플라이 구조(2010)는 동일한 결과값을 출력하는 우측의 버터 플라이 구조(2020)으로 변경될 수 있다. 본 발명의 또 다른 실시예에 따른 변경된 버터 플라이 구조(2020)에서는 최종 결과값인 Y1과 Y2가 획득되기 전에 도면 부호 2025로 표시된 바와 같이 각 연산 결과가 cosα 및 (1/(1-cosα))와 곱셈 연산이 수행된다. 이러한 도면 부호 2025로 표시된 곱셈 연산은 변환 과정에서 수행되지 않고, 양자화 과정에서 수행되는 스케일링 행렬에 반영될 수 있다. 다시 말해서, 도면 부호 2025에 표시된 곱셈 인자를 스케일링 행렬의 각 원소에 곱해줌으로써 변환 단계에서의 곱셈 연산을 감소시키고, 대신에 곱셈 연산을 양자화 과정에 통합시킬 수도 있다. 이와 같이, 도면 부호 2025에 표시된 곱셈 인자를 양자화 과정에 통합시키고 변환 단계에서 생략하는 경우, 도 20에 따른 버터 플라이 구조에서는 총 2회의 곱셈 및 2회의 덧셈 연산만으로 구성될 수 있다.
도 21은 본 발명의 또 다른 실시예에 따른 변경된 버터 플라이 구조를 나타낸 도면이다. 도 21에서는 버터 플라이 구조의 연산에서 변수에 해당하는 R(θ)의 θ가 특수한 값을 갖을 때, 예를 들어 도시된 바와 같이 θ=π/4일 때, 우측에 도시된 바와 같은 변경된 버터 플라이 구조(2120)에 의한 연산에 의해서도 좌측에 도시된 버터 플라이 구조(2110)에 의한 연산과 동일한 결과를 얻을 수 있는 것을 도시한다. 우측에 도시된 버터 플라이 구조(2120)에 의한 연산 과정에서는 좌측에 도시된 버터 플라이 구조(2110)에 비하여 전체 연산 횟수를 감소시킬 수 있다.
도 18의 우측에 도시된 바와 같은 변경된 버터 플라이 구조(1820)의 연산을 도 15의 버터 플라이 구조 각각에 적용하여 32 포인트 이산 코사인 변환을 수행하는 경우, X0 내지 X31는 변환되어야 할 입력값, A0 내지 A31, B0 내지 B31, C0 내지 C31, D0 내지 D31, E0 내지 E31, F0 내지 F31은 중간값, t는 보조 변수, Y0 내지 Y31은 변환된 값을 나타낸다고 할 때, 변환 결과 Y0 내지 Y31은 다음의 연산 과정을 통해 획득될 수 있다.
A0 = X0 + X31; A31 = X0 - X31; A1 = X1 + X30; A30 = X1 - X30; A2 = X2 + X29; A29 = X2 - X29; A3 = X3 + X28; A28 = X3 - X28; A4 = X4 + X27; A27 = X4 - X27; A5 = X5 + X26; A26 = X5 - X26; A6 = X6 + X25; A25 = X6 - X25; A7 = X7 + X24; A24 = X7 - X24; A8 = X8 + X23; A23 = X8 - X23; A9 = X9 + X22; A22 = X9 - X22; A10 = X10 + X21; A21 = X10 - X21; A11 = X11 + X20; A20 = X11 - X20; A12 = X12 + X19; A19 = X12 - X19; A13 = X13 + X18; A18 = X13 - X18; A14 = X14 + X17; A17 = X14 - X17; A15 = X15 + X16; A16 = X15 - X16;
B0 = A0 + A15; B15 = A0 - A15; B1 = A1 + A14; B14 = A1 - A14; B2 = A2 + A13; B13 = A2 - A13; B3 = A3 + A12; B12 = A3 - A12; B4 = A4 + A11; B11 = A4 - A11; B5 = A5 + A10; B10 = A5 - A10; B6 = A6 + A9; B9 = A6 - A9; B7 = A7 + A8; B8 = A7 - A8;
t = ((171*(A16 + A31) >> 8); B16 = t - ((361*A31) >> 8); B31 = t - ((-17*A16) >> 8);
t = ((205*(A17 + A30) >> 8); B17 = t - ((53*A30) >> 8); B30 = t - ((358*A17) >> 8);
t = ((131*(A18 + A29) >> 8); B18 = t - ((351*A29) >> 8); B29 = t - ((-87*A18) >> 8);
t = ((231*(A19 + A28) >> 8); B19 = t - ((121*A28) >> 8); B28 = t - ((340*A19) >> 8);
t = ((86*(A20 + A27) >> 8); B20 = t - ((327*A27) >> 8); B27 = t - ((-77*A20) >> 8);
t = ((248*(A21 + A26) >> 8); B21 = t - ((186*A26) >> 8); B26 = t - ((310*A21) >> 8);
t = ((37*(A22 + A25) >> 8); B22 = t - ((290*A25) >> 8); B25 = t - ((-215*A22) >> 8);
t = ((255*(A23 + A24) >> 8); B23 = t - ((243*A24) >> 8); B24 = t - ((268*A23) >> 8);
C0 = B0 + B7; C7 = B0 - B7; C1 = B1 + B6; C6 = B1 - B6; C2 = B2 + B5; C5 = B2 - B5; C3 = B3 + B4; C4 = B3 - B4;
t = ((197*(B8 + B15) >> 8); C8 = t - ((35*B15) >> 8); C15 = t - ((360*B8) >> 8);
t = ((120*(B9 + B14) >> 8); C9 = t - ((346*B14) >> 8); C14 = t - ((-105*B9) >> 8);
t = ((244*(B10 + B13) >> 8); C10 = t - ((170*B13) >> 8); C13 = t - ((319*B10) >> 8);
t = ((25*(B11 + B12) >> 8); C11 = t - ((279*B12) >> 8); C12 = t - ((-229*B11) >> 8);
C16 = B16 + B23; C23 = B16 - B23; C17 = B17 + B22; C22 = B17 - B22; C18 = B18 + B21; C21 = B18 - B21; C19 = B19 + B20; C20 = B19 - B20; C24 = B24 + B31; C31 = B24 - B31; C25 = B25 + B30; C30 = B25 - B30; C26 = B26 + B29; C29 = B26 - B29; C27 = B27 + B28; C28 = B27 - B28;
D0 = C0 + C3; D3 = C0 - C3; D1 = C1 + C2; D2 = C1 - C2; t = ((49*(C4 + C7) >> 8); D4 = t - ((-201*C7) >> 8); D7 = t - ((301*C4) >> 8);
t = ((142*(C5 + C6) >> 8); D5 = t - ((-70*C6) >> 8); D6 = t - ((355*C5) >> 8); D8 = C8 + C11; D11 = C8 - C11; D9 = C9 + C10; D10 = C9 - C10; D12 = C12 + C15; D15 = C12 - C15; D13 = C13 + C14; D14 = C13 - C14; D16 = C16 + C28; D28 = C16 - C28; D17 = C17 + C29; D29 = C17 - C29; D18 = C18 + C30; D30 = C18 - C30; D19 = C19 + C31; D31 = C19 - C31; D20 = C20 + C23; D23 = C20 - C23; D21 = C21 + C22; D22 = C21 - C22; D24 = C24 + C27; D27 = C24 - C27; D25 = C25 + C26; D26 = C25 - C26;
E0 = ((D0 + D1)*181 >> 8); E1 = ((D0 - D1)*181 >> 8);
t = (97*(D2 + D3) >> 8); E2 = t - ((-138*D3) >> 8); E3 = t - ((334*D2) >> 8); E4 = D4 + D5; E5 = D4 - D5; E6 = -D6 + D7; E7 = D6 + D7; E8 = D8 + D14; E14 = D8 - D14; E9 = D9 + D15; E15 = D9 - D15; E10 = D10 + D11; E11 = D10 - D11; E12 = D12 + D13; E13 = D12 - D13; E16 = ((D16 + D19)*181 >> 8); E19 = ((D16 - D19)*181 >> 8); E20 = D20 + D26; E26 = D20 - D26; E21 = D21 + D27; E27 = D21 - D27; E22 = D22 + D23; E23 = D22 - D23; E24 = D24 + D25; E25 = D24 - D25; E28 = ((D28 + D31)*181 >> 8); E31 = ((D28 - D31)*181 >> 8);
F5 = ((E5 + E7)*181 >> 8); F7 = ((E5 - E7)*181 >> 8);
t = (97*(E8 + E9) >> 8); F8 = t - ((334*E9) >> 8); F9 = t - ((-138*E8) >> 8); F11 = ((E11 + E12)*181 >> 8); F12 = ((E12 - F11)*181 >> 8);
t = (97*(E14 + E15) >> 8); F14 = t - ((334*E15) >> 8); F15 = t - ((-138*E14) >> 8); F16 = E16 + D18; F18 = E16 - D18; F17 = D17 + E19; F19 = D17 - E19;
t = (236*(E20 + E21) >> 8); F20 = t - ((138*E21) >> 8); F21 = t - ((334*E20) >> 8); F23 = ((E23 + E24)*181 >> 8); F24 = ((E23 - E24)*181 >> 8);
t = ((236*(E26 + E27)) >> 8); F26 = t - ((138*E27) >> 8); F27 = t - ((334*E26) >> 8); F28 = -E28 + D30; F30 = E28 + D30; F29 = -D29 + E31; F31 = D29 + E31;
t = (251*(F16 + F17) >> 8); G16 = t - ((301*F17) >> 8); G17 = t - ((201*F16) >> 8);
t = (212*(F18 + F19) >> 8); G18 = t - ((355*F19) >> 8); G19 = t - ((70*F18) >> 8);
t = (212*(F28 + F29) >> 8); G28 = t - ((355*F29) >> 8); G29 = t - ((70*F28) >> 8);
t = (251*(F30 + F31) >> 8); G30 = t - ((301*F31) >> 8); G31 = t - ((201*F30) >> 8);
Y0 = E0; Y1 = F24; Y2 = -F12; Y3 = -G16; Y4 = E4; Y5 = G31; Y6 = F8; Y7 = -F26; Y8 = E2; Y9 = F21; Y10 = F15; Y11 = G29; Y12 = F5; Y13 = -G18; Y14 = E13; Y15 = E22; Y16 = E1; Y17 = E25; Y18 = E10; Y19 = -G19; Y20 = F7; Y21 = -G28; Y22 = F14; Y23 = -F20; Y24 = E3; Y25 = -F27; Y26 = F9; Y27 = -G30; Y28 = E6; Y29 = -G17; Y30 = F11; Y31 = -F23
만약, 도 19의 우측에 도시된 바와 같은 변경된 버터 플라이 구조(1920)의 연산을 도 15의 버터 플라이 구조 각각에 적용하여 32 포인트 이산 코사인 변환을 수행하는 경우, X0 내지 X31는 변환되어야 할 입력값, A0 내지 A31, B0 내지 B31, C0 내지 C31, D0 내지 D31, E0 내지 E31, F0 내지 F31, G0내지 G31은 중간값, Y0 내지 Y31은 변환된 값을 나타낸다고 할 때, 변환 결과 Y0 내지 Y31은 다음의 연산 과정을 통해 획득될 수 있다.
A0 = X0 + X31; A31 = X0 - X31; A1 = X1 + X30; A30 = X1 - X30; A2 = X2 + X29; A29 = X2 - X29; A3 = X3 + X28; A28 = X3 - X28; A4 = X4 + X27; A27 = X4 - X27; A5 = X5 + X26; A26 = X5 - X26; A6 = X6 + X25; A25 = X6 - X25; A7 = X7 + X24; A24 = X7 - X24; A8 = X8 + X23; A23 = X8 - X23; A9 = X9 + X22; A22 = X9 - X22; A10 = X10 + X21; A21 = X10 - X21; A11 = X11 + X20; A20 = X11 - X20; A12 = X12 + X19; A19 = X12 - X19; A13 = X13 + X18; A18 = X13 - X18; A14 = X14 + X17; A17 = X14 - X17; A15 = X15 + X16; A16 = X15 - X16;
B0 = A0 + A15; B15 = A0 - A15; B1 = A1 + A14; B14 = A1 - A14; B2 = A2 + A13; B13 = A2 - A13; B3 = A3 + A12; B12 = A3 - A12; B4 = A4 + A11; B11 = A4 - A11; B5 = A5 + A10; B10 = A5 - A10; B6 = A6 + A9; B9 = A6 - A9; B7 = A7 + A8; B8 = A7 - A8; B16 = A16 - ((113*A31)>> 8); B31 = A31 + ((189*B16)>> 8); B16 = B16 - ((113*B31)>> 8); B17 = A17 + ((21*A30) >> 6); B30 = A30 - ((152*B17) >> 8); B17 = B17 + ((21*B30) >> 6); B18 = A18 - ((145*A29) >> 8); B29 = A29 + ((219*B18) >> 8); B18 = B18 - ((145*B29) >> 8); B19 = A19 + ((57*A28) >> 8); B28 = A28 - ((109*B19) >> 8); B19 = B19 + ((57*B28) >> 8); B20 = A20 - ((45*A27) >> 6); B27 = A27 + ((241*B20) >> 8); B20 = B20 - ((45*B27) >> 6); B21 = A21 + ((31*A26) >> 8); B26 = A26 - ((31*B21) >> 7); B21 = B21 + ((31*B26) >> 8); B22 = A22 - ((55*A25) >> 6); B25 = A25 + ((253*B22) >> 8); B22 = B22 - ((55*B25) >> 6); B23 = A23 + ((3*A24) >> 7); B24 = A24 - ((3*B23) >> 6); B23 = B23 + ((3*B24) >> 7);
C0 = B0 + B7; C7 = B0 - B7; C1 = B1 + B6; C6 = B1 - B6;
C2 = B2 + B5; C5 = B2 - B5; C3 = B3 + B4; C4 = B3 - B4;
C15 = B15 - ((B8*91) >> 8); C8 = B8 + ((C15*81) >> 7);
C15 = C15 - ((C8*91) >> 8); C9 = B9 - ((B14*153) >> 8);
C14 = B14 + ((C9*225) >> 8); C9 = C9 - ((C14*153) >> 8);
C13 = B13 - ((B10*37) >> 8); C10 = B10 + ((C13*37) >> 7);
C13 = C13 - ((C10*37) >> 8); C11 = B11 - ((B12*29) >> 5);
C12 = B12 + ((C11*127) >> 7); C11 = C11 - ((C12*29) >> 5);
C16 = B16 + B23; C23 = B16 - B23; C17 = B17 + B22;
C22 = B17 - B22; C18 = B18 + B21; C21 = B18 - B21;
C19 = B19 + B20; C20 = B19 - B20; C24 = B24 + B31;
C31 = B24 - B31; C25 = B25 + B30; C30 = B25 - B30;
C26 = B26 + B29; C29 = B26 - B29; C27 = B27 + B28;
C28 = B27 - B28;
D0 = C0 + C3; D3 = C0 - C3; D1 = C1 + C2; D2 = C1 - C2;
D7 = C7 - ((C4*77) >> 8); D4 = C4 + ((D7*71) >> 7);
D7 = D7 - ((D4*77) >> 8); D6 = C6 - ((C5*25) >> 8);
D5 = C5 + ((D6*49) >> 8); D6 = D6 - ((D5*25) >> 8);
D8 = C8 + C11; D11 = C8 - C11; D9 = C9 + C10;
D10 = C9 - C10; D12 = C12 + C15; D15 = C12 - C15;
D13 = C13 + C14; D14 = C13 - C14; D16 = C16 + C28;
D28 = C16 - C28; D17 = C17 + C29; D29 = C17 - C29;
D18 = C18 + C30; D30 = C18 - C30; D19 = C19 + C31;
D31 = C19 - C31; D20 = C20 + C23; D23 = C20 - C23;
D21 = C21 + C22; D22 = C21 - C22; D24 = C24 + C27;
D27 = C24 - C27; D25 = C25 + C26; D26 = C25 - C26;
E0 = D0 + D1; E1 = (E0>>1) - D1;
E2 = -D2 + ((D3*53) >> 7); E3 = D3 - ((E2*45) >> 7);
E4 = D4 + D6; E6 = D4 - D6; E5 = D7 - D5; E7 = D7 + D5;
E8 = D8 + D14; E14 = D8 - D14; E9 = D9 + D15;
E15 = D9 - D15; E10 = D10 + D11; E11 = D10 - D11;
E12 = D12 + D13; E13 = D12 - D13;
E16 = ((D16 + D19)*181) >> 8; E19 = ((-D16 + D19)*181) >> 8;
E20 = D20 + D26; E26 = D20 - D26; E21 = D21 + D27;
E27 = D21 - D27; E22 = D22 + D23; E23 = D22 - D23;
E24 = D24 + D25; E25 = D24 - D25;
E28 = ((D28 + D31)*181) >> 8; E31 = ((-D28 + D31)*181) >> 8;
F7 = E7 + E4; F4 = (F7>>1) - E4;
F8 = E8 + ((E9*53) >> 7); F9 = -E9 + ((F8*45) >> 7);
F11 = E11 + E12; F12 = E12 - (F11 >> 1);
F14 = E14 + ((E15*53) >> 7); F15 = E15 - ((F14*45) >> 7);
F16 = E16 + D18; F18 = E16 - D18; F17 = D17 + E19;
F19 = D17 - E19; F20 = E20 + ((E21*53) >> 7);
F21 = E21 - ((F20*45) >> 7); F23 = E23 + ((E24*255) >> 8);
F24 = E24 - (F23 >> 1); F26 = E26 + ((E27*53) >> 7);
F27 = E27 - ((F26*45) >> 7); F28 = -E28 + D30;
F30 = E28 + D30; F29 = -D29 +E31; F31 = D29 + E31;
G16 = F16 - ((F17*25) >> 7); G17 = F17 + ((G16*3) >> 4);
G18 = F18 - ((F19*171) >> 8); G19 = F19 + ((G18*59) >> 7);
G28 = F28 - ((F29*171) >> 8); G29 = F29 + ((G28*59) >> 7);
G30 = F30 - ((F31*25) >> 7); G31 = F31 + ((G30*3) >> 4);
Y0 = E0; Y1 = F24; Y2 = F12; Y3 = -G16; Y4 = F7; Y5 = G31; Y6 = F9; Y7 = -F26; Y8 = E3; Y9 = F21; Y10 = F14; Y11 = G29; Y12 = E5; Y13 = -G18; Y14 = E13; Y15 = E22; Y16 = E1; Y17 = E25; Y18 = E10; Y19 = -G19; Y20 = E6; Y21 = -G28; Y22 = F15; Y23 = -F20; Y24 = E2; Y25 = -F27; Y26 = F8; Y27 = -G30; Y28 = F4; Y29 = -G17; Y30 = F11; Y31 = -F23
한편, 도 18 및 도 19에 도시된 변경된 버터플라이 구조에 기초한 32x32 크기의 블록의 변환을 위한 변경된 이산 코사인 변환 행렬을 A라고 할 때, 도 15에 대응되는 32x32 크기의 블록의 이산 코사인 변환에 이용되는 원래의 NxN 변환 행렬(Original_A)과 변경된 이산 코사인 변환 행렬 A 사이의 차이값을 보정하기 위한 스케일링 행렬 및 시프트 연산을 적용하여 NxN 크기의 블록을 변환한 변환 블록에 대한 양자화를 수행할 수 있다.
전술한 도 5과 같이, 스케일링 행렬은 각 i번째 행의 원소가 Si(i는 1부터 N까지의 정수)의 값을 갖는 NxN 크기의 중간 행렬(S)의 각 원소와 변경된 이산 코사인 변환 행렬 A의 동일 위치의 원소들을 각각 곱한 값(SⓧA)과, 원래의 NxN 변환 행렬 사이의 차이인 변환 오차 행렬(Original_A-SⓧA)을 획득하고, 변환 오차 행렬(Original_A- SⓧA)의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 Si 값들을 획득하며, 획득된 Si값들을 적용한 NxN 크기의 중간 행렬(S)의 각 원소와 중간 행렬의 전치 행렬(ST)의 동일 위치의 원소들을 각각 곱한 행렬(SⓧST)에 기초하여 생성될 수 있다. 원래의 NxN 변환 행렬(Original_A)이 차이가 난다는 점을 제외하고는 구체적인 과정은 전술한 도 5의 단계 530 및 540과 동일하므로 구체적인 설명은 생략한다. 도 18의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예는 도 22 내지 도 27과 같다. 도 22 내지 도 27에서는 m=10인 경우이다. 또한, 도 19의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예는 도 28 내지 도33과 같다. 도 28 내지 도 33에서는 m=10인 경우이다.
한편, 역양자화 단계에서는 이산 코사인 역변환에 이용되는 원래의 NxN 역변환 행렬과 치환된 NxN 변환 행렬의 역행렬인 NxN 역변환 행렬 사이의 차이값을 보정하기 위한 역스케일링 행렬 및 시프트 연산을 적용하여 역양자화를 수행한다. 전술한 도 18 및 도 19의 우측에 도시된 변경된 버터 플라이 구조를 적용하는 경우 이산 코사인 변환을 나타내는 행렬이 변화되기 때문에 역스케일링 행렬 역시 변화된다.
역스케일링 행렬(V)는 전술한 스케일링 행렬(MF)의 생성시에도 이용되는 중간 행렬(S)과 중간 행렬의 전치 행렬(ST)의 동일 위치의 원소들을 각각 곱한 행렬(SⓧST)에 해당하는 PF에 기초하여 생성될 수 있다. 구체적으로, 양자화 스텝을 Qstep, 중간 행렬(S)과 중간 행렬의 전치 행렬(ST)동일 위치의 원소들을 각각 곱한 행렬을 PF, n은 양의 정수라고 할 때, 역스케일링 행렬(V)은 다음의 수학식; V=Qstep*PF*2^n 을 통해 획득된다.
전술한 바와 같이 역스케일링 행렬(V)가 결정되면, 역양자화는 역스케일링 행렬(V)와 양자화된 변환 계수를 곱한 값에 대해서 floor(QP/6)(floor[x]는 x보다 작거나 같은 최대 정수, QP는 양자화 파라메터) 비트만큼 비트 시프트 연산을 통해 수행될 수 있다. 즉, Zij를 양자화된 계수값, Wij를 변환 계수라고 하면 다음의 수학식; Wij=(Zij)<<floor(QP/6)을 통해 양자화된 계수를 역양자화한 Wij를 획득할 수 있다.
도 18의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 역스케일링 행렬(v)의 예는 도 34 내지 도 39과 같다. 도 34 내지 도 39에서는 n=10인 경우이다. 또한, 도 19의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 역스케일링 행렬(V)의 예는 도 40 내지 도 45과 같다. 도 40내지 도 45에서는 n=10인 경우이다.
또한, 전술한 도 6과 유사하게 스케일링 행렬은 이산 코사인 변환에 이용되는 원래의 NxN 변환 행렬의 각 원소를 변경된 이산 코사인 변환 행렬 A의 동일 위치의 원소들로 나눔으로써 획득된 중간 행렬의 각 원소와 중간 행렬의 전치 행렬의 동일 위치의 원소를 곱하여 획득된 행렬일 수 있다. 도 18 및 도 19의 우측에 도시된 변경된 버터플라이 구조를 도 15의 알고리즘에 적용한 N 포인트 1차원 이산 코사인 변환을 나타내는 변경된 이산 코사인 변환 행렬(A)이 차이가 난다는 점을 제외하고는 구체적인 과정은 전술한 도 6과 동일하므로 구체적인 설명은 생략한다. 도 18의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예는 도 46 내지 도 51과 같다. 도 46 내지 도 51에서는 m=10인 경우이다. 또한, 도 19의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예는 도 52 내지 도 57과 같다. 도 52 내지 도 57에서는 m=10인 경우이다.
스케일링 행렬을 도 46 내지 57에 적용된 바와 같이 이산 코사인 변환에 이용되는 원래의 NxN 변환 행렬의 각 원소를 변경된 이산 코사인 변환 행렬 A의 동일 위치의 원소들로 나눔으로써 중간 행렬을 획득하고, 획득된 중간 행렬의 각 원소를 중간 행렬의 전치 행렬의 동일 위치의 원소와 곱하여 획득하는 경우, 원래의 NxN 변환 행렬이 차이가 나기 때문에 역스케일링 행렬(V) 역시 변경된다. 도 18의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 역스케일링 행렬(v)의 예는 도 58 내지 도 63과 같다. 도 58 내지 도 63에서는 n=10인 경우이다. 또한, 도 19의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 역스케일링 행렬(V)의 예는 도 64 내지 도 69과 같다. 도 64 내지 도 69에서는 n=10인 경우이다.
한편, 전술한 도 6과 유사하게 스케일링 행렬은 이산 코사인 변환에 이용되는 원래의 NxN 변환 행렬의 각 원소를 변경된 이산 코사인 변환 행렬 A의 동일 위치의 원소들로 나눔으로써 획득된 중간 행렬의 각 원소를 중간 행렬의 전치 행렬의 동일 위치의 원소들을 곱하여 획득된 행렬을 이용하는 한편, 역스케일링 행렬은 중간 행렬(S)을 이용하는 대신에 원래의 32 포인트 이산 코사인 역변환 행렬(Original_InverseA)의 각 원소와, 본 발명의 일 실시예에 따른 변경된 버터 플라이 구조에 대응되는 32 포인트 이산 코사인 변환 행렬(InverseA)의 동일 위치의 원소를 직접 나눔으로써 획득된 중간 행렬(R)을 이용하여 결정될 수 있다. 이 경우, 중간 행렬(R)의 각 원소와 중간 행렬(R)의 전치 행렬(RT)의 동일 위치의 원소들을 각각 곱한 행렬(RⓧRT)에 기초하여 역스케일링 행렬(V)을 생성한다. 구체적으로, 중간 행렬(R)과 중간 행렬의 전치 행렬(RT)의 동일 위치의 원소들을 각각 곱한 행렬(RⓧRT)을 BF, n은 양의 정수라고 할 때, 역스케일링 행렬(V)은 다음의 수학식; V=Qstep*BF*2^n 을 통해 획득된다. 도 18의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예는 도 70 내지 도 75과 같다. 도 70 내지 도 75에서는 m=10인 경우이다. 또한, 도 19의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 스케일링 행렬(MF)의 예는 도 76 내지 도 81과 같다. 도 76 내지 도 81에서는 m=10인 경우이다. 도 18의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 역스케일링 행렬(v)의 예는 도 82 내지 도 87과 같다. 도 82 내지 도 87에서는 n=10인 경우이다. 또한, 도 19의 우측에 도시된 변경된 버터 플라이 구조를 적용하였을 때 32x32 입력 블록에 대한 양자화 파라메터(QP)에 따른 역스케일링 행렬(V)의 예는 도 88 내지 도 93과 같다. 도 88 내지 도 93에서는 n=10인 경우이다.
도 100은 본 발명의 일 실시예에 따른 영상 복호화 장치를 나타낸 블록도이다.
도 100을 참조하면, 본 발명의 일 실시예에 따른 영상 복호화 장치(10000)는 엔트로피 복호화부(10010), 역양자화부(10020), 역변환부(10030) 및 예측부(10040)를 포함한다.
엔트로피 복호화부(10010)는 입력 비트스트림으로부터 복호화되는 현재 블록의 예측 모드 정보, 참조 픽처 정보 및 레지듀얼 정보를 추출한다.
역양자화부(10020)는 엔트로피복호화부(10010)에서 엔트로피 복호화된 양자화된 변환 계수들을 역양자화한다. 전술한 바와 같이 본 발명의 다양한 실시예를 통해서 역스케일링 행렬(V)이 결정되면, 역양자화부(10020)는 역스케일링 행렬(V)와 양자화된 변환 계수를 곱한 값에 대해서 floor(QP/6)(floor[x]는 x보다 작거나 같은 최대 정수, QP는 양자화 파라메터) 비트만큼 비트 시프트 연산을 통해 역양자화를 수행한다. 즉, Zij를 양자화된 계수값, Wij를 변환 계수라고 하면 다음의 수학식; Wij=(Zij)<<floor(QP/6)을 통해 양자화된 계수를 역양자화한 Wij를 획득할 수 있다.
역변환부(10030)는 역양자화된 변환 계수들을 역변환한다. 역변환 결과, 블록 단위에 대한 레지듀얼 값들이 복원된다. 역변환 과정은 본 발명의 다양한 실시예를 통해서 획득된 NxN 변환 행렬(A)의 역행렬(A-1)을 이용한 N 포인트 이산 코사인 역변환을 통해 수행될 수 있다.
전술한 도 3의 실시예에 따라서 변환된 16x16 입력 블록에 대하여 치환된 16x16 변환 행렬(A)의 역변환 행렬(A-1)를 이용한 1차원 이산 코사인 역변환을 수행하는 경우, X0 내지 X15은 역변환되어야 할 입력값, B0 내지 B15, C0 내지 C15, D0 내지 D15, E0 내지 E15, F0 내지 F15, G0 내지 G15은 중간값, Y0 내지 Y15은 역변환된 값을 나타낸다고 할 때, 다음의 연산 과정과 같이 표현될 수 있다.
G0 = X0;G8 = X1;G4 = X2;G12 = X3;G2 = X4;G10 = X5;G6 = X6;G14 = X7;G1 = X8;G9 = X9;G5 = X10;G13 = X11;G3 = X12;G11 = X13;G7 = X14;G15 = X15;F0 = G0;F1 = G1;F2 = G2;F3 = G3;F4 = G4;F5 = G5;F6 = G6;F7 = G7;F8 = (6*G8-63*G15) >> 6;F9 = (49*G9-40*G14) >> 6;F10 = (30*G10-56*G13) >> 6;F11 = (61*G11-18*G12) >> 6;F12 = (61*G12+18*G11) >> 6;F13 = (30*G13+56*G10) >> 6;F14 = (49*G14+40*G9) >> 6;F15 = (6*G15+63*G8) >> 6;E0 = F0;E1 = F1;E2 = F2;E3 = F3;E4 = (12*F4-62*F7) >> 6;E5 = (53*F5-35*F6) >> 6;E6 = (53*F6+35*F5) >> 6;E7 = (12*F7+62*F4) >> 6;E8 = F8+F9;E9 = F8-F9;E10 = F11-F10;E11 = F11+F10;E12 = F12+F13;E13 = F12-F13;E14 = F15-F14;E15 = F15+F14;D0 = (45*(E0+E1)) >> 6;D1 = (45*(E0-E1)) >> 6;D2 = (24*E2-59*E3) >> 6;D3 = (59*E2+24*E3) >> 6;D4 = E4+E5;D5 = E4-E5;D6 = E7-E6;D7 = E7+E6;D8 = E8;D9 = (24*E14-59*E9) >> 6;D10 = (-59*E13-24*E10) >> 6;D11 = E11;D12 = E12;D13 = (24*E13-59*E10) >> 6;D14 = (59*E14+24*E9) >> 6;D15 = E15;C0 = D0+D3;C3 = D0-D3;C8 = D8+D11;C11 = D8-D11;C12 = D15-D12;C15 = D15+D12;C1 = D1+D2;C2 = D1-D2;C9 = D9+D10;C10 = D9-D10;C13 = D14-D13;C14 = D14+D13;C4 = D4;C5 = (45*(D6-D5)) >> 6;C6 = (45*(D6+D5)) >> 6;C7 = D7;B0 = C0+C7;B7 = C0-C7;B1 = C1+C6;B6 = C1-C6;B2 = C2+C5;B5 = C2-C5;B3 = C3+C4;B4 = C3-C4;B8 = C8;B14 = C14;B10 = (45*(C13-C10)) >> 6;B13 = (45*(C13+C10)) >> 6;B9 = C9;B15 = C15;B11 = (45*(C12-C11)) >> 6;B12 = (45*(C12+C11)) >> 6;Y0 = B0+B15;Y15 = B0-B15;Y1 = B1+B14;Y14 = B1-B14;Y2 = B2+B13;Y13 = B2-B13;Y3 = B3+B12;Y12 = B3-B12;Y4 = B4+B11;Y11 = B4-B11;Y5 = B5+B10;Y10 = B5-B10;Y6 = B6+B9;Y9 = B6-B9;Y7 = B7+B8;Y8 = B7-B8
전술한 도 3의 실시예에 따라서 변환된 32x32 입력 블록에 대하여 치환된 32x32 변환 행렬(A)의 역변환 행렬(A-1)를 이용한 1차원 이산 코사인 역변환을 수행하는 경우, X0 내지 X31은 역변환되어야 할 입력값, A0 내지 A31, B0 내지 B31, C0 내지 C31, D0 내지 D31, E0 내지 E31, F0 내지 F31, G0 내지 G31, H0 내지 H31은 중간값, Y0 내지 Y31은 역변환된 값을 나타낸다고 할 때, 다음의 연산 과정과 같이 표현될 수 있다.
H0 = X0;H16 = X1;H8 = X2;H24 = X3;H4 = X4;H20 = X5;H12 = X6;H28 = X7;H2 = X8;H18 = X9;H10 = X10;H26 = X11;H6 = X12;H22 = X13;H14 = X14;H30 = X15;H1 = X16;H17 = X17;H9 = X18;H25 = X19;H5 = X20;H21 = X21;H13 = X22;H29 = X23;H3 = X24;H19 = X25;H11 = X26;H27 = X27;H7 = X28;H23 = X29;H15 = X30;H31 = X31;G0 = H0;G1 = H1;G2 = H2;G3 = H3;G4 = H4;G5 = H5;G6 = H6;G7 = H7;G8 = H8;G9 = H9;G10 = H10;G11 = H11;G12 = H12;G13 = H13;G14 = H14;G15 = H15;G16 = (12*H16-255*H31) >> 8;G17 = (189*H17-171*H30) >> 8;G18 = (109*H18-231*H29) >> 8;G19 = (241*H19-86*H28) >> 8;G20 = (62*H20-248*H27) >> 8;G21 = (219*H21-131*H26) >> 8;G22 = (152*H22-205*H25) >> 8;G23 = (253*H23-37*H24) >> 8;G24 = (253*H24+37*H23) >> 8;G25 = (152*H25+205*H22) >> 8;G26 = (219*H26+131*H21) >> 8;G27 = (62*H27+248*H20) >> 8;G28 = (241*H28+86*H19) >> 8;G29 = (109*H29+231*H18) >> 8;G30 = (189*H30+171*H17) >> 8;G31 = (12*H31+255*H16) >> 8;F0 = G0;F1 = G1;F2 = G2;F3 = G3;F4 = G4;F5 = G5;F6 = G6;F7 = G7;F8 = (25*G8-254*G15) >> 8;F9 = (197*G9-162*G14) >> 8;F10 = (120*G10-225*G13) >> 8;F11 = (244*G11-74*G12) >> 8;F12 = (244*G12+74*G11) >> 8;F13 = (120*G13+225*G10) >> 8;F14 = (197*G14+162*G9) >> 8;F15 = (25*G15+254*G8) >> 8;F16 = G16+G17;F17 = G16-G17;F18 = G19-G18;F19 = G19+G18;F20 = G20+G21;F21 = G20-G21;F22 = G23-G22;F23 = G23+G22;F24 = G24+G25;F25 = G24-G25;F26 = G27-G26;F27 = G27+G26;F28 = G28+G29;F29 = G28-G29;F30 = G31-G30;F31 = G31+G30;E0 = F0;E1 = F1;E2 = F2;E3 = F3;E4 = (49*F4-251*F7) >> 8;E5 = (212*F5-142*F6) >> 8;E6 = (212*F6+142*F5) >> 8;E7 = (49*F7+251*F4) >> 8;E8 = F8+F9;E9 = F8-F9;E10 = F11-F10;E11 = F11+F10;E12 = F12+F13;E13 = F12-F13;E14 = F15-F14;E15 = F15+F14;E16 = F16;E17 = (49*F30-251*F17) >> 8;E18 = (-251*F29-49*F18) >> 8;E19 = F19;E20 = F20;E21 = (212*F26-142*F21) >> 8;E22 = (-142*F25-212*F22) >> 8;E23 = F23;E24 = F24;E25 = (212*F25-142*F22) >> 8;E26 = (142*F26+212*F21) >> 8;E27 = F27;E28 = F28;E29 = (49*F29-251*F18) >> 8;E30 = (251*F30+49*F17) >> 8;E31 = F31;D0 = (181*(E0+E1)) >> 8;D1 = (181*(E0-E1)) >> 8;D2 = (97*E2-236*E3) >> 8;D3 = (236*E2+97*E3) >> 8;D4 = E4+E5;D5 = E4-E5;D6 = E7-E6;D7 = E7+E6;D8 = E8;D9 = (97*E14-236*E9) >> 8;D10 = (-236*E13-97*E10) >> 8;D11 = E11;D12 = E12;D13 = (97*E13-236*E10) >> 8;D14 = (236*E14+97*E9) >> 8;D15 = E15;D16 = E16+E19;D19 = E16-E19;D20 = E23-E20;D23 = E23+E20;D24 = E24+E27;D27 = E24-E27;D28 = E31-E28;D31 = E31+E28;D17 = E17+E18;D18 = E17-E18;D21 = E22-E21;D22 = E22+E21;D25 = E25+E26;D26 = E25-E26;D29 = E30-E29;D30 = E30+E29;C0 = D0+D3;C3 = D0-D3;C8 = D8+D11;C11 = D8-D11;C12 = D15-D12;C15 = D15+D12;C1 = D1+D2;C2 = D1-D2;C9 = D9+D10;C10 = D9-D10;C13 = D14-D13;C14 = D14+D13;C4 = D4;C5 = (181*(D6-D5)) >> 8;C6 = (181*(D6+D5)) >> 8;C7 = D7;C16 = D16;C18 = (97*D29-236*D18) >> 8;C20 = (-236*D27-97*D20) >> 8;C22 = D22;C24 = D24;C26 = (-236*D21+97*D26) >> 8;C28 = (97*D19+236*D28) >> 8;C30 = D30;C17 = D17;C19 = (97*D28-236*D19) >> 8;C21 = (-236*D26-97*D21) >> 8;C23 = D23;C25 = D25;C27 = (-236*D20+97*D27) >> 8;C29 = (97*D18+236*D29) >> 8;C31 = D31;B0 = C0+C7;B7 = C0-C7;B1 = C1+C6;B6 = C1-C6;B2 = C2+C5;B5 = C2-C5;B3 = C3+C4;B4 = C3-C4;B8 = C8;B14 = C14;B10 = (181*(C13-C10)) >> 8;B13 = (181*(C13+C10)) >> 8;B9 = C9;B15 = C15;B11 = (181*(C12-C11)) >> 8;B12 = (181*(C12+C11)) >> 8;B16 = C16+C23;B23 = C16-C23;B24 = C31-C24;B31 = C31+C24;B17 = C17+C22;B22 = C17-C22;B25 = C30-C25;B30 = C30+C25;B18 = C18+C21;B21 = C18-C21;B26 = C29-C26;B29 = C29+C26;B19 = C19+C20;B20 = C19-C20;B27 = C28-C27;B28 = C28+C27;A0 = B0+B15;A15 = B0-B15;A1 = B1+B14;A14 = B1-B14;A2 = B2+B13;A13 = B2-B13;A3 = B3+B12;A12 = B3-B12;A4 = B4+B11;A11 = B4-B11;A5 = B5+B10;A10 = B5-B10;A6 = B6+B9;A9 = B6-B9;A7 = B7+B8;A8 = B7-B8;A16 = B16;A28 = B28;A20 = (181*(B27-B20)) >> 8;A27 = (181*(B27+B20)) >> 8;A17 = B17;A29 = B29;A21 = (181*(B26-B21)) >> 8;A26 = (181*(B26+B21)) >> 8;A18 = B18;A30 = B30;A22 = (181*(B25-B22)) >> 8;A25 = (181*(B25+B22)) >> 8;A19 = B19;A31 = B31;A23 = (181*(B24-B23)) >> 8;A24 = (181*(B24+B23)) >> 8;Y0 = (A0+A31);Y31 = (A0-A31);Y1 = (A1+A30);Y30 = (A1-A30);Y2 = (A2+A29);Y29 = (A2-A29);Y3 = (A3+A28);Y28 = (A3-A28);Y4 = (A4+A27);Y27 = (A4-A27);Y5 = (A5+A26);Y26 = (A5-A26);Y6 = (A6+A25);Y25 = (A6-A25);Y7 = (A7+A24);Y24 = (A7-A24);Y8 = (A8+A23);Y23 = (A8-A23);Y9 = (A9+A22);Y22 = (A9-A22);Y10 = (A10+A21);Y21 = (A10-A21);Y11 = (A11+A20);Y20 = (A11-A20);Y12 = (A12+A19);Y19 = (A12-A19);Y13 = (A13+A18);Y18 = (A13-A18);Y14 = (A14+A17);Y17 = (A14-A17);Y15 = (A15+A16);Y16 = (A15-A16)
전술한 도 3의 실시예에 따라서 변환된 64x64 입력 블록에 대하여 치환된 64x64 변환 행렬(A)의 역변환 행렬(A-1)를 이용한 1차원 이산 코사인 역변환을 수행하는 경우, X0 내지 X63은 역변환되어야 할 입력값, A0 내지 A63, B0 내지 B63, C0 내지 C63, D0 내지 D63, E0 내지 E63, F0 내지 F63, G0 내지 G63, H0 내지 H63, I0 내지 I63, O0 내지 O63은 중간값, Y0 내지 Y63은 역변환된 값을 나타낸다고 할 때, 다음의 연산 과정과 같이 표현될 수 있다.
I0 = X0;I32 = X1;I16 = X2;I48 = X3;I8 = X4;I40 = X5;I24 = X6;I56 = X7;I4 = X8;I36 = X9;I20 = X10;I52 = X11;I12 = X12;I44 = X13;I28 = X14;I60 = X15;I2 = X16;I34 = X17;I18 = X18;I50 = X19;I10 = X20;I42 = X21;I26 = X22;I58 = X23;I6 = X24;I38 = X25;I22 = X26;I54 = X27;I14 = X28;I46 = X29;I30 = X30;I62 = X31;I1 = X32;I33 = X33;I17 = X34;I49 = X35;I9 = X36;I41 = X37;I25 = X38;I57 = X39;I5 = X40;I37 = X41;I21 = X42;I53 = X43;I13 = X44;I45 = X45;I29 = X46;I61 = X47;I3 = X48;I35 = X49;I19 = X50;I51 = X51;I11 = X52;I43 = X53;I27 = X54;I59 = X55;I7 = X56;I39 = X57;I23 = X58;I55 = X59;I15 = X60;I47 = X61;I31 = X62;I63 = X63;H0 = I0;H1 = I1;H2 = I2;H3 = I3;H4 = I4;H5 = I5;H6 = I6;H7 = I7;H8 = I8;H9 = I9;H10 = I10;H11 = I11;H12 = I12;H13 = I13;H14 = I14;H15 = I15;H16 = I16;H17 = I17;H18 = I18;H19 = I19;H20 = I20;H21 = I21;H22 = I22;H23 = I23;H24 = I24;H25 = I25;H26 = I26;H27 = I27;H28 = I28;H29 = I29;H30 = I30;H31 = I31;H32 = (25*I32-1024*I63) >> 10;H33 = (742*I33-706*I62) >> 10;H34 = (415*I34-936*I61) >> 10;H35 = (955*I35-369*I60) >> 10;H36 = (224*I36-999*I59) >> 10;H37 = (865*I37-548*I58) >> 10;H38 = (590*I38-837*I57) >> 10;H39 = (1009*I39-175*I56) >> 10;H40 = (125*I40-1016*I55) >> 10;H41 = (807*I41-630*I54) >> 10;H42 = (505*I42-891*I53) >> 10;H43 = (987*I43-273*I52) >> 10;H44 = (321*I44-972*I51) >> 10;H45 = (915*I45-460*I50) >> 10;H46 = (669*I46-775*I49) >> 10;H47 = (1021*I47-75*I48) >> 10;H48 = (1021*I48+75*I47) >> 10;H49 = (669*I49+775*I46) >> 10;H50 = (915*I50+460*I45) >> 10;H51 = (321*I51+972*I44) >> 10;H52 = (987*I52+273*I43) >> 10;H53 = (505*I53+891*I42) >> 10;H54 = (807*I54+630*I41) >> 10;H55 = (125*I55+1016*I40) >> 10;H56 = (1009*I56+175*I39) >> 10;H57 = (590*I57+837*I38) >> 10;H58 = (865*I58+548*I37) >> 10;H59 = (224*I59+999*I36) >> 10;H60 = (955*I60+369*I35) >> 10;H61 = (415*I61+936*I34) >> 10;H62 = (742*I62+706*I33) >> 10;H63 = (25*I63+1024*I32) >> 10;G0 = H0;G1 = H1;G2 = H2;G3 = H3;G4 = H4;G5 = H5;G6 = H6;G7 = H7;G8 = H8;G9 = H9;G10 = H10;G11 = H11;G12 = H12;G13 = H13;G14 = H14;G15 = H15;G16 = (50*H16-1023*H31) >> 10;G17 = (759*H17-688*H30) >> 10;G18 = (438*H18-926*H29) >> 10;G19 = (964*H19-345*H28) >> 10;G20 = (249*H20-993*H27) >> 10;G21 = (878*H21-526*H26) >> 10;G22 = (610*H22-822*H25) >> 10;G23 = (1013*H23-150*H24) >> 10;G24 = (1013*H24+150*H23) >> 10;G25 = (610*H25+822*H22) >> 10;G26 = (878*H26+526*H21) >> 10;G27 = (249*H27+993*H20) >> 10;G28 = (964*H28+345*H19) >> 10;G29 = (438*H29+926*H18) >> 10;G30 = (759*H30+688*H17) >> 10;G31 = (50*H31+1023*H16) >> 10;G32 = H32+H33;G33 = H32-H33;G34 = H35-H34;G35 = H35+H34;G36 = H36+H37;G37 = H36-H37;G38 = H39-H38;G39 = H39+H38;G40 = H40+H41;G41 = H40-H41;G42 = H43-H42;G43 = H43+H42;G44 = H44+H45;G45 = H44-H45;G46 = H47-H46;G47 = H47+H46;G48 = H48+H49;G49 = H48-H49;G50 = H51-H50;G51 = H51+H50;G52 = H52+H53;G53 = H52-H53;G54 = H55-H54;G55 = H55+H54;G56 = H56+H57;G57 = H56-H57;G58 = H59-H58;G59 = H59+H58;G60 = H60+H61;G61 = H60-H61;G62 = H63-H62;G63 = H63+H62;F0 = G0;F1 = G1;F2 = G2;F3 = G3;F4 = G4;F5 = G5;F6 = G6;F7 = G7;F8 = (100*G8-1019*G15) >> 10;F9 = (792*G9-650*G14) >> 10;F10 = (483*G10-903*G13) >> 10;F11 = (980*G11-297*G12) >> 10;F12 = (980*G12+297*G11) >> 10;F13 = (483*G13+903*G10) >> 10;F14 = (792*G14+650*G9) >> 10;F15 = (100*G15+1019*G8) >> 10;F16 = G16+G17;F17 = G16-G17;F18 = G19-G18;F19 = G19+G18;F20 = G20+G21;F21 = G20-G21;F22 = G23-G22;F23 = G23+G22;F24 = G24+G25;F25 = G24-G25;F26 = G27-G26;F27 = G27+G26;F28 = G28+G29;F29 = G28-G29;F30 = G31-G30;F31 = G31+G30;F32 = G32;F33 = (100*G62-1019*G33) >> 10;F34 = (-1019*G61-100*G34) >> 10;F35 = G35;F36 = G36;F37 = (792*G58-650*G37) >> 10;F38 = (-650*G57-792*G38) >> 10;F39 = G39;F40 = G40;F41 = (483*G54-903*G41) >> 10;F42 = (-903*G53-483*G42) >> 10;F43 = G43;F44 = G44;F45 = (980*G50-297*G45) >> 10;F46 = (-297*G49-980*G46) >> 10;F47 = G47;F48 = G48;F49 = (980*G49-297*G46) >> 10;F50 = (297*G50+980*G45) >> 10;F51 = G51;F52 = G52;F53 = (483*G53-903*G42) >> 10;F54 = (903*G54+483*G41) >> 10;F55 = G55;F56 = G56;F57 = (792*G57-650*G38) >> 10;F58 = (650*G58+792*G37) >> 10;F59 = G59;F60 = G60;F61 = (100*G61-1019*G34) >> 10;F62 = (1019*G62+100*G33) >> 10;F63 = G63;E0 = F0;E1 = F1;E2 = F2;E3 = F3;E4 = (200*F4-1004*F7) >> 10;E5 = (851*F5-569*F6) >> 10;E6 = (851*F6+569*F5) >> 10;E7 = (200*F7+1004*F4) >> 10;E8 = F8+F9;E9 = F8-F9;E10 = F11-F10;E11 = F11+F10;E12 = F12+F13;E13 = F12-F13;E14 = F15-F14;E15 = F15+F14;E16 = F16;E17 = (200*F30-1004*F17) >> 10;E18 = (-1004*F29-200*F18) >> 10;E19 = F19;E20 = F20;E21 = (851*F26-569*F21) >> 10;E22 = (-569*F25-851*F22) >> 10;E23 = F23;E24 = F24;E25 = (851*F25-569*F22) >> 10;E26 = (569*F26+851*F21) >> 10;E27 = F27;E28 = F28;E29 = (200*F29-1004*F18) >> 10;E30 = (1004*F30+200*F17) >> 10;E31 = F31;E32 = F32+F35;E33 = F33+F34;E34 = F33-F34;E35 = F32-F35;E36 = F39-F36;E37 = F38-F37;E38 = F38+F37;E39 = F39+F36;E40 = F40+F43;E41 = F41+F42;E42 = F41-F42;E43 = F40-F43;E44 = F47-F44;E45 = F46-F45;E46 = F46+F45;E47 = F47+F44;E48 = F48+F51;E49 = F49+F50;E50 = F49-F50;E51 = F48-F51;E52 = F55-F52;E53 = F54-F53;E54 = F54+F53;E55 = F55+F52;E56 = F56+F59;E57 = F57+F58;E58 = F57-F58;E59 = F56-F59;E60 = F63-F60;E61 = F62-F61;E62 = F62+F61;E63 = F63+F60;D0 = (724*(E0+E1)) >> 10;D1 = (724*(E0-E1)) >> 10;D2 = (392*E2-946*E3) >> 10;D3 = (946*E2+392*E3) >> 10;D4 = E4+E5;D5 = E4-E5;D6 = E7-E6;D7 = E7+E6;D8 = E8;D9 = (392*E14-946*E9) >> 10;D10 = (-946*E13-392*E10) >> 10;D11 = E11;D12 = E12;D13 = (392*E13-946*E10) >> 10;D14 = (946*E14+392*E9) >> 10;D15 = E15;D16 = E16+E19;D19 = E16-E19;D20 = E23-E20;D23 = E23+E20;D24 = E24+E27;D27 = E24-E27;D28 = E31-E28;D31 = E31+E28;D17 = E17+E18;D18 = E17-E18;D21 = E22-E21;D22 = E22+E21;D25 = E25+E26;D26 = E25-E26;D29 = E30-E29;D30 = E30+E29;D32 = E32;D33 = E33;D34 = (200*E61-1004*E34) >> 10;D35 = (200*E60-1004*E35) >> 10;D36 = (-1004*E59-200*E36) >> 10;D37 = (-1004*E58-200*E37) >> 10;D38 = E38;D39 = E39;D40 = E40;D41 = E41;D42 = (851*E53-569*E42) >> 10;D43 = (851*E52-569*E43) >> 10;D44 = (-569*E51-851*E44) >> 10;D45 = (-569*E50-851*E45) >> 10;D46 = E46;D47 = E47;D48 = E48;D49 = E49;D50 = (851*E50-569*E45) >> 10;D51 = (851*E51-569*E44) >> 10;D52 = (569*E52+851*E43) >> 10;D53 = (569*E53+851*E42) >> 10;D54 = E54;D55 = E55;D56 = E56;D57 = E57;D58 = (200*E58-1004*E37) >> 10;D59 = (200*E59-1004*E36) >> 10;D60 = (1004*E60+200*E35) >> 10;D61 = (1004*E61+200*E34) >> 10;D62 = E62;D63 = E63;C0 = D0+D3;C3 = D0-D3;C8 = D8+D11;C11 = D8-D11;C12 = D15-D12;C15 = D15+D12;C1 = D1+D2;C2 = D1-D2;C9 = D9+D10;C10 = D9-D10;C13 = D14-D13;C14 = D14+D13;C4 = D4;C5 = (724*(D6-D5)) >> 10;C6 = (724*(D6+D5)) >> 10;C7 = D7;C16 = D16;C18 = (392*D29-946*D18) >> 10;C20 = (-946*D27-392*D20) >> 10;C22 = D22;C24 = D24;C26 = (-946*D21+392*D26) >> 10;C28 = (392*D19+946*D28) >> 10;C30 = D30;C17 = D17;C19 = (392*D28-946*D19) >> 10;C21 = (-946*D26-392*D21) >> 10;C23 = D23;C25 = D25;C27 = (-946*D20+392*D27) >> 10;C29 = (392*D18+946*D29) >> 10;C31 = D31;C32 = D32+D39;C39 = D32-D39;C40 = D47-D40;C47 = D47+D40;C48 = D48+D55;C55 = D48-D55;C56 = D63-D56;C63 = D63+D56;C33 = D33+D38;C38 = D33-D38;C41 = D46-D41;C46 = D46+D41;C49 = D49+D54;C54 = D49-D54;C57 = D62-D57;C62 = D62+D57;C34 = D34+D37;C37 = D34-D37;C42 = D45-D42;C45 = D45+D42;C50 = D50+D53;C53 = D50-D53;C58 = D61-D58;C61 = D61+D58;C35 = D35+D36;C36 = D35-D36;C43 = D44-D43;C44 = D44+D43;C51 = D51+D52;C52 = D51-D52;C59 = D60-D59;C60 = D60+D59;B0 = C0+C7;B7 = C0-C7;B1 = C1+C6;B6 = C1-C6;B2 = C2+C5;B5 = C2-C5;B3 = C3+C4;B4 = C3-C4;B8 = C8;B14 = C14;B10 = (724*(C13-C10)) >> 10;B13 = (724*(C13+C10)) >> 10;B9 = C9;B15 = C15;B11 = (724*(C12-C11)) >> 10;B12 = (724*(C12+C11)) >> 10;B16 = C16+C23;B23 = C16-C23;B24 = C31-C24;B31 = C31+C24;B17 = C17+C22;B22 = C17-C22;B25 = C30-C25;B30 = C30+C25;B18 = C18+C21;B21 = C18-C21;B26 = C29-C26;B29 = C29+C26;B19 = C19+C20;B20 = C19-C20;B27 = C28-C27;B28 = C28+C27;B32 = C32;B36 = (392*C59-946*C36) >> 10;B40 = (-946*C55-392*C40) >> 10;B44 = C44;B48 = C48;B52 = (-946*C43+392*C52) >> 10;B56 = (392*C39+946*C56) >> 10;B60 = C60;B33 = C33;B37 = (392*C58-946*C37) >> 10;B41 = (-946*C54-392*C41) >> 10;B45 = C45;B49 = C49;B53 = (-946*C42+392*C53) >> 10;B57 = (392*C38+946*C57) >> 10;B61 = C61;B34 = C34;B38 = (392*C57-946*C38) >> 10;B42 = (-946*C53-392*C42) >> 10;B46 = C46;B50 = C50;B54 = (-946*C41+392*C54) >> 10;B58 = (392*C37+946*C58) >> 10;B62 = C62;B35 = C35;B39 = (392*C56-946*C39) >> 10;B43 = (-946*C52-392*C43) >> 10;B47 = C47;B51 = C51;B55 = (-946*C40+392*C55) >> 10;B59 = (392*C36+946*C59) >> 10;B63 = C63;A0 = B0+B15;A15 = B0-B15;A1 = B1+B14;A14 = B1-B14;A2 = B2+B13;A13 = B2-B13;A3 = B3+B12;A12 = B3-B12;A4 = B4+B11;A11 = B4-B11;A5 = B5+B10;A10 = B5-B10;A6 = B6+B9;A9 = B6-B9;A7 = B7+B8;A8 = B7-B8;A16 = B16;A28 = B28;A20 = (724*(B27-B20)) >> 10;A27 = (724*(B27+B20)) >> 10;A17 = B17;A29 = B29;A21 = (724*(B26-B21)) >> 10;A26 = (724*(B26+B21)) >> 10;A18 = B18;A30 = B30;A22 = (724*(B25-B22)) >> 10;A25 = (724*(B25+B22)) >> 10;A19 = B19;A31 = B31;A23 = (724*(B24-B23)) >> 10;A24 = (724*(B24+B23)) >> 10;A32 = B32+B47;A47 = B32-B47;A48 = B63-B48;A63 = B63+B48;A33 = B33+B46;A46 = B33-B46;A49 = B62-B49;A62 = B62+B49;A34 = B34+B45;A45 = B34-B45;A50 = B61-B50;A61 = B61+B50;A35 = B35+B44;A44 = B35-B44;A51 = B60-B51;A60 = B60+B51;A36 = B36+B43;A43 = B36-B43;A52 = B59-B52;A59 = B59+B52;A37 = B37+B42;A42 = B37-B42;A53 = B58-B53;A58 = B58+B53;A38 = B38+B41;A41 = B38-B41;A54 = B57-B54;A57 = B57+B54;A39 = B39+B40;A40 = B39-B40;A55 = B56-B55;A56 = B56+B55;O0 = A0+A31;O31 = A0-A31;O1 = A1+A30;O30 = A1-A30;O2 = A2+A29;O29 = A2-A29;O3 = A3+A28;O28 = A3-A28;O4 = A4+A27;O27 = A4-A27;O5 = A5+A26;O26 = A5-A26;O6 = A6+A25;O25 = A6-A25;O7 = A7+A24;O24 = A7-A24;O8 = A8+A23;O23 = A8-A23;O9 = A9+A22;O22 = A9-A22;O10 = A10+A21;O21 = A10-A21;O11 = A11+A20;O20 = A11-A20;O12 = A12+A19;O19 = A12-A19;O13 = A13+A18;O18 = A13-A18;O14 = A14+A17;O17 = A14-A17;O15 = A15+A16;O16 = A15-A16;O32 = A32;O56 = A56;O40 = (724*(A55-A40)) >> 10;O55 = (724*(A55+A40)) >> 10;O33 = A33;O57 = A57;O41 = (724*(A54-A41)) >> 10;O54 = (724*(A54+A41)) >> 10;O34 = A34;O58 = A58;O42 = (724*(A53-A42)) >> 10;O53 = (724*(A53+A42)) >> 10;O35 = A35;O59 = A59;O43 = (724*(A52-A43)) >> 10;O52 = (724*(A52+A43)) >> 10;O36 = A36;O60 = A60;O44 = (724*(A51-A44)) >> 10;O51 = (724*(A51+A44)) >> 10;O37 = A37;O61 = A61;O45 = (724*(A50-A45)) >> 10;O50 = (724*(A50+A45)) >> 10;O38 = A38;O62 = A62;O46 = (724*(A49-A46)) >> 10;O49 = (724*(A49+A46)) >> 10;O39 = A39;O63 = A63;O47 = (724*(A48-A47)) >> 10;O48 = (724*(A48+A47)) >> 10;Y0 = O0+O63;Y63 = O0-O63;Y1 = O1+O62;Y62 = O1-O62;Y2 = O2+O61;Y61 = O2-O61;Y3 = O3+O60;Y60 = O3-O60;Y4 = O4+O59;Y59 = O4-O59;Y5 = O5+O58;Y58 = O5-O58;Y6 = O6+O57;Y57 = O6-O57;Y7 = O7+O56;Y56 = O7-O56;Y8 = O8+O55;Y55 = O8-O55;Y9 = O9+O54;Y54 = O9-O54;Y10 = O10+O53;Y53 = O10-O53;Y11 = O11+O52;Y52 = O11-O52;Y12 = O12+O51;Y51 = O12-O51;Y13 = O13+O50;Y50 = O13-O50;Y14 = O14+O49;Y49 = O14-O49;Y15 = O15+O48;Y48 = O15-O48;Y16 = O16+O47;Y47 = O16-O47;Y17 = O17+O46;Y46 = O17-O46;Y18 = O18+O45;Y45 = O18-O45;Y19 = O19+O44;Y44 = O19-O44;Y20 = O20+O43;Y43 = O20-O43;Y21 = O21+O42;Y42 = O21-O42;Y22 = O22+O41;Y41 = O22-O41;Y23 = O23+O40;Y40 = O23-O40;Y24 = O24+O39;Y39 = O24-O39;Y25 = O25+O38;Y38 = O25-O38;Y26 = O26+O37;Y37 = O26-O37;Y27 = O27+O36;Y36 = O27-O36;Y28 = O28+O35;Y35 = O28-O35;Y29 = O29+O34;Y34 = O29-O34;Y30 = O30+O33;Y33 = O30-O33;Y31 = O31+O32;Y32 = O31-O32;
전술한 도 18의 우측에 도시된 변경된 버터플라이 구조의 실시예에 따라서 변환된 32x32 입력 블록에 대하여 1차원 이산 코사인 역변환을 수행하는 경우, X0 내지 X31은 역변환되어야 할 입력값, A0 내지 A31, B0 내지 B31, C0 내지 C31, D0 내지 D31, E0 내지 E31, F0 내지 F31, G0 내지 G31, H0 내지 H31은 중간값, t는 보조 변수, Y0 내지 Y31은 역변환된 값을 나타낸다고 할 때, 다음의 연산 과정과 같이 표현될 수 있다.
E0= X0;F24 = X1;F12 = -X2;G16 = -X3;E4 = X4; ;G31 = X5; ;F8 = X6; ;F26 = -X7;E2 = X8; ;F21 = X9; ;F15 = X10; ;G29 = X11;F5 = X12; ;G18 = -X13; ;E13 = X14; ;E22 = X15;E1 = X16; ;E25 = X17; ;E10 = X18; ;G19 = -X19;F7 = X20; ;G28 = -X21 ; ;F14 = X22; ;F20 = -X23;E3 = X24; ;F27 = -X25; ;F9 = X26; ;G30 = -X27;E6 = X28; ;G17 = -X29 ; ;F11 = X30; ;F23 = -X31;;t = (251*(G16 + G17) >> 8);F16 = t - ((201*G17) >> 8);F17 = t - ((301*G16) >> 8);t = (212*(G18 + G19) >> 8);F18 = t - ((70*G19) >> 8);F19 = t - ((355*G18) >> 8); ;t = ((212*(G28 + G29)) >> 8);F28 = t - ((70*G29) >> 8);F29 = t - ((355*G28) >> 8);t = (251*(G30 + G31) >> 8);F30 = t - ((201*G31) >> 8);F31 = t - ((301*G30) >> 8);E5 = ((F5 + F7)*181 >> 8);E7 = ((F5 - F7)*181 >> 8);t = (97*(F8 + F9) >> 8);E8 = t - ((-138*F9) >> 8);E9 = t - ((334*F8) >> 8);;E11 = ((F11 + F12)*181 >> 8);E12 = ((F11 - F12)*181 >> 8);t = (97*(F14 + F15) >> 8);E14 = t - ((-138*F15) >> 8);E15 = t - ((334*F14) >> 8);;E16 = F16 + F18;D18 = F16 - F18;D17 = F17 + F19;E19 = F17 - F19;;t = (236*(F20 + F21) >> 8);E20 = t - ((334*F21) >> 8);E21 = t - ((138*F20) >> 8);E23 = ((F23 + F24)*181 >> 8);E24 = ((F23 - F24)*181 >> 8);;t = (236*(F26 + F27) >> 8);E26 = t - ((334*F27) >> 8);E27 = t - ((138*F26) >> 8);;E28 = -F28 + F30;D30 = F28 + F30;D29 = -F29 + F31;E31 = F29 + F31;;D0 = ((E0 + E1)*181 >> 8);D1 = ((E0 - E1)*181 >> 8);t = (97*(E2 + E3) >> 8);D2 = t - ((334*E3) >> 8);D3 = t - ((-138*E2) >> 8);D4 = E4 + E5;D5 = E4 - E5;D6 = -E6 + E7;D7 = E6 + E7;D8 = E8 + E14;D14 = E8 - E14;D9 = E9 + E15;D15 = E9 - E15;D10 = E10 + E11; ;D11 = E10 - E11;D12 = E12 + E13;D13 = E12 - E13; ;;D16 = ((E16 + E19)*181 >> 8);D19 = ((E16 - E19)*181 >> 8);D20 = E20 + E26;D26 = E20 - E26;D21 = E21 + E27;D27 = E21 - E27;D22 = E22 + E23;D23 = E22 - E23;D24 = E24 + E25;D25 = E24 - E25;D28 = ((E28 + E31)*181 >> 8);D31 = ((E28 - E31)*181 >> 8);;C0 = D0 + D3;C3 = D0 - D3;C1 = D1 + D2;C2 = D1 - D2;t = (49*(D4 + D7) >> 8);C4 = t - ((301*D7) >> 8);C7 = t - ((-201*D4) >> 8);;t = (142*(D5 + D6) >> 8);C5 = t - ((355*D6) >> 8);C6 = t - ((-70*D5) >> 8);C8 = D8 + D11;C11 = D8 - D11;C9 = D9 + D10;C10 = D9 - D10;C12 = D12 + D15;C15 = D12 - D15;C13 = D13 + D14;C14 = D13 - D14;;C16 = D16 + D28;C28 = D16 - D28;C17 = D17 + D29;C29 = D17 - D29;C18 = D18 + D30;C30 = D18 - D30;C19 = D19 + D31;C31 = D19 - D31;C20 = D20 + D23;C23 = D20 - D23;C21 = D21 + D22;C22 = D21 - D22;C24 = D24 + D27;C27 = D24 - D27;C25 = D25 + D26;C26 = D25 - D26;;B0 = C0 + C7;B7 = C0 - C7;B1 = C1 + C6;B6 = C1 - C6;B2 = C2 + C5;B5 = C2 - C5;B3 = C3 + C4;B4 = C3 - C4;;t = (197*(C8 + C15) >> 8);B8 = t - ((360*C15) >> 8);B15 = t - ((35*C8) >> 8);t = (120*(C9 + C14) >> 8);B9 = t - ((-105*C14) >> 8);B14 = t - ((346*C9) >> 8);t = (244*(C10 + C13) >> 8);B10 = t - ((319*C13) >> 8);B13 = t - ((170*C10) >> 8);t = (25*(C11 + C12) >> 8);B11 = t - ((-229*C12) >> 8);B12 = t - ((279*C11) >> 8);B16 = C16 + C23;B23 = C16 - C23; ;B17 = C17 + C22;B22 = C17 - C22;B18 = C18 + C21;B21 = C18 - C21;B19 = C19 + C20;B20 = C19 - C20;B24 = C24 + C31;B31 = C24 - C31; ;B25 = C25 + C30;B30 = C25 - C30;B26 = C26 + C29;B29 = C26 - C29;B27 = C27 + C28;B28 = C27 - C28;A0 = B0 + B15;A1 = B1 + B14;A2 = B2 + B13;A3 = B3 + B12;A4 = B4 + B11;A5 = B5 + B10;A6 = B6 + B9;A7 = B7 + B8;A8 = B7 - B8;A9 = B6 - B9;A10 = B5 - B10;A11 = B4 - B11;A12 = B3 - B12;A13 = B2 - B13;A14 = B1 - B14;A15 = B0 - B15;;t = (171*(B16 + B31) >> 8);A16 = t - ((-17*B31) >> 8);A31 = t - ((361*B16) >> 8);t = (205*(B17 + B30) >> 8);A17 = t - ((358*B30) >> 8);A30 = t - ((53*B17) >> 8);t = (131*(B18 + B29) >> 8);A18 = t - ((-87*B29) >> 8);A29 = t - ((351*B18) >> 8);t = (231*(B19 + B28) >> 8);A19 = t - ((340*B28) >> 8);A28 = t - ((121*B19) >> 8);t = (86*(B20 + B27) >> 8);A20 = t - ((-154*B27) >> 8);A27 = t - ((327*B20) >> 8);t = (248*(B21 + B26) >> 8);A21 = t - ((310*B26) >> 8);A26 = t - ((186*B21) >> 8);t = (37*(B22 + B25) >> 8);A22 = t - ((-215*B25) >> 8);A25 = t - ((290*B22) >> 8);t = (255*(B23 + B24) >> 8);A23 = t - ((243*B24) >> 8);A24 = t - ((268*B23) >> 8);Y0 = A0 + A31;Y31 = A0 - A31;Y1 = A1 + A30;Y30 = A1 - A30;Y2 = A2 + A29;Y29 = A2 - A29;Y3 = A3 + A28;Y28 = A3 - A28;Y4 = A4 + A27;Y27 = A4 - A27;Y5 = A5 + A26;Y26 = A5 - A26;Y6 = A6 + A25;Y25 = A6 - A25;Y7 = A7 + A24;Y24 = A7 - A24;Y8 = A8 + A23;Y23 = A8 - A23;Y9 = A9 + A22;Y22 = A9 - A22;Y10 = A10 + A21;Y21 = A10 - A21;Y11 = A11 + A20;Y20 = A11 - A20;Y12 = A12 + A19;Y19 = A12 - A19;Y13 = A13 + A18;Y18 = A13 - A18;Y14 = A14 + A17;Y17 = A14 - A17;Y15 = A15 + A16;Y16 = A15 - A16 E0= X0; F24 = X1; F12 = -X2; G16 = -X3; E4 = X4; ; G31 = X5; ; F8 = X6; ; F26 = -X7; E2 = X8; ; F21 = X9; ; F15 = X10; ; G29 = X11; F5 = X12; ; G18 = -X13; ; E13 = X14; ; E22 = X15; E1 = X16; ; E25 = X17; ; E10 = X18; ; G19 = -X19; F7 = X20; ; G28 = -X21 ; ; F14 = X22; ; F20 = -X23; E3 = X24; ; F27 = -X25; ; F9 = X26; ; G30 = -X27; E6 = X28; ; G17 = -X29 ; ; F11 = X30; ; F23 = -X31; ; t = (251*(G16 + G17) >> 8); F16 = t - ((201*G17) >> 8); F17 = t - ((301*G16) >> 8); t = (212*(G18 + G19) >> 8); F18 = t - ((70*G19) >> 8); F19 = t - ((355*G18) >> 8); ; t = ((212*(G28 + G29)) >> 8); F28 = t - ((70*G29) >> 8); F29 = t - ((355*G28) >> 8); t = (251*(G30 + G31) >> 8); F30 = t - ((201*G31) >> 8); F31 = t - ((301*G30) >> 8); E5 = ((F5 + F7)*181 >> 8); E7 = ((F5 - F7)*181 >> 8); t = (97*(F8 + F9) >> 8); E8 = t - ((-138*F9) >> 8); E9 = t - ((334*F8) >> 8); ; E11 = ((F11 + F12)*181 >> 8); E12 = ((F11 - F12)*181 >> 8); t = (97*(F14 + F15) >> 8); E14 = t - ((-138*F15) >> 8); E15 = t - ((334*F14) >> 8); ; E16 = F16 + F18; D18 = F16 - F18; D17 = F17 + F19; E19 = F17 - F19;; t = (236*(F20 + F21) >> 8); E20 = t - ((334*F21) >> 8); E21 = t - ((138*F20) >> 8); E23 = ((F23 + F24)*181 >> 8); E24 = ((F23 - F24)*181 >> 8); ; t = (236*(F26 + F27) >> 8); E26 = t - ((334*F27) >> 8); E27 = t - ((138*F26) >> 8); ; E28 = -F28 + F30; D30 = F28 + F30; D29 = -F29 + F31; E31 = F29 + F31; ; D0 = ((E0 + E1)*181 >> 8); D1 = ((E0 - E1)*181 >> 8); t = (97*(E2 + E3) >> 8); D2 = t - ((334*E3) >> 8); D3 = t - ((-138*E2) >> 8); D4 = E4 + E5; D5 = E4 - E5; D6 = -E6 + E7; D7 = E6 + E7; D8 = E8 + E14; D14 = E8 - E14; D9 = E9 + E15; D15 = E9 - E15; D10 = E10 + E11; ; D11 = E10 - E11; D12 = E12 + E13; D13 = E12 - E13; ; ; D16 = ((E16 + E19)*181 >> 8); D19 = ((E16 - E19)*181 >> 8); D20 = E20 + E26; D26 = E20 - E26; D21 = E21 + E27; D27 = E21 - E27; D22 = E22 + E23; D23 = E22 - E23; D24 = E24 + E25; D25 = E24 - E25; D28 = ((E28 + E31)*181 >> 8); D31 = ((E28 - E31)*181 >> 8); ; C0 = D0 + D3; C3 = D0 - D3; C1 = D1 + D2; C2 = D1 - D2; t = (49*(D4 + D7) >> 8); C4 = t - ((301*D7) >> 8); C7 = t - ((-201*D4) >> 8); ; t = (142*(D5 + D6) >> 8); C5 = t - ((355*D6) >> 8); C6 = t - ((-70*D5) >> 8); C8 = D8 + D11; C11 = D8 - D11; C9 = D9 + D10; C10 = D9 - D10; C12 = D12 + D15; C15 = D12 - D15; C13 = D13 + D14; C14 = D13 - D14; ; C16 = D16 + D28; C28 = D16 - D28; C17 = D17 + D29; C29 = D17 - D29; C18 = D18 + D30; C30 = D18 - D30; C19 = D19 + D31; C31 = D19 - D31; C20 = D20 + D23; C23 = D20 - D23; C21 = D21 + D22; C22 = D21 - D22; C24 = D24 + D27; C27 = D24 - D27; C25 = D25 + D26; C26 = D25 - D26; ; B0 = C0 + C7; B7 = C0 - C7; B1 = C1 + C6; B6 = C1 - C6; B2 = C2 + C5; B5 = C2 - C5; B3 = C3 + C4; B4 = C3 - C4; ; t = (197*(C8 + C15) >> 8); B8 = t - ((360*C15) >> 8); B15 = t - ((35*C8) >> 8); t = (120*(C9 + C14) >> 8); B9 = t - ((-105*C14) >> 8); B14 = t - ((346*C9) >> 8); t = (244*(C10 + C13) >> 8); B10 = t - ((319*C13) >> 8); B13 = t - ((170*C10) >> 8); t = (25*(C11 + C12) >> 8); B11 = t - ((-229*C12) >> 8); B12 = t - ((279*C11) >> 8); B16 = C16 + C23; B23 = C16 - C23; ; B17 = C17 + C22; B22 = C17 - C22; B18 = C18 + C21; B21 = C18 - C21; B19 = C19 + C20; B20 = C19 - C20; B24 = C24 + C31; B31 = C24 - C31; ; B25 = C25 + C30; B30 = C25 - C30; B26 = C26 + C29; B29 = C26 - C29; B27 = C27 + C28; B28 = C27 - C28; A0 = B0 + B15; A1 = B1 + B14; A2 = B2 + B13; A3 = B3 + B12; A4 = B4 + B11; A5 = B5 + B10; A6 = B6 + B9; A7 = B7 + B8; A8 = B7 - B8; A9 = B6 - B9; A10 = B5 - B10; A11 = B4 - B11; A12 = B3 - B12; A13 = B2 - B13; A14 = B1 - B14; A15 = B0 - B15; ; t = (171*(B16 + B31) >> 8); A16 = t - ((-17*B31) >> 8); A31 = t - ((361*B16) >> 8); t = (205*(B17 + B30) >> 8); A17 = t - ((358*B30) >> 8); A30 = t - ((53*B17) >> 8); t = (131*(B18 + B29) >> 8); A18 = t - ((-87*B29) >> 8); A29 = t - ((351*B18) >> 8); t = (231*(B19 + B28) >> 8); A19 = t - ((340*B28) >> 8); A28 = t - ((121*B19) >> 8); t = (86*(B20 + B27) >> 8); A20 = t - ((-154*B27) >> 8); A27 = t - ((327*B20) >> 8); t = (248*(B21 + B26) >> 8); A21 = t - ((310*B26) >> 8); A26 = t - ((186*B21) >> 8); t = (37*(B22 + B25) >> 8); A22 = t - ((-215*B25) >> 8); A25 = t - ((290*B22) >> 8); t = (255*(B23 + B24) >> 8); A23 = t - ((243*B24) >> 8); A24 = t - ((268*B23) >> 8); Y0 = A0 + A31; Y31 = A0 - A31; Y1 = A1 + A30; Y30 = A1 - A30; Y2 = A2 + A29; Y29 = A2 - A29; Y3 = A3 + A28; Y28 = A3 - A28; Y4 = A4 + A27; Y27 = A4 - A27; Y5 = A5 + A26; Y26 = A5 - A26; Y6 = A6 + A25; Y25 = A6 - A25; Y7 = A7 + A24; Y24 = A7 - A24; Y8 = A8 + A23; Y23 = A8 - A23; Y9 = A9 + A22; Y22 = A9 - A22; Y10 = A10 + A21; Y21 = A10 - A21; Y11 = A11 + A20; Y20 = A11 - A20; Y12 = A12 + A19; Y19 = A12 - A19; Y13 = A13 + A18; Y18 = A13 - A18; Y14 = A14 + A17; Y17 = A14 - A17; Y15 = A15 + A16; Y16 = A15 - A16 E0= X0; F24 = X1; F12 = -X2; G16 = -X3; E4 = X4; ; G31 = X5; ; F8 = X6; ; F26 = -X7; E2 = X8; ; F21 = X9; ; F15 = X10; ; G29 = X11; F5 = X12; ; G18 = -X13; ; E13 = X14; ; E22 = X15; E1 = X16; ; E25 = X17; ; E10 = X18; ; G19 = -X19; F7 = X20; ; G28 = -X21 ; ; F14 = X22; ; F20 = -X23; E3 = X24; ; F27 = -X25; ; F9 = X26; ; G30 = -X27; E6 = X28; ; G17 = -X29 ; ; F11 = X30; ; F23 = -X31; ; t = (251*(G16 + G17) >> 8); F16 = t - ((201*G17) >> 8); F17 = t - ((301*G16) >> 8); t = (212*(G18 + G19) >> 8); F18 = t - ((70*G19) >> 8); F19 = t - ((355*G18) >> 8); ; t = ((212*(G28 + G29)) >> 8); F28 = t - ((70*G29) >> 8); F29 = t - ((355*G28) >> 8); t = (251*(G30 + G31) >> 8); F30 = t - ((201*G31) >> 8); F31 = t - ((301*G30) >> 8); E5 = ((F5 + F7)*181 >> 8); E7 = ((F5 - F7)*181 >> 8); t = (97*(F8 + F9) >> 8); E8 = t - ((-138*F9) >> 8); E9 = t - ((334*F8) >> 8); ; E11 = ((F11 + F12)*181 >> 8); E12 = ((F11 - F12)*181 >> 8); t = (97*(F14 + F15) >> 8); E14 = t - ((-138*F15) >> 8); E15 = t - ((334*F14) >> 8); ; E16 = F16 + F18; D18 = F16 - F18; D17 = F17 + F19; E19 = F17 - F19;; t = (236*(F20 + F21) >> 8); E20 = t - ((334*F21) >> 8); E21 = t - ((138*F20) >> 8); E23 = ((F23 + F24)*181 >> 8); E24 = ((F23 - F24)*181 >> 8); ; t = (236*(F26 + F27) >> 8); E26 = t - ((334*F27) >> 8); E27 = t - ((138*F26) >> 8); ; E28 = -F28 + F30; D30 = F28 + F30; D29 = -F29 + F31; E31 = F29 + F31; ; D0 = ((E0 + E1)*181 >> 8); D1 = ((E0 - E1)*181 >> 8); t = (97*(E2 + E3) >> 8); D2 = t - ((334*E3) >> 8); D3 = t - ((-138*E2) >> 8); D4 = E4 + E5; D5 = E4 - E5; D6 = -E6 + E7; D7 = E6 + E7; D8 = E8 + E14; D14 = E8 - E14; D9 = E9 + E15; D15 = E9 - E15; D10 = E10 + E11; ; D11 = E10 - E11; D12 = E12 + E13; D13 = E12 - E13; ; ; D16 = ((E16 + E19)*181 >> 8); D19 = ((E16 - E19)*181 >> 8); D20 = E20 + E26; D26 = E20 - E26; D21 = E21 + E27; D27 = E21 - E27; D22 = E22 + E23; D23 = E22 - E23; D24 = E24 + E25; D25 = E24 - E25; D28 = ((E28 + E31)*181 >> 8); D31 = ((E28 - E31)*181 >> 8); ; C0 = D0 + D3; C3 = D0 - D3; C1 = D1 + D2; C2 = D1 - D2; t = (49*(D4 + D7) >> 8); C4 = t - ((301*D7) >> 8); C7 = t - ((-201*D4) >> 8); ; t = (142*(D5 + D6) >> 8); C5 = t - ((355*D6) >> 8); C6 = t - ((-70*D5) >> 8); C8 = D8 + D11; C11 = D8 - D11; C9 = D9 + D10; C10 = D9 - D10; C12 = D12 + D15; C15 = D12 - D15; C13 = D13 + D14; C14 = D13 - D14; ; C16 = D16 + D28; C28 = D16 - D28; C17 = D17 + D29; C29 = D17 - D29; C18 = D18 + D30; C30 = D18 - D30; C19 = D19 + D31; C31 = D19 - D31; C20 = D20 + D23; C23 = D20 - D23; C21 = D21 + D22; C22 = D21 - D22; C24 = D24 + D27; C27 = D24 - D27; C25 = D25 + D26; C26 = D25 - D26; ; B0 = C0 + C7; B7 = C0 - C7; B1 = C1 + C6; B6 = C1 - C6; B2 = C2 + C5; B5 = C2 - C5; B3 = C3 + C4; B4 = C3 - C4; ; t = (197*(C8 + C15) >> 8); B8 = t - ((360*C15) >> 8); B15 = t - ((35*C8) >> 8); t = (120*(C9 + C14) >> 8); B9 = t - ((-105*C14) >> 8); B14 = t - ((346*C9) >> 8); t = (244*(C10 + C13) >> 8); B10 = t - ((319*C13) >> 8); B13 = t - ((170*C10) >> 8); t = (25*(C11 + C12) >> 8); B11 = t - ((-229*C12) >> 8); B12 = t - ((279*C11) >> 8); B16 = C16 + C23; B23 = C16 - C23; ; B17 = C17 + C22; B22 = C17 - C22; B18 = C18 + C21; B21 = C18 - C21; B19 = C19 + C20; B20 = C19 - C20; B24 = C24 + C31; B31 = C24 - C31; ; B25 = C25 + C30; B30 = C25 - C30; B26 = C26 + C29; B29 = C26 - C29; B27 = C27 + C28; B28 = C27 - C28; A0 = B0 + B15; A1 = B1 + B14; A2 = B2 + B13; A3 = B3 + B12; A4 = B4 + B11; A5 = B5 + B10; A6 = B6 + B9; A7 = B7 + B8; A8 = B7 - B8; A9 = B6 - B9; A10 = B5 - B10; A11 = B4 - B11; A12 = B3 - B12; A13 = B2 - B13; A14 = B1 - B14; A15 = B0 - B15; ; t = (171*(B16 + B31) >> 8); A16 = t - ((-17*B31) >> 8); A31 = t - ((361*B16) >> 8); t = (205*(B17 + B30) >> 8); A17 = t - ((358*B30) >> 8); A30 = t - ((53*B17) >> 8); t = (131*(B18 + B29) >> 8); A18 = t - ((-87*B29) >> 8); A29 = t - ((351*B18) >> 8); t = (231*(B19 + B28) >> 8); A19 = t - ((340*B28) >> 8); A28 = t - ((121*B19) >> 8); t = (86*(B20 + B27) >> 8); A20 = t - ((-154*B27) >> 8); A27 = t - ((327*B20) >> 8); t = (248*(B21 + B26) >> 8); A21 = t - ((310*B26) >> 8); A26 = t - ((186*B21) >> 8); t = (37*(B22 + B25) >> 8); A22 = t - ((-215*B25) >> 8); A25 = t - ((290*B22) >> 8); t = (255*(B23 + B24) >> 8); A23 = t - ((243*B24) >> 8); A24 = t - ((268*B23) >> 8); Y0 = A0 + A31; Y31 = A0 - A31; Y1 = A1 + A30; Y30 = A1 - A30; Y2 = A2 + A29; Y29 = A2 - A29; Y3 = A3 + A28; Y28 = A3 - A28; Y4 = A4 + A27; Y27 = A4 - A27; Y5 = A5 + A26; Y26 = A5 - A26; Y6 = A6 + A25; Y25 = A6 - A25; Y7 = A7 + A24; Y24 = A7 - A24; Y8 = A8 + A23; Y23 = A8 - A23; Y9 = A9 + A22; Y22 = A9 - A22; Y10 = A10 + A21; Y21 = A10 - A21; Y11 = A11 + A20; Y20 = A11 - A20; Y12 = A12 + A19; Y19 = A12 - A19; Y13 = A13 + A18; Y18 = A13 - A18; Y14 = A14 + A17; Y17 = A14 - A17; Y15 = A15 + A16; Y16 = A15 - A16 E0= X0; F24 = X1; F12 = -X2; G16 = -X3; E4 = X4; ; G31 = X5; ; F8 = X6; ; F26 = -X7; E2 = X8; ; F21 = X9; ; F15 = X10; ; G29 = X11; F5 = X12; ; G18 = -X13; ; E13 = X14; ; E22 = X15; E1 = X16; ; E25 = X17; ; E10 = X18; ; G19 = -X19; F7 = X20; ; G28 = -X21 ; ; F14 = X22; ; F20 = -X23; E3 = X24; ; F27 = -X25; ; F9 = X26; ; G30 = -X27; E6 = X28; ; G17 = -X29 ; ; F11 = X30; ; F23 = -X31; ; t = (251*(G16 + G17) >> 8); F16 = t - ((201*G17) >> 8); F17 = t - ((301*G16) >> 8); t = (212*(G18 + G19) >> 8); F18 = t - ((70*G19) >> 8); F19 = t - ((355*G18) >> 8); ; t = ((212*(G28 + G29)) >> 8); F28 = t - ((70*G29) >> 8); F29 = t - ((355*G28) >> 8); t = (251*(G30 + G31) >> 8); F30 = t - ((201*G31) >> 8); F31 = t - ((301*G30) >> 8); E5 = ((F5 + F7)*181 >> 8); E7 = ((F5 - F7)*181 >> 8); t = (97*(F8 + F9) >> 8); E8 = t - ((-138*F9) >> 8); E9 = t - ((334*F8) >> 8); ; E11 = ((F11 + F12)*181 >> 8); E12 = ((F11 - F12)*181 >> 8); t = (97*(F14 + F15) >> 8); E14 = t - ((-138*F15) >> 8); E15 = t - ((334*F14) >> 8); ; E16 = F16 + F18; D18 = F16 - F18; D17 = F17 + F19; E19 = F17 - F19;; t = (236*(F20 + F21) >> 8); E20 = t - ((334*F21) >> 8); E21 = t - ((138*F20) >> 8); E23 = ((F23 + F24)*181 >> 8); E24 = ((F23 - F24)*181 >> 8); ; t = (236*(F26 + F27) >> 8); E26 = t - ((334*F27) >> 8); E27 = t - ((138*F26) >> 8); ; E28 = -F28 + F30; D30 = F28 + F30; D29 = -F29 + F31; E31 = F29 + F31; ; D0 = ((E0 + E1)*181 >> 8); D1 = ((E0 - E1)*181 >> 8); t = (97*(E2 + E3) >> 8); D2 = t - ((334*E3) >> 8); D3 = t - ((-138*E2) >> 8); D4 = E4 + E5; D5 = E4 - E5; D6 = -E6 + E7; D7 = E6 + E7; D8 = E8 + E14; D14 = E8 - E14; D9 = E9 + E15; D15 = E9 - E15; D10 = E10 + E11; ; D11 = E10 - E11; D12 = E12 + E13; D13 = E12 - E13; ; ; D16 = ((E16 + E19)*181 >> 8); D19 = ((E16 - E19)*181 >> 8); D20 = E20 + E26; D26 = E20 - E26; D21 = E21 + E27; D27 = E21 - E27; D22 = E22 + E23; D23 = E22 - E23; D24 = E24 + E25; D25 = E24 - E25; D28 = ((E28 + E31)*181 >> 8); D31 = ((E28 - E31)*181 >> 8); ; C0 = D0 + D3; C3 = D0 - D3; C1 = D1 + D2; C2 = D1 - D2; t = (49*(D4 + D7) >> 8); C4 = t - ((301*D7) >> 8); C7 = t - ((-201*D4) >> 8); ; t = (142*(D5 + D6) >> 8); C5 = t - ((355*D6) >> 8); C6 = t - ((-70*D5) >> 8); C8 = D8 + D11; C11 = D8 - D11; C9 = D9 + D10; C10 = D9 - D10; C12 = D12 + D15; C15 = D12 - D15; C13 = D13 + D14; C14 = D13 - D14; ; C16 = D16 + D28; C28 = D16 - D28; C17 = D17 + D29; C29 = D17 - D29; C18 = D18 + D30; C30 = D18 - D30; C19 = D19 + D31; C31 = D19 - D31; C20 = D20 + D23; C23 = D20 - D23; C21 = D21 + D22; C22 = D21 - D22; C24 = D24 + D27; C27 = D24 - D27; C25 = D25 + D26; C26 = D25 - D26; ; B0 = C0 + C7; B7 = C0 - C7; B1 = C1 + C6; B6 = C1 - C6; B2 = C2 + C5; B5 = C2 - C5; B3 = C3 + C4; B4 = C3 - C4; ; t = (197*(C8 + C15) >> 8); B8 = t - ((360*C15) >> 8); B15 = t - ((35*C8) >> 8); t = (120*(C9 + C14) >> 8); B9 = t - ((-105*C14) >> 8); B14 = t - ((346*C9) >> 8); t = (244*(C10 + C13) >> 8); B10 = t - ((319*C13) >> 8); B13 = t - ((170*C10) >> 8); t = (25*(C11 + C12) >> 8); B11 = t - ((-229*C12) >> 8); B12 = t - ((279*C11) >> 8); B16 = C16 + C23; B23 = C16 - C23; ; B17 = C17 + C22; B22 = C17 - C22; B18 = C18 + C21; B21 = C18 - C21; B19 = C19 + C20; B20 = C19 - C20; B24 = C24 + C31; B31 = C24 - C31; ; B25 = C25 + C30; B30 = C25 - C30; B26 = C26 + C29; B29 = C26 - C29; B27 = C27 + C28; B28 = C27 - C28; A0 = B0 + B15; A1 = B1 + B14; A2 = B2 + B13; A3 = B3 + B12; A4 = B4 + B11; A5 = B5 + B10; A6 = B6 + B9; A7 = B7 + B8; A8 = B7 - B8; A9 = B6 - B9; A10 = B5 - B10; A11 = B4 - B11; A12 = B3 - B12; A13 = B2 - B13; A14 = B1 - B14; A15 = B0 - B15; ; t = (171*(B16 + B31) >> 8); A16 = t - ((-17*B31) >> 8); A31 = t - ((361*B16) >> 8); t = (205*(B17 + B30) >> 8); A17 = t - ((358*B30) >> 8); A30 = t - ((53*B17) >> 8); t = (131*(B18 + B29) >> 8); A18 = t - ((-87*B29) >> 8); A29 = t - ((351*B18) >> 8); t = (231*(B19 + B28) >> 8); A19 = t - ((340*B28) >> 8); A28 = t - ((121*B19) >> 8); t = (86*(B20 + B27) >> 8); A20 = t - ((-154*B27) >> 8); A27 = t - ((327*B20) >> 8); t = (248*(B21 + B26) >> 8); A21 = t - ((310*B26) >> 8); A26 = t - ((186*B21) >> 8); t = (37*(B22 + B25) >> 8); A22 = t - ((-215*B25) >> 8); A25 = t - ((290*B22) >> 8); t = (255*(B23 + B24) >> 8); A23 = t - ((243*B24) >> 8); A24 = t - ((268*B23) >> 8); Y0 = A0 + A31; Y31 = A0 - A31; Y1 = A1 + A30; Y30 = A1 - A30; Y2 = A2 + A29; Y29 = A2 - A29; Y3 = A3 + A28; Y28 = A3 - A28; Y4 = A4 + A27; Y27 = A4 - A27; Y5 = A5 + A26; Y26 = A5 - A26; Y6 = A6 + A25; Y25 = A6 - A25; Y7 = A7 + A24; Y24 = A7 - A24; Y8 = A8 + A23; Y23 = A8 - A23; Y9 = A9 + A22; Y22 = A9 - A22; Y10 = A10 + A21; Y21 = A10 - A21; Y11 = A11 + A20; Y20 = A11 - A20; Y12 = A12 + A19; Y19 = A12 - A19; Y13 = A13 + A18; Y18 = A13 - A18; Y14 = A14 + A17; Y17 = A14 - A17; Y15 = A15 + A16; Y16 = A15 - A16 E0= X0; F24 = X1; F12 = -X2; G16 = -X3; E4 = X4; ; G31 = X5; ; F8 = X6; ; F26 = -X7; E2 = X8; ; F21 = X9; ; F15 = X10; ; G29 = X11; F5 = X12; ; G18 = -X13; ; E13 = X14; ; E22 = X15; E1 = X16; ; E25 = X17; ; E10 = X18; ; G19 = -X19; F7 = X20; ; G28 = -X21 ; ; F14 = X22; ; F20 = -X23; E3 = X24; ; F27 = -X25; ; F9 = X26; ; G30 = -X27; E6 = X28; ; G17 = -X29 ; ; F11 = X30; ; F23 = -X31; ; t = (251*(G16 + G17) >> 8); F16 = t - ((201*G17) >> 8); F17 = t - ((301*G16) >> 8); t = (212*(G18 + G19) >> 8); F18 = t - ((70*G19) >> 8); F19 = t - ((355*G18) >> 8); ; t = ((212*(G28 + G29)) >> 8); F28 = t - ((70*G29) >> 8); F29 = t - ((355*G28) >> 8); t = (251*(G30 + G31) >> 8); F30 = t - ((201*G31) >> 8); F31 = t - ((301*G30) >> 8); E5 = ((F5 + F7)*181 >> 8); E7 = ((F5 - F7)*181 >> 8); t = (97*(F8 + F9) >> 8); E8 = t - ((-138*F9) >> 8); E9 = t - ((334*F8) >> 8); ; E11 = ((F11 + F12)*181 >> 8); E12 = ((F11 - F12)*181 >> 8); t = (97*(F14 + F15) >> 8); E14 = t - ((-138*F15) >> 8); E15 = t - ((334*F14) >> 8); ; E16 = F16 + F18; D18 = F16 - F18; D17 = F17 + F19; E19 = F17 - F19;; t = (236*(F20 + F21) >> 8); E20 = t - ((334*F21) >> 8); E21 = t - ((138*F20) >> 8); E23 = ((F23 + F24)*181 >> 8); E24 = ((F23 - F24)*181 >> 8); ; t = (236*(F26 + F27) >> 8); E26 = t - ((334*F27) >> 8); E27 = t - ((138*F26) >> 8); ; E28 = -F28 + F30; D30 = F28 + F30; D29 = -F29 + F31; E31 = F29 + F31; ; D0 = ((E0 + E1)*181 >> 8); D1 = ((E0 - E1)*181 >> 8); t = (97*(E2 + E3) >> 8); D2 = t - ((334*E3) >> 8); D3 = t - ((-138*E2) >> 8); D4 = E4 + E5; D5 = E4 - E5; D6 = -E6 + E7; D7 = E6 + E7; D8 = E8 + E14; D14 = E8 - E14; D9 = E9 + E15; D15 = E9 - E15; D10 = E10 + E11; ; D11 = E10 - E11; D12 = E12 + E13; D13 = E12 - E13; ; ; D16 = ((E16 + E19)*181 >> 8); D19 = ((E16 - E19)*181 >> 8); D20 = E20 + E26; D26 = E20 - E26; D21 = E21 + E27; D27 = E21 - E27; D22 = E22 + E23; D23 = E22 - E23; D24 = E24 + E25; D25 = E24 - E25; D28 = ((E28 + E31)*181 >> 8); D31 = ((E28 - E31)*181 >> 8); ; C0 = D0 + D3; C3 = D0 - D3; C1 = D1 + D2; C2 = D1 - D2; t = (49*(D4 + D7) >> 8); C4 = t - ((301*D7) >> 8); C7 = t - ((-201*D4) >> 8); ; t = (142*(D5 + D6) >> 8); C5 = t - ((355*D6) >> 8); C6 = t - ((-70*D5) >> 8); C8 = D8 + D11; C11 = D8 - D11; C9 = D9 + D10; C10 = D9 - D10; C12 = D12 + D15; C15 = D12 - D15; C13 = D13 + D14; C14 = D13 - D14; ; C16 = D16 + D28; C28 = D16 - D28; C17 = D17 + D29; C29 = D17 - D29; C18 = D18 + D30; C30 = D18 - D30; C19 = D19 + D31; C31 = D19 - D31; C20 = D20 + D23; C23 = D20 - D23; C21 = D21 + D22; C22 = D21 - D22; C24 = D24 + D27; C27 = D24 - D27; C25 = D25 + D26; C26 = D25 - D26; ; B0 = C0 + C7; B7 = C0 - C7; B1 = C1 + C6; B6 = C1 - C6; B2 = C2 + C5; B5 = C2 - C5; B3 = C3 + C4; B4 = C3 - C4; ; t = (197*(C8 + C15) >> 8); B8 = t - ((360*C15) >> 8); B15 = t - ((35*C8) >> 8); t = (120*(C9 + C14) >> 8); B9 = t - ((-105*C14) >> 8); B14 = t - ((346*C9) >> 8); t = (244*(C10 + C13) >> 8); B10 = t - ((319*C13) >> 8); B13 = t - ((170*C10) >> 8); t = (25*(C11 + C12) >> 8); B11 = t - ((-229*C12) >> 8); B12 = t - ((279*C11) >> 8); B16 = C16 + C23; B23 = C16 - C23; ; B17 = C17 + C22; B22 = C17 - C22; B18 = C18 + C21; B21 = C18 - C21; B19 = C19 + C20; B20 = C19 - C20; B24 = C24 + C31; B31 = C24 - C31; ; B25 = C25 + C30; B30 = C25 - C30; B26 = C26 + C29; B29 = C26 - C29; B27 = C27 + C28; B28 = C27 - C28; A0 = B0 + B15; A1 = B1 + B14; A2 = B2 + B13; A3 = B3 + B12; A4 = B4 + B11; A5 = B5 + B10; A6 = B6 + B9; A7 = B7 + B8; A8 = B7 - B8; A9 = B6 - B9; A10 = B5 - B10; A11 = B4 - B11; A12 = B3 - B12; A13 = B2 - B13; A14 = B1 - B14; A15 = B0 - B15; ; t = (171*(B16 + B31) >> 8); A16 = t - ((-17*B31) >> 8); A31 = t - ((361*B16) >> 8); t = (205*(B17 + B30) >> 8); A17 = t - ((358*B30) >> 8); A30 = t - ((53*B17) >> 8); t = (131*(B18 + B29) >> 8); A18 = t - ((-87*B29) >> 8); A29 = t - ((351*B18) >> 8); t = (231*(B19 + B28) >> 8); A19 = t - ((340*B28) >> 8); A28 = t - ((121*B19) >> 8); t = (86*(B20 + B27) >> 8); A20 = t - ((-154*B27) >> 8); A27 = t - ((327*B20) >> 8); t = (248*(B21 + B26) >> 8); A21 = t - ((310*B26) >> 8); A26 = t - ((186*B21) >> 8); t = (37*(B22 + B25) >> 8); A22 = t - ((-215*B25) >> 8); A25 = t - ((290*B22) >> 8); t = (255*(B23 + B24) >> 8); A23 = t - ((243*B24) >> 8); A24 = t - ((268*B23) >> 8); Y0 = A0 + A31; Y31 = A0 - A31; Y1 = A1 + A30; Y30 = A1 - A30; Y2 = A2 + A29; Y29 = A2 - A29; Y3 = A3 + A28; Y28 = A3 - A28; Y4 = A4 + A27; Y27 = A4 - A27; Y5 = A5 + A26; Y26 = A5 - A26; Y6 = A6 + A25; Y25 = A6 - A25; Y7 = A7 + A24; Y24 = A7 - A24; Y8 = A8 + A23; Y23 = A8 - A23; Y9 = A9 + A22; Y22 = A9 - A22; Y10 = A10 + A21; Y21 = A10 - A21; Y11 = A11 + A20; Y20 = A11 - A20; Y12 = A12 + A19; Y19 = A12 - A19; Y13 = A13 + A18; Y18 = A13 - A18; Y14 = A14 + A17; Y17 = A14 - A17; Y15 = A15 + A16; Y16 = A15 - A16 E0= X0; F24 = X1; F12 = -X2; G16 = -X3; E4 = X4; ; G31 = X5; ; F8 = X6; ; F26 = -X7; E2 = X8; ; F21 = X9; ; F15 = X10; ; G29 = X11; F5 = X12; ; G18 = -X13; ; E13 = X14; ; E22 = X15; E1 = X16; ; E25 = X17; ; E10 = X18; ; G19 = -X19; F7 = X20; ; G28 = -X21 ; ; F14 = X22; ; F20 = -X23; E3 = X24; ; F27 = -X25; ; F9 = X26; ; G30 = -X27; E6 = X28; ; G17 = -X29 ; ; F11 = X30; ; F23 = -X31; ; t = (251*(G16 + G17) >> 8); F16 = t - ((201*G17) >> 8); F17 = t - ((301*G16) >> 8); t = (212*(G18 + G19) >> 8); F18 = t - ((70*G19) >> 8); F19 = t - ((355*G18) >> 8); ; t = ((212*(G28 + G29)) >> 8); F28 = t - ((70*G29) >> 8); F29 = t - ((355*G28) >> 8); t = (251*(G30 + G31) >> 8); F30 = t - ((201*G31) >> 8); F31 = t - ((301*G30) >> 8); E5 = ((F5 + F7)*181 >> 8); E7 = ((F5 - F7)*181 >> 8); t = (97*(F8 + F9) >> 8); E8 = t - ((-138*F9) >> 8); E9 = t - ((334*F8) >> 8); ; E11 = ((F11 + F12)*181 >> 8); E12 = ((F11 - F12)*181 >> 8); t = (97*(F14 + F15) >> 8); E14 = t - ((-138*F15) >> 8); E15 = t - ((334*F14) >> 8); ; E16 = F16 + F18; D18 = F16 - F18; D17 = F17 + F19; E19 = F17 - F19;; t = (236*(F20 + F21) >> 8); E20 = t - ((334*F21) >> 8); E21 = t - ((138*F20) >> 8); E23 = ((F23 + F24)*181 >> 8); E24 = ((F23 - F24)*181 >> 8); ; t = (236*(F26 + F27) >> 8); E26 = t - ((334*F27) >> 8); E27 = t - ((138*F26) >> 8); ; E28 = -F28 + F30; D30 = F28 + F30; D29 = -F29 + F31; E31 = F29 + F31; ; D0 = ((E0 + E1)*181 >> 8); D1 = ((E0 - E1)*181 >> 8); t = (97*(E2 + E3) >> 8); D2 = t - ((334*E3) >> 8); D3 = t - ((-138*E2) >> 8); D4 = E4 + E5; D5 = E4 - E5; D6 = -E6 + E7; D7 = E6 + E7; D8 = E8 + E14; D14 = E8 - E14; D9 = E9 + E15; D15 = E9 - E15; D10 = E10 + E11; ; D11 = E10 - E11; D12 = E12 + E13; D13 = E12 - E13; ; ; D16 = ((E16 + E19)*181 >> 8); D19 = ((E16 - E19)*181 >> 8); D20 = E20 + E26; D26 = E20 - E26; D21 = E21 + E27; D27 = E21 - E27; D22 = E22 + E23; D23 = E22 - E23; D24 = E24 + E25; D25 = E24 - E25; D28 = ((E28 + E31)*181 >> 8); D31 = ((E28 - E31)*181 >> 8); ; C0 = D0 + D3; C3 = D0 - D3; C1 = D1 + D2; C2 = D1 - D2; t = (49*(D4 + D7) >> 8); C4 = t - ((301*D7) >> 8); C7 = t - ((-201*D4) >> 8); ; t = (142*(D5 + D6) >> 8); C5 = t - ((355*D6) >> 8); C6 = t - ((-70*D5) >> 8); C8 = D8 + D11; C11 = D8 - D11; C9 = D9 + D10; C10 = D9 - D10; C12 = D12 + D15; C15 = D12 - D15; C13 = D13 + D14; C14 = D13 - D14; ; C16 = D16 + D28; C28 = D16 - D28; C17 = D17 + D29; C29 = D17 - D29; C18 = D18 + D30; C30 = D18 - D30; C19 = D19 + D31; C31 = D19 - D31; C20 = D20 + D23; C23 = D20 - D23; C21 = D21 + D22; C22 = D21 - D22; C24 = D24 + D27; C27 = D24 - D27; C25 = D25 + D26; C26 = D25 - D26; ; B0 = C0 + C7; B7 = C0 - C7; B1 = C1 + C6; B6 = C1 - C6; B2 = C2 + C5; B5 = C2 - C5; B3 = C3 + C4; B4 = C3 - C4; ; t = (197*(C8 + C15) >> 8); B8 = t - ((360*C15) >> 8); B15 = t - ((35*C8) >> 8); t = (120*(C9 + C14) >> 8); B9 = t - ((-105*C14) >> 8); B14 = t - ((346*C9) >> 8); t = (244*(C10 + C13) >> 8); B10 = t - ((319*C13) >> 8); B13 = t - ((170*C10) >> 8); t = (25*(C11 + C12) >> 8); B11 = t - ((-229*C12) >> 8); B12 = t - ((279*C11) >> 8); B16 = C16 + C23; B23 = C16 - C23; ; B17 = C17 + C22; B22 = C17 - C22; B18 = C18 + C21; B21 = C18 - C21; B19 = C19 + C20; B20 = C19 - C20; B24 = C24 + C31; B31 = C24 - C31; ; B25 = C25 + C30; B30 = C25 - C30; B26 = C26 + C29; B29 = C26 - C29; B27 = C27 + C28; B28 = C27 - C28; A0 = B0 + B15; A1 = B1 + B14; A2 = B2 + B13; A3 = B3 + B12; A4 = B4 + B11; A5 = B5 + B10; A6 = B6 + B9; A7 = B7 + B8; A8 = B7 - B8; A9 = B6 - B9; A10 = B5 - B10; A11 = B4 - B11; A12 = B3 - B12; A13 = B2 - B13; A14 = B1 - B14; A15 = B0 - B15; ; t = (171*(B16 + B31) >> 8); A16 = t - ((-17*B31) >> 8); A31 = t - ((361*B16) >> 8); t = (205*(B17 + B30) >> 8); A17 = t - ((358*B30) >> 8); A30 = t - ((53*B17) >> 8); t = (131*(B18 + B29) >> 8); A18 = t - ((-87*B29) >> 8); A29 = t - ((351*B18) >> 8); t = (231*(B19 + B28) >> 8); A19 = t - ((340*B28) >> 8); A28 = t - ((121*B19) >> 8); t = (86*(B20 + B27) >> 8); A20 = t - ((-154*B27) >> 8); A27 = t - ((327*B20) >> 8); t = (248*(B21 + B26) >> 8); A21 = t - ((310*B26) >> 8); A26 = t - ((186*B21) >> 8); t = (37*(B22 + B25) >> 8); A22 = t - ((-215*B25) >> 8); A25 = t - ((290*B22) >> 8); t = (255*(B23 + B24) >> 8); A23 = t - ((243*B24) >> 8); A24 = t - ((268*B23) >> 8); Y0 = A0 + A31; Y31 = A0 - A31; Y1 = A1 + A30; Y30 = A1 - A30; Y2 = A2 + A29; Y29 = A2 - A29; Y3 = A3 + A28; Y28 = A3 - A28; Y4 = A4 + A27; Y27 = A4 - A27; Y5 = A5 + A26; Y26 = A5 - A26; Y6 = A6 + A25; Y25 = A6 - A25; Y7 = A7 + A24; Y24 = A7 - A24; Y8 = A8 + A23; Y23 = A8 - A23; Y9 = A9 + A22; Y22 = A9 - A22; Y10 = A10 + A21; Y21 = A10 - A21; Y11 = A11 + A20; Y20 = A11 - A20; Y12 = A12 + A19; Y19 = A12 - A19; Y13 = A13 + A18; Y18 = A13 - A18; Y14 = A14 + A17; Y17 = A14 - A17; Y15 = A15 + A16; Y16 = A15 - A16 E0= X0; F24 = X1; F12 = -X2; G16 = -X3; E4 = X4; ; G31 = X5; ; F8 = X6; ; F26 = -X7; E2 = X8; ; F21 = X9; ; F15 = X10; ; G29 = X11; F5 = X12; ; G18 = -X13; ; E13 = X14; ; E22 = X15; E1 = X16; ; E25 = X17; ; E10 = X18; ; G19 = -X19; F7 = X20; ; G28 = -X21 ; ; F14 = X22; ; F20 = -X23; E3 = X24; ; F27 = -X25; ; F9 = X26; ; G30 = -X27; E6 = X28; ; G17 = -X29 ; ; F11 = X30; ; F23 = -X31; ; t = (251*(G16 + G17) >> 8); F16 = t - ((201*G17) >> 8); F17 = t - ((301*G16) >> 8); t = (212*(G18 + G19) >> 8); F18 = t - ((70*G19) >> 8); F19 = t - ((355*G18) >> 8); ; t = ((212*(G28 + G29)) >> 8); F28 = t - ((70*G29) >> 8); F29 = t - ((355*G28) >> 8); t = (251*(G30 + G31) >> 8); F30 = t - ((201*G31) >> 8); F31 = t - ((301*G30) >> 8); E5 = ((F5 + F7)*181 >> 8); E7 = ((F5 - F7)*181 >> 8); t = (97*(F8 + F9) >> 8); E8 = t - ((-138*F9) >> 8); E9 = t - ((334*F8) >> 8); ; E11 = ((F11 + F12)*181 >> 8); E12 = ((F11 - F12)*181 >> 8); t = (97*(F14 + F15) >> 8); E14 = t - ((-138*F15) >> 8); E15 = t - ((334*F14) >> 8); ; E16 = F16 + F18; D18 = F16 - F18; D17 = F17 + F19; E19 = F17 - F19;; t = (236*(F20 + F21) >> 8); E20 = t - ((334*F21) >> 8); E21 = t - ((138*F20) >> 8); E23 = ((F23 + F24)*181 >> 8); E24 = ((F23 - F24)*181 >> 8); ; t = (236*(F26 + F27) >> 8); E26 = t - ((334*F27) >> 8); E27 = t - ((138*F26) >> 8); ; E28 = -F28 + F30; D30 = F28 + F30; D29 = -F29 + F31; E31 = F29 + F31; ; D0 = ((E0 + E1)*181 >> 8); D1 = ((E0 - E1)*181 >> 8); t = (97*(E2 + E3) >> 8); D2 = t - ((334*E3) >> 8); D3 = t - ((-138*E2) >> 8); D4 = E4 + E5; D5 = E4 - E5; D6 = -E6 + E7; D7 = E6 + E7; D8 = E8 + E14; D14 = E8 - E14; D9 = E9 + E15; D15 = E9 - E15; D10 = E10 + E11; ; D11 = E10 - E11; D12 = E12 + E13; D13 = E12 - E13; ; ; D16 = ((E16 + E19)*181 >> 8); D19 = ((E16 - E19)*181 >> 8); D20 = E20 + E26; D26 = E20 - E26; D21 = E21 + E27; D27 = E21 - E27; D22 = E22 + E23; D23 = E22 - E23; D24 = E24 + E25; D25 = E24 - E25; D28 = ((E28 + E31)*181 >> 8); D31 = ((E28 - E31)*181 >> 8); ; C0 = D0 + D3; C3 = D0 - D3; C1 = D1 + D2; C2 = D1 - D2; t = (49*(D4 + D7) >> 8); C4 = t - ((301*D7) >> 8); C7 = t - ((-201*D4) >> 8); ; t = (142*(D5 + D6) >> 8); C5 = t - ((355*D6) >> 8); C6 = t - ((-70*D5) >> 8); C8 = D8 + D11; C11 = D8 - D11; C9 = D9 + D10; C10 = D9 - D10; C12 = D12 + D15; C15 = D12 - D15; C13 = D13 + D14; C14 = D13 - D14; ; C16 = D16 + D28; C28 = D16 - D28; C17 = D17 + D29; C29 = D17 - D29; C18 = D18 + D30; C30 = D18 - D30; C19 = D19 + D31; C31 = D19 - D31; C20 = D20 + D23; C23 = D20 - D23; C21 = D21 + D22; C22 = D21 - D22; C24 = D24 + D27; C27 = D24 - D27; C25 = D25 + D26; C26 = D25 - D26; ; B0 = C0 + C7; B7 = C0 - C7; B1 = C1 + C6; B6 = C1 - C6; B2 = C2 + C5; B5 = C2 - C5; B3 = C3 + C4; B4 = C3 - C4; ; t = (197*(C8 + C15) >> 8); B8 = t - ((360*C15) >> 8); B15 = t - ((35*C8) >> 8); t = (120*(C9 + C14) >> 8); B9 = t - ((-105*C14) >> 8); B14 = t - ((346*C9) >> 8); t = (244*(C10 + C13) >> 8); B10 = t - ((319*C13) >> 8); B13 = t - ((170*C10) >> 8); t = (25*(C11 + C12) >> 8); B11 = t - ((-229*C12) >> 8); B12 = t - ((279*C11) >> 8); B16 = C16 + C23; B23 = C16 - C23; ; B17 = C17 + C22; B22 = C17 - C22; B18 = C18 + C21; B21 = C18 - C21; B19 = C19 + C20; B20 = C19 - C20; B24 = C24 + C31; B31 = C24 - C31; ; B25 = C25 + C30; B30 = C25 - C30; B26 = C26 + C29; B29 = C26 - C29; B27 = C27 + C28; B28 = C27 - C28; A0 = B0 + B15; A1 = B1 + B14; A2 = B2 + B13; A3 = B3 + B12; A4 = B4 + B11; A5 = B5 + B10; A6 = B6 + B9; A7 = B7 + B8; A8 = B7 - B8; A9 = B6 - B9; A10 = B5 - B10; A11 = B4 - B11; A12 = B3 - B12; A13 = B2 - B13; A14 = B1 - B14; A15 = B0 - B15; ; t = (171*(B16 + B31) >> 8); A16 = t - ((-17*B31) >> 8); A31 = t - ((361*B16) >> 8); t = (205*(B17 + B30) >> 8); A17 = t - ((358*B30) >> 8); A30 = t - ((53*B17) >> 8); t = (131*(B18 + B29) >> 8); A18 = t - ((-87*B29) >> 8); A29 = t - ((351*B18) >> 8); t = (231*(B19 + B28) >> 8); A19 = t - ((340*B28) >> 8); A28 = t - ((121*B19) >> 8); t = (86*(B20 + B27) >> 8); A20 = t - ((-154*B27) >> 8); A27 = t - ((327*B20) >> 8); t = (248*(B21 + B26) >> 8); A21 = t - ((310*B26) >> 8); A26 = t - ((186*B21) >> 8); t = (37*(B22 + B25) >> 8); A22 = t - ((-215*B25) >> 8); A25 = t - ((290*B22) >> 8); t = (255*(B23 + B24) >> 8); A23 = t - ((243*B24) >> 8); A24 = t - ((268*B23) >> 8); Y0 = A0 + A31; Y31 = A0 - A31; Y1 = A1 + A30; Y30 = A1 - A30; Y2 = A2 + A29; Y29 = A2 - A29; Y3 = A3 + A28; Y28 = A3 - A28; Y4 = A4 + A27; Y27 = A4 - A27; Y5 = A5 + A26; Y26 = A5 - A26; Y6 = A6 + A25; Y25 = A6 - A25; Y7 = A7 + A24; Y24 = A7 - A24; Y8 = A8 + A23; Y23 = A8 - A23; Y9 = A9 + A22; Y22 = A9 - A22; Y10 = A10 + A21; Y21 = A10 - A21; Y11 = A11 + A20; Y20 = A11 - A20; Y12 = A12 + A19; Y19 = A12 - A19; Y13 = A13 + A18; Y18 = A13 - A18; Y14 = A14 + A17; Y17 = A14 - A17; Y15 = A15 + A16; Y16 = A15 - A16
전술한 도 19의 우측에 도시된 변경된 버터플라이 구조의 실시예에 따라서 변환된 32x32 입력 블록에 대하여 1차원 이산 코사인 역변환을 수행하는 경우, X0 내지 X31은 역변환되어야 할 입력값, A0 내지 A31, B0 내지 B31, C0 내지 C31, D0 내지 D31, E0 내지 E31, F0 내지 F31, G0 내지 G31, H0 내지 H31은 중간값, t는 보조 변수, Y0 내지 Y31은 역변환된 값을 나타낸다고 할 때, 다음의 연산 과정과 같이 표현될 수 있다.
E0= X0; F24 = X1; F12 = X2; G16 = -X3; F7 = X4; ; G31 = X5; ; F9 = X6; ; F26 = -X7; E3 = X8; ; F21 = X9; ; F14 = X10; ; G29 = X11; E5 = X12; ; G18 = -X13; ; E13 = X14; ; E22 = X15; E1 = X16; ; E25 = X17; ; E10 = X18; ; G19 = -X19; E6 = X20; ; G28 = -X21 ; ; F15 = X22; ; F20 = -X23; E2 = X24; ; F27 = -X25; ; F8 = X26; ; G30 = -X27; F4 = X28; ; G17 = -X29 ; ; F11 = X30; ; F23 = -X31; ; F17 = G17 - ((G16*3) >> 4); F16 = G16 + ((F17*25) >> 7); ; F19 = G19 - ((G18*59) >> 7); F18 = G18 + ((F19*171) >> 8); ; F29 = G29 - ((G28*59) >> 7); F28 = G28 + ((F29*171) >> 8); ; F31 = G31 - ((G30*3) >> 4); F30 = G30 + ((F31*25) >> 7); ; ; ; E4 = (F7 >> 1) - F4; E7 = F7 - E4; ; E9 = -F9 + ((F8*45) >> 7); E8 = F8 - ((E9*53) >> 7); ; E12 = F12 + (F11 >> 1); E11 = F11 - E12; ; E15 = F15 + ((F14*45) >> 7); E14 = F14 - ((E15*53) >> 7); ; ; E16 = F16 + F18; D18 = F16 - F18; D17 = F17 + F19; E19 = F17 - F19; ; E21 = F21 + ((F20*45) >> 7); E20 = F20 - ((E21*53) >> 7); ; E24 = F24 + (F23 >> 1); E23 = F23 - ((E24*255) >> 8); ; E27 = F27 + ((F26*45) >> 7); E26 = F26 - ((E27*53) >> 7); ; E28 = -F28 + F30; D30 = F28 + F30; D29 = -F29 + F31; E31 = F29 + F31; ; D1 = (E0 >> 1) - E1; D0 = E0 - D1; ; D3 = E3 + ((E2*45) >> 7); D2 = ((D3*53) >> 7)- E2; ; D4 = E4 + E6; D6 = E4 - E6; D5 = E7 - E5; ; D7 = E7 + E5; ; D8 = E8 + E14; D14 = E8 - E14; D9 = E9 + E15; D15 = E9 - E15; D10 = E10 + E11; ; D11 = E10 - E11; D12 = E12 + E13; D13 = E12 - E13; ; D16 = ((E16 - E19)*181) >> 8; D19 = ((E16 + E19)*181) >> 8; D20 = E20 + E26; D26 = E20 - E26; D21 = E21 + E27; D27 = E21 - E27; D22 = E22 + E23; D23 = E22 - E23; D24 = E24 + E25; D25 = E24 - E25; ; D28 = ((E28 - E31)*181) >> 8; D31 = ((E28 + E31)*181) >> 8; C0 = D0 + D3; C3 = D0 - D3; C1 = D1 + D2; C2 = D1 - D2; ; D7 = D7 + ((D4*77) >> 8); C4 = D4 - ((D7*71) >> 7); C7 = D7 + ((C4*77) >> 8); ; D6 = D6 + ((D5*25) >> 8); C5 = D5 - ((D6*49) >> 8); C6 = D6 + ((C5*25) >> 8); ; C8 = D8 + D11; C11 = D8 - D11; C9 = D9 + D10; C10 = D9 - D10; ; C12 = D12 + D15; C15 = D12 - D15; C13 = D13 + D14; C14 = D13 - D14; ; C16 = D16 + D28; C28 = D16 - D28; C17 = D17 + D29; C29 = D17 - D29; C18 = D18 + D30; C30 = D18 - D30; C19 = D19 + D31; C31 = D19 - D31; ; C20 = D20 + D23; C23 = D20 - D23; C21 = D21 + D22; C22 = D21 - D22; ; C24 = D24 + D27; C27 = D24 - D27; C25 = D25 + D26; C26 = D25 - D26; ; ; B0 = C0 + C7; B7 = C0 - C7; B1 = C1 + C6; B6 = C1 - C6; B2 = C2 + C5; B5 = C2 - C5; B3 = C3 + C4; B4 = C3 - C4; ; C15 = C15 + ((C8*91) >> 8); B8 = C8 - ((C15*81) >> 7); B15 = C15 + ((B8*91) >> 8); ; C9 = C9 + ((C14*153) >> 8); B14 = C14 - ((C9*225) >> 8); B9 = C9 + ((B14*153) >> 8); ; C13 = C13 + ((C10*37) >> 8); B10 = C10 - ((C13*37) >> 7); B13 = C13 + ((B10*37) >> 8); ; C11 = C11 + ((C12*29) >> 5); B12 = C12 - ((C11*127) >> 7); B11 = C11 + ((B12*29) >> 5); ; B16 = C16 + C23; B23 = C16 - C23; ; B17 = C17 + C22; B22 = C17 - C22; B18 = C18 + C21; B21 = C18 - C21; B19 = C19 + C20; B20 = C19 - C20; ; B24 = C24 + C31; B31 = C24 - C31; ; B25 = C25 + C30; B30 = C25 - C30; B26 = C26 + C29; B29 = C26 - C29; B27 = C27 + C28; B28 = C27 - C28; ; A0 = B0 + B15; A1 = B1 + B14; A2 = B2 + B13; A3 = B3 + B12; A4 = B4 + B11; A5 = B5 + B10; A6 = B6 + B9; A7 = B7 + B8; A8 = B7 - B8; A9 = B6 - B9; A10 = B5 - B10; A11 = B4 - B11; A12 = B3 - B12; A13 = B2 - B13; A14 = B1 - B14; A15 = B0 - B15; ; ; B16 = B16 + ((113*B31) >> 8); A31 = B31 - ((189*B16) >> 8); A16 = B16 + ((113*A31) >> 8); ; B17 = B17 - ((21*B30) >> 6); A30 = B30 + ((19*B17) >> 5); A17 = B17 - ((21*A30) >> 6); ; B18 = B18 + ((145*B29) >> 8); A29 = B29 - ((219*B18) >> 8); A18 = B18 + ((145*A29) >> 8); ; B19 = B19 - ((57*B28) >> 8); A28 = B28 + ((109*B19) >> 8); A19 = B19 - ((57*A28) >> 8); ; B20 = B20 + ((45*B27) >> 6); A27 = B27 - ((241*B20) >> 8); A20 = B20 + ((45*A27) >> 6); ; B21 = B21 - ((31*B26) >> 8); A26 = B26 + ((31*B21) >> 7); A21 = B21 - ((31*A26) >> 8); ; B22 = B22 + ((55*B25) >> 6); A25 = B25 - ((253*B22) >> 8); A22 = B22 + ((55*A25) >> 6); ; B23 = B23 - ((3*B24) >> 7); A24 = B24 + ((3*B23) >> 6); A23 = B23 - ((3*A24) >> 7); ; Y0 = A0 + A31; Y31 = A0 - A31; Y1 = A1 + A30; Y30 = A1 - A30; Y2 = A2 + A29; Y29 = A2 - A29; Y3 = A3 + A28; Y28 = A3 - A28; Y4 = A4 + A27; Y27 = A4 - A27; Y5 = A5 + A26; Y26 = A5 - A26; Y6 = A6 + A25; Y25 = A6 - A25; Y7 = A7 + A24; Y24 = A7 - A24; Y8 = A8 + A23; Y23 = A8 - A23; Y9 = A9 + A22; Y22 = A9 - A22; Y10 = A10 + A21; Y21 = A10 - A21; Y11 = A11 + A20; Y20 = A11 - A20; Y12 = A12 + A19; Y19 = A12 - A19; Y13 = A13 + A18; Y18 = A13 - A18; Y14 = A14 + A17; Y17 = A14 - A17; Y15 = A15 + A16; Y16 = A15 - A16
예측부(10040)는 인터 예측 또는 인트라 예측을 통해 복호화되는 현재 블록의 예측 블록을 생성하고, 역변환부(10030)에서 출력되는 레지듀얼 값과 예측 블록을 가산하여 현재 블록을 복원한다.
도 101은 본 발명의 일 실시예에 따른 영상의 역변환 방법을 나타낸 플로우 차트이다.
도 101을 참조하면, 단계 10110에서 복호화되는 영상을 구성하는 NxN(N은 정수) 크기의 블록의 양자화된 변환 계수들을 수신한다.
단계 10120에서, 수신된 양자화된 변환 계수들을 역양자화한다. 전술한 바와 같이, 역양자화는 역스케일링 행렬(V)와 양자화된 변환 계수를 곱한 값에 대해서 floor(QP/6)(floor[x]는 x보다 작거나 같은 최대 정수, QP는 양자화 파라메터) 비트만큼 비트 시프트를 통해 수행될 수 있다.
단계 10130에서, NxN 크기의 블록의 1차원 이산 코사인 변환에 이용되는 NxN 변환 행렬을 구성하는 원소들을 N개의 변수들에 기초한 값들로 치환하여 치환된 NxN 변환 행렬을 생성하고, 치환된 NxN 변환 행렬과 치환된 NxN 변환 행렬의 전치 행렬의 곱셈 행렬을 획득하며, 획득된 곱셈 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 N개의 변수들을 획득하고, 획득된 N개의 변수들에 기초한 값들로 치환된 NxN 변환 행렬(A)의 역행렬인 NxN 역변환 행렬(A-1)을 이용하여 NxN 크기의 블록의 역양자화된 변환 계수들을 역변환한다.
도 102는 본 발명의 다른 실시예에 다른 영상의 역변환 방법을 나타낸 플로우 차트이다.
도 102를 참조하면, 단계 10210에서 복호화되는 영상을 구성하는 NxN(N은 정수) 크기의 블록의 양자화된 변환 계수들을 수신한다.
단계 10220에서 수신된 양자화된 변환 계수들을 역양자화한다. 이 때, 역양자화는 전술한 도 18 및 도 19에 대응되는 변경된 버터 플라이 구조에 대응되는 변환 행렬의 역행렬을 이용하여 수행될 수 있다.
단계 10230에서 버터플라이 구조의 곱셈 인수 중 삼각 함수 성분을 유리수로 치환하고, 버터플라이 구조의 4개의 곱셈 연산과 2개의 덧셈 연산 과정을 3개의 곱셈 연산과 3개의 덧셈 연산 과정으로 대체한 변경된 버터플라이 구조에 기초하여 역양자화된 변환 계수들에 대한 1차원 이산 코사인 역변환을 수행한다.
한편, 전술한 16x16, 32x32, 64x64의 변환 및 역변환 과정은 곱셈을 포함하지 않는 형태로 변경될 수 있다. 구체적으로, 각 변환 과정은 분모가 2의 거듭 제곱꼴인 유리수(dyadic rational)와 중간값들의 곱으로 표현된다. 분모가 2의 거듭 제곱꼴인 유리수(dyadic rational) 형태의 상수를, 분자가 1인 분수들만의 덧셈 및 뺄셈의 형태로 분해하면 곱셈 연산 없이, 덧셈, 뺄셈 및 쉬프트 연산만으로 해당 연산이 수행될 수 있다. 또한, 분해시에 항의 개수가 최소가 되도록 하면 덧셈, 뺄셈 및 쉬프트 연산의 수를 줄일 수 있다. 예를 들어, 분모가 2의 거듭 제곱꼴인 유리수(dyadic rational)의 하나인 59/64는 (1-1/16-1/64)로 변경될 수 있다. 이러한 59/64를 소정의 중간값 x와 곱하는 연산, 즉 (59/64)*x=(59*x)/64이고 64는 2^6이기 때문에 (59*x)/64는 (59*x)>>6을 계산하는 것과 같다. 상기 59/64는 (1-1/16-1/64)로 분해될 수 있기 때문에, (59*x)>>6는 (x-(x>>4)-(x>>6))으로 변경될 수 있다. 이와 같은 경우 (59*x)/64를 계산하기 위해서 원래 곱셈 1번, 쉬프트 연산이 1번 필요했다면 (x-x>>4-x>>6)을 계산시에는 뺄셈 2번, 쉬프트 연산 2번이 필요하게 되므로 복잡도가 큰 곱셈 연산의 횟수를 줄일 수 있다.
다른 예로서, 분모가 2의 거듭 제곱꼴인 유리수(dyadic rational)인 255/256, 131/256, 999/1024, 75/1024는 각각 다음과 같이 분자가 1이면서 분모가 2의 거듭 제곱꼴인 유리수(dyadic rational)의 덧셈 및 뺄셈의 형태로 분해될 수 있다.
255/256=1-1/256; 131/256=1/2+1/128+1/256; 999/1024=1-1/32+1/128-1/1024; 75/1024=1/16+1/128+1/512+1/1024
하나 이상의 분모가 2의 거듭 제곱꼴인 유리수(dyadic rational)와 중간값의 곱셈을 포함하고 있는 식의 경우는, 총 연산의 수를 최소화하도록 변경할 수 있다. 예를 들어, F5=(53*E5+35*E6)>>6 과 같은 연산은, X=E5+E6라고 할 때 F5=(X>>6)+(X>>5)+(X>>1)+(E5>>5)+(E5>>2)와 같이 변경될 수 있다.
이상과 같이 본 발명은 비록 한정된 실시예와 도면에 의해 설명되었으나, 본 발명이 상기의 실시예에 한정되는 것은 아니며, 이는 본 발명이 속하는 분야에서 통상의 지식을 가진 자라면 이러한 기재로부터 다양한 수정 및 변형이 가능하다. 따라서, 본 발명의 사상은 아래에 기재된 특허청구범위에 의해서만 파악되어야 하고, 이와 균등하거나 또는 등가적인 변형 모두는 본 발명 사상의 범주에 속한다 할 것이다. 또한, 본 발명에 따른 시스템은 컴퓨터로 읽을 수 있는 기록매체에 컴퓨터가 읽을 수 있는 코드로서 구현하는 것이 가능하다. 컴퓨터가 읽을 수 있는 기록매체는 컴퓨터 시스템에 의하여 읽혀질 수 있는 데이터가 저장되는 모든 종류의 기록장치를 포함한다. 기록매체의 예로는 ROM, RAM, CD-ROM, 자기 테이프, 플로피 디스크, 광데이터 저장장치 등을 포함한다. 또한 컴퓨터가 읽을 수 있는 기록매체는 네트워크로 연결된 컴퓨터 시스템에 분산되어 분산방식으로 컴퓨터가 읽을 수 있는 코드가 저장되고 실행될 수 있다.
본 발명은 정지 영상 및 동영상의 변환 및 역변환 과정에 이용될 수 있다.

Claims (38)

  1. 영상의 변환 방법에 있어서,
    NxN(N은 정수) 크기의 블록의 1차원 이산 코사인 변환에 이용되는 NxN 변환 행렬을 구성하는 원소들을 N개의 변수들에 기초한 값들로 치환하여 치환된 NxN 변환 행렬을 생성하는 단계;
    상기 치환된 NxN 변환 행렬과 상기 치환된 NxN 변환 행렬의 전치 행렬의 곱셈 행렬을 획득하는 단계;
    상기 획득된 곱셈 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 상기 N개의 변수들을 획득하는 단계; 및
    상기 획득된 N개의 변수들에 기초한 값들로 치환된 NxN 변환 행렬을 이용하여 상기 NxN 크기의 블록을 변환하는 단계를 포함하는 것을 특징으로 하는 영상 변환 방법.
  2. 제 1항에 있어서, 상기 치환된 NxN 변환 행렬을 생성하는 단계는
    상기 NxN 변환 행렬을 구성하는 원소들의 cos(πx(i/2)/N)(i는 0부터 N-1까지의 정수)인 성분을 유리수인 N개의 ai 변수들로 치환하는 것을 특징으로 하는 영상 변환 방법.
  3. 제 2항에 있어서,
    상기 유리수인 N개의 ai 변수들의 분모는 쉬프트(shift) 연산이 가능한 2의 거듭제곱 형태의 값을 갖는 것을 특징으로 하는 영상 변환 방법.
  4. 제 2항에 있어서,
    상기 N은 16의 값을 갖으며, 상기 획득된 N개의 변수들 ai는 다음의 값들; a1=63/64, a2= 62/64, a3= 61/64, a4 = 59/64, a5 = 56/64, a6 = 53/64, a7 = 49/64, a8 = 45/64, a9 = 40/64, a10 = 35/64, a11 = 30/64, a12 = 24/64, a13 = 18/64, a14 = 12/64 및 a15 = 6/64을 갖는 것을 특징으로 하는 영상 변환 방법.
  5. 제 2항에 있어서,
    상기 N은 32의 값을 가지며, 상기 획득된 N개의 변수들 ai는 다음의 값들; a1 = 255/256, a2 = 254/256, a3 = 253/256, a4 = 251/256, a5 = 248/256, a6 = 244/256, a7 = 241/256, a8 = 236/256, a9 = 231/256, a10 = 225/256, a11 = 219/256, a12 = 212/256, a13 = 205/256, a14 = 197/256, a15 = 189/256, a16 = 181/256, a17 = 171/256, a18 = 162/256, a19 = 152/256, a20 = 142/256, a21 = 131/256, a22 = 120/256, a23 = 109/256, a24 = 97/256, a25 = 86/256, a26 = 74/256, a27 = 62/256, a28 = 49/256, a29 = 37/256, a30 = 25/256 및 a31 = 12/256 을 갖는 것을 특징으로 하는 영상 변환 방법.
  6. 제 2항에 있어서,
    상기 N은 64의 값을 가지며, 상기 획득된 N개의 변수들 ai는 다음의 값들; a1 =1024/1024, a2 = 1023/1024, a3 = 1021/1024, a4 = 1019/1024, a5 = 1016/1024, a6 = 1013/1024, a7 = 1009/1024, a8 = 1004/1024, a9 = 999 /1024, a10 =993 /1024, a11 =987 /1024, a12 =980 /1024, a13 =972 /1024, a14 =964 /1024, a15 =955 /1024, a16 =946 /1024, a17 =936 /1024, a18 =926 /1024, a19 =915 /1024, a20 =903 /1024, a21 =891 /1024, a22 =878 /1024, a23 =865 /1024, a24 =851 /1024, a25 =837 /1024, a26 =822 /1024, a27 =807 /1024, a28 =792 /1024, a29 =775 /1024, a30 =759 /1024, a31 =742 /1024, a32 =724 /1024, a33 =706 /1024, a34 =688 /1024, a35 =669 /1024, a36 =650 /1024, a37 =630 /1024, a38 =610 /1024, a39 =590 /1024, a40 =569 /1024, a41 =548 /1024, a42 =526 /1024, a43 =505 /1024, a44 =483 /1024, a45 =460 /1024, a46 =438 /1024, a47 =415 /1024, a48 =392 /1024, a49 =369 /1024, a50 =345 /1024, a51 =321 /1024, a52 =297 /1024, a53 =273 /1024, a54 =249 /1024, a55 =224 /1024, a56 =200 /1024, a57 =175 /1024, a58 =150/1024, a59 =125 /1024, a60 =100 /1024, a61 =75 /1024, a62 =50/1024 및 a63 =25/1024 을 갖는 것을 특징으로 하는 영상 변환 방법.
  7. 제 1항에 있어서,
    이산 코사인 변환에 이용되는 원래의 NxN 변환 행렬과 상기 치환된 NxN 변환 행렬 사이의 차이값을 보정하기 위한 스케일링 행렬 및 시프트 연산을 적용하여 상기 NxN 크기의 블록을 변환한 변환 블록에 대한 양자화를 수행하는 단계를 더 포함하는 것을 특징으로 하는 영상 변환 방법.
  8. 제 7항에 있어서,
    상기 스케일링 행렬은
    각 i번째 행의 원소가 Si(i는 1부터 N까지의 정수)의 값을 갖는 NxN 크기의 중간 행렬과 상기 치환된 NxN 크기의 변환 행렬의 동일 위치의 원소들을 각각 곱한 값과, 상기 원래의 NxN 변환 행렬 사이의 차이인 변환 오차 행렬을 획득하고, 상기 변환 오차 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 상기 Si 값들을 획득하며, 상기 획득된 Si값들을 적용한 상기 NxN 크기의 중간 행렬과 상기 중간 행렬의 전치 행렬의 동일 위치의 원소들을 각각 곱한 행렬에 기초하여 생성된 것을 특징으로 하는 영상 변환 방법.
  9. 제 8항에 있어서,
    양자화 스텝을 Qstep, 상기 중간 행렬의 원소들과 상기 중간 행렬의 전치 행렬의 동일 위치의 원소들을 각각 곱한 행렬을 PF, m은 양의 정수라고 할 때, 상기 스케일링 행렬(MF)은 다음의 수학식; MF=PF*2^m/Qstep 을 통해 획득되는 것을 특징으로 하는 영상 변환 방법.
  10. 제 9항에 있어서,
    상기 NxN 크기의 블록을 변환한 변환 블록에 대한 양자화를 수행하는 단계는
    상기 스케일링 행렬(MF)와 상기 NxN 크기의 블록을 변환한 변환 블록을 곱한 값에 소정의 오프셋을 더한 값을 다음의 수학식; q=floor(QP/6)+m 의 q 비트만큼 비트 시프트 연산함으로써 수행하는 것을 특징으로 하는 영상 변환 방법.
  11. 제 7항에 있어서,
    상기 스케일링 행렬은
    이산 코사인 변환에 이용되는 원래의 NxN 변환 행렬의 각 원소를 상기 치환된 NxN 변환 행렬의 동일 위치의 원소로 나눔으로써 획득된 중간 행렬의 각 원소와 상기 중간 행렬의 전치 행렬의 동일 위치의 원소를 곱하여 획득된 행렬인 것을 특징으로 하는 영상 변환 방법.
  12. 영상의 변환 방법에 있어서,
    NxN 크기(N은 정수)의 블록의 행 단위 및 열 단위 중 어느 하나에 대한 1차원 이산 코사인 변환을 수행하는 단계를 포함하며,
    상기 1차원 이산 코사인 변환을 수행하는 단계는 버터플라이 구조의 곱셈 인수 중 삼각 함수 성분을 유리수로 치환하고, 상기 버터플라이 구조의 4개의 곱셈 연산과 2개의 덧셈 연산 과정을 3개의 곱셈 연산과 3개의 덧셈 연산 과정으로 대체한 변경된 버터플라이 구조에 기초하여 수행되는 것을 특징으로 하는 영상 변환 방법.
  13. 제 12항에 있어서,
    상기 1차원 이산 코사인 변환을 수행하는 단계는
    상기 N은 32, X0 내지 X31는 변환되어야 할 입력값, A0 내지 A31, B0 내지 B31, C0 내지 C31, D0 내지 D31, E0 내지 E31, F0 내지 F31은 중간값, t는 보조 변수, Y0 내지 Y31은 변환된 값을 나타낸다고 할 때,
    A0 = X0 + X31; A31 = X0 - X31; A1 = X1 + X30; A30 = X1 - X30; A2 = X2 + X29; A29 = X2 - X29; A3 = X3 + X28; A28 = X3 - X28; A4 = X4 + X27; A27 = X4 - X27; A5 = X5 + X26; A26 = X5 - X26; A6 = X6 + X25; A25 = X6 - X25; A7 = X7 + X24; A24 = X7 - X24; A8 = X8 + X23; A23 = X8 - X23; A9 = X9 + X22; A22 = X9 - X22; A10 = X10 + X21; A21 = X10 - X21; A11 = X11 + X20; A20 = X11 - X20; A12 = X12 + X19; A19 = X12 - X19; A13 = X13 + X18; A18 = X13 - X18; A14 = X14 + X17; A17 = X14 - X17; A15 = X15 + X16; A16 = X15 - X16;
    B0 = A0 + A15; B15 = A0 - A15; B1 = A1 + A14; B14 = A1 - A14; B2 = A2 + A13; B13 = A2 - A13; B3 = A3 + A12; B12 = A3 - A12; B4 = A4 + A11; B11 = A4 - A11; B5 = A5 + A10; B10 = A5 - A10; B6 = A6 + A9; B9 = A6 - A9; B7 = A7 + A8; B8 = A7 - A8;
    t = ((171*(A16 + A31) >> 8); B16 = t - ((361*A31) >> 8); B31 = t - ((-17*A16) >> 8);
    t = ((205*(A17 + A30) >> 8); B17 = t - ((53*A30) >> 8); B30 = t - ((358*A17) >> 8);
    t = ((131*(A18 + A29) >> 8); B18 = t - ((351*A29) >> 8); B29 = t - ((-87*A18) >> 8);
    t = ((231*(A19 + A28) >> 8); B19 = t - ((121*A28) >> 8); B28 = t - ((340*A19) >> 8);
    t = ((86*(A20 + A27) >> 8); B20 = t - ((327*A27) >> 8); B27 = t - ((-77*A20) >> 8);
    t = ((248*(A21 + A26) >> 8); B21 = t - ((186*A26) >> 8); B26 = t - ((310*A21) >> 8);
    t = ((37*(A22 + A25) >> 8); B22 = t - ((290*A25) >> 8); B25 = t - ((-215*A22) >> 8);
    t = ((255*(A23 + A24) >> 8); B23 = t - ((243*A24) >> 8); B24 = t - ((268*A23) >> 8);
    C0 = B0 + B7; C7 = B0 - B7; C1 = B1 + B6; C6 = B1 - B6; C2 = B2 + B5; C5 = B2 - B5; C3 = B3 + B4; C4 = B3 - B4;
    t = ((197*(B8 + B15) >> 8); C8 = t - ((35*B15) >> 8); C15 = t - ((360*B8) >> 8);
    t = ((120*(B9 + B14) >> 8); C9 = t - ((346*B14) >> 8); C14 = t - ((-105*B9) >> 8);
    t = ((244*(B10 + B13) >> 8); C10 = t - ((170*B13) >> 8); C13 = t - ((319*B10) >> 8);
    t = ((25*(B11 + B12) >> 8); C11 = t - ((279*B12) >> 8); C12 = t - ((-229*B11) >> 8);
    C16 = B16 + B23; C23 = B16 - B23; C17 = B17 + B22; C22 = B17 - B22; C18 = B18 + B21; C21 = B18 - B21; C19 = B19 + B20; C20 = B19 - B20; C24 = B24 + B31; C31 = B24 - B31; C25 = B25 + B30; C30 = B25 - B30; C26 = B26 + B29; C29 = B26 - B29; C27 = B27 + B28; C28 = B27 - B28;
    D0 = C0 + C3; D3 = C0 - C3; D1 = C1 + C2; D2 = C1 - C2; t = ((49*(C4 + C7) >> 8); D4 = t - ((-201*C7) >> 8); D7 = t - ((301*C4) >> 8);
    t = ((142*(C5 + C6) >> 8); D5 = t - ((-70*C6) >> 8); D6 = t - ((355*C5) >> 8); D8 = C8 + C11; D11 = C8 - C11; D9 = C9 + C10; D10 = C9 - C10; D12 = C12 + C15; D15 = C12 - C15; D13 = C13 + C14; D14 = C13 - C14; D16 = C16 + C28; D28 = C16 - C28; D17 = C17 + C29; D29 = C17 - C29; D18 = C18 + C30; D30 = C18 - C30; D19 = C19 + C31; D31 = C19 - C31; D20 = C20 + C23; D23 = C20 - C23; D21 = C21 + C22; D22 = C21 - C22; D24 = C24 + C27; D27 = C24 - C27; D25 = C25 + C26; D26 = C25 - C26;
    E0 = ((D0 + D1)*181 >> 8); E1 = ((D0 - D1)*181 >> 8);
    t = (97*(D2 + D3) >> 8); E2 = t - ((-138*D3) >> 8); E3 = t - ((334*D2) >> 8); E4 = D4 + D5; E5 = D4 - D5; E6 = -D6 + D7; E7 = D6 + D7; E8 = D8 + D14; E14 = D8 - D14; E9 = D9 + D15; E15 = D9 - D15; E10 = D10 + D11; E11 = D10 - D11; E12 = D12 + D13; E13 = D12 - D13; E16 = ((D16 + D19)*181 >> 8); E19 = ((D16 - D19)*181 >> 8); E20 = D20 + D26; E26 = D20 - D26; E21 = D21 + D27; E27 = D21 - D27; E22 = D22 + D23; E23 = D22 - D23; E24 = D24 + D25; E25 = D24 - D25; E28 = ((D28 + D31)*181 >> 8); E31 = ((D28 - D31)*181 >> 8);
    F5 = ((E5 + E7)*181 >> 8); F7 = ((E5 - E7)*181 >> 8);
    t = (97*(E8 + E9) >> 8); F8 = t - ((334*E9) >> 8); F9 = t - ((-138*E8) >> 8); F11 = ((E11 + E12)*181 >> 8); F12 = ((E12 - F11)*181 >> 8);
    t = (97*(E14 + E15) >> 8); F14 = t - ((334*E15) >> 8); F15 = t - ((-138*E14) >> 8); F16 = E16 + D18; F18 = E16 - D18; F17 = D17 + E19; F19 = D17 - E19;
    t = (236*(E20 + E21) >> 8); F20 = t - ((138*E21) >> 8); F21 = t - ((334*E20) >> 8); F23 = ((E23 + E24)*181 >> 8); F24 = ((E23 - E24)*181 >> 8);
    t = ((236*(E26 + E27)) >> 8); F26 = t - ((138*E27) >> 8); F27 = t - ((334*E26) >> 8); F28 = -E28 + D30; F30 = E28 + D30; F29 = -D29 + E31; F31 = D29 + E31;
    t = (251*(F16 + F17) >> 8); G16 = t - ((301*F17) >> 8); G17 = t - ((201*F16) >> 8);
    t = (212*(F18 + F19) >> 8); G18 = t - ((355*F19) >> 8); G19 = t - ((70*F18) >> 8);
    t = (212*(F28 + F29) >> 8); G28 = t - ((355*F29) >> 8); G29 = t - ((70*F28) >> 8);
    t = (251*(F30 + F31) >> 8); G30 = t - ((301*F31) >> 8); G31 = t - ((201*F30) >> 8);
    Y0 = E0; Y1 = F24; Y2 = -F12; Y3 = -G16; Y4 = E4; Y5 = G31; Y6 = F8; Y7 = -F26; Y8 = E2; Y9 = F21; Y10 = F15; Y11 = G29; Y12 = F5; Y13 = -G18; Y14 = E13; Y15 = E22; Y16 = E1; Y17 = E25; Y18 = E10; Y19 = -G19; Y20 = F7; Y21 = -G28; Y22 = F14; Y23 = -F20; Y24 = E3; Y25 = -F27; Y26 = F9; Y27 = -G30; Y28 = E6; Y29 = -G17; Y30 = F11; Y31 = -F23;
    에 의하여 변환값을 생성하는 것을 특징으로 하는 영상 변환 방법.
  14. 제 12항에 있어서,
    상기 1차원 이산 코사인 변환을 수행하는 단계는
    상기 N은 32, X0 내지 X31는 변환되어야 할 입력값, A0 내지 A31, B0 내지 B31, C0 내지 C31, D0 내지 D31, E0 내지 E31, F0 내지 F31, G0내지 G31은 중간값, Y0 내지 Y31은 변환된 값을 나타낸다고 할 때,
    A0 = X0 + X31; A31 = X0 - X31; A1 = X1 + X30; A30 = X1 - X30; A2 = X2 + X29; A29 = X2 - X29; A3 = X3 + X28; A28 = X3 - X28; A4 = X4 + X27; A27 = X4 - X27; A5 = X5 + X26; A26 = X5 - X26; A6 = X6 + X25; A25 = X6 - X25; A7 = X7 + X24; A24 = X7 - X24; A8 = X8 + X23; A23 = X8 - X23; A9 = X9 + X22; A22 = X9 - X22; A10 = X10 + X21; A21 = X10 - X21; A11 = X11 + X20; A20 = X11 - X20; A12 = X12 + X19; A19 = X12 - X19; A13 = X13 + X18; A18 = X13 - X18; A14 = X14 + X17; A17 = X14 - X17; A15 = X15 + X16; A16 = X15 - X16;
    B0 = A0 + A15; B15 = A0 - A15; B1 = A1 + A14; B14 = A1 - A14; B2 = A2 + A13; B13 = A2 - A13; B3 = A3 + A12; B12 = A3 - A12; B4 = A4 + A11; B11 = A4 - A11; B5 = A5 + A10; B10 = A5 - A10; B6 = A6 + A9; B9 = A6 - A9; B7 = A7 + A8; B8 = A7 - A8; B16 = A16 - ((113*A31)>> 8); B31 = A31 + ((189*B16)>> 8); B16 = B16 - ((113*B31)>> 8); B17 = A17 + ((21*A30) >> 6); B30 = A30 - ((152*B17) >> 8); B17 = B17 + ((21*B30) >> 6); B18 = A18 - ((145*A29) >> 8); B29 = A29 + ((219*B18) >> 8); B18 = B18 - ((145*B29) >> 8); B19 = A19 + ((57*A28) >> 8); B28 = A28 - ((109*B19) >> 8); B19 = B19 + ((57*B28) >> 8); B20 = A20 - ((45*A27) >> 6); B27 = A27 + ((241*B20) >> 8); B20 = B20 - ((45*B27) >> 6); B21 = A21 + ((31*A26) >> 8); B26 = A26 - ((31*B21) >> 7); B21 = B21 + ((31*B26) >> 8); B22 = A22 - ((55*A25) >> 6); B25 = A25 + ((253*B22) >> 8); B22 = B22 - ((55*B25) >> 6); B23 = A23 + ((3*A24) >> 7); B24 = A24 - ((3*B23) >> 6); B23 = B23 + ((3*B24) >> 7);
    C0 = B0 + B7; C7 = B0 - B7; C1 = B1 + B6; C6 = B1 - B6;
    C2 = B2 + B5; C5 = B2 - B5; C3 = B3 + B4; C4 = B3 - B4;
    C15 = B15 - ((B8*91) >> 8); C8 = B8 + ((C15*81) >> 7);
    C15 = C15 - ((C8*91) >> 8); C9 = B9 - ((B14*153) >> 8);
    C14 = B14 + ((C9*225) >> 8); C9 = C9 - ((C14*153) >> 8);
    C13 = B13 - ((B10*37) >> 8); C10 = B10 + ((C13*37) >> 7);
    C13 = C13 - ((C10*37) >> 8); C11 = B11 - ((B12*29) >> 5);
    C12 = B12 + ((C11*127) >> 7); C11 = C11 - ((C12*29) >> 5);
    C16 = B16 + B23; C23 = B16 - B23; C17 = B17 + B22;
    C22 = B17 - B22; C18 = B18 + B21; C21 = B18 - B21;
    C19 = B19 + B20; C20 = B19 - B20; C24 = B24 + B31;
    C31 = B24 - B31; C25 = B25 + B30; C30 = B25 - B30;
    C26 = B26 + B29; C29 = B26 - B29; C27 = B27 + B28;
    C28 = B27 - B28;
    D0 = C0 + C3; D3 = C0 - C3; D1 = C1 + C2; D2 = C1 - C2;
    D7 = C7 - ((C4*77) >> 8); D4 = C4 + ((D7*71) >> 7);
    D7 = D7 - ((D4*77) >> 8); D6 = C6 - ((C5*25) >> 8);
    D5 = C5 + ((D6*49) >> 8); D6 = D6 - ((D5*25) >> 8);
    D8 = C8 + C11; D11 = C8 - C11; D9 = C9 + C10;
    D10 = C9 - C10; D12 = C12 + C15; D15 = C12 - C15;
    D13 = C13 + C14; D14 = C13 - C14; D16 = C16 + C28;
    D28 = C16 - C28; D17 = C17 + C29; D29 = C17 - C29;
    D18 = C18 + C30; D30 = C18 - C30; D19 = C19 + C31;
    D31 = C19 - C31; D20 = C20 + C23; D23 = C20 - C23;
    D21 = C21 + C22; D22 = C21 - C22; D24 = C24 + C27;
    D27 = C24 - C27; D25 = C25 + C26; D26 = C25 - C26;
    E0 = D0 + D1; E1 = (E0>>1) - D1;
    E2 = -D2 + ((D3*53) >> 7); E3 = D3 - ((E2*45) >> 7);
    E4 = D4 + D6; E6 = D4 - D6; E5 = D7 - D5; E7 = D7 + D5;
    E8 = D8 + D14; E14 = D8 - D14; E9 = D9 + D15;
    E15 = D9 - D15; E10 = D10 + D11; E11 = D10 - D11;
    E12 = D12 + D13; E13 = D12 - D13;
    E16 = ((D16 + D19)*181) >> 8; E19 = ((-D16 + D19)*181) >> 8;
    E20 = D20 + D26; E26 = D20 - D26; E21 = D21 + D27;
    E27 = D21 - D27; E22 = D22 + D23; E23 = D22 - D23;
    E24 = D24 + D25; E25 = D24 - D25;
    E28 = ((D28 + D31)*181) >> 8; E31 = ((-D28 + D31)*181) >> 8;
    F7 = E7 + E4; F4 = (F7>>1) - E4;
    F8 = E8 + ((E9*53) >> 7); F9 = -E9 + ((F8*45) >> 7);
    F11 = E11 + E12; F12 = E12 - (F11 >> 1);
    F14 = E14 + ((E15*53) >> 7); F15 = E15 - ((F14*45) >> 7);
    F16 = E16 + D18; F18 = E16 - D18; F17 = D17 + E19;
    F19 = D17 - E19; F20 = E20 + ((E21*53) >> 7);
    F21 = E21 - ((F20*45) >> 7); F23 = E23 + ((E24*255) >> 8);
    F24 = E24 - (F23 >> 1); F26 = E26 + ((E27*53) >> 7);
    F27 = E27 - ((F26*45) >> 7); F28 = -E28 + D30;
    F30 = E28 + D30; F29 = -D29 +E31; F31 = D29 + E31;
    G16 = F16 - ((F17*25) >> 7); G17 = F17 + ((G16*3) >> 4);
    G18 = F18 - ((F19*171) >> 8); G19 = F19 + ((G18*59) >> 7);
    G28 = F28 - ((F29*171) >> 8); G29 = F29 + ((G28*59) >> 7);
    G30 = F30 - ((F31*25) >> 7); G31 = F31 + ((G30*3) >> 4);
    Y0 = E0; Y1 = F24; Y2 = F12; Y3 = -G16; Y4 = F7; Y5 = G31; Y6 = F9; Y7 = -F26; Y8 = E3; Y9 = F21; Y10 = F14; Y11 = G29; Y12 = E5; Y13 = -G18; Y14 = E13; Y15 = E22; Y16 = E1; Y17 = E25; Y18 = E10; Y19 = -G19; Y20 = E6; Y21 = -G28; Y22 = F15; Y23 = -F20; Y24 = E2; Y25 = -F27; Y26 = F8; Y27 = -G30; Y28 = F4; Y29 = -G17; Y30 = F11; Y31 = -F23
    에 의하여 변환값을 생성하는 것을 특징으로 하는 영상 변환 방법.
  15. 제 12항에 있어서,
    상기 변경된 버터플라이 구조에 기초한 N 포인트 1차원 이산 코사인 변환에 대응되는 변경된 이산 코사인 변환 행렬을 A라고 할 때,
    상기 버터플라이 구조에 기초한 원래의 NxN 변환 행렬과 상기 변경된 이산 코사인 변환 행렬 A 사이의 차이값을 보정하기 위한 스케일링 행렬 및 시프트 연산을 적용하여 상기 NxN 크기의 블록을 변환한 변환 블록에 대한 양자화를 수행하는 단계를 더 포함하는 것을 특징으로 하는 영상 변환 방법.
  16. 제 15항에 있어서,
    상기 스케일링 행렬은
    각 i번째 행의 원소가 Si(i는 1부터 N까지의 정수)의 값을 갖는 NxN 크기의 중간 행렬과 상기 변경된 이산 코사인 변환 행렬 A의 동일 위치의 원소들을 각각 곱한 값과, 상기 원래의 NxN 변환 행렬 사이의 차이인 변환 오차 행렬을 획득하고, 상기 변환 오차 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 상기 Si 값들을 획득하며, 상기 획득된 Si값들을 적용한 상기 NxN 크기의 중간 행렬의 각 원소와 상기 중간 행렬의 전치 행렬의 동일 위치의 원소를 곱한 행렬에 기초하여 생성된 것을 특징으로 하는 영상 변환 방법.
  17. 제 15항에 있어서,
    상기 스케일링 행렬은
    이산 코사인 변환에 이용되는 원래의 NxN 변환 행렬의 각 원소를 상기 변경된 이산 코사인 변환 행렬 A의 동일 위치의 원소들로 나눔으로써 중간 행렬을 획득하고, 상기 획득된 중간 행렬의 각 원소와 상기 중간 행렬의 전치 행렬의 동일 위치의 원소들을 곱하여 획득된 행렬인 것을 특징으로 하는 영상 변환 방법.
  18. 영상의 변환 장치에 있어서,
    NxN(N은 정수) 크기의 블록의 1차원 이산 코사인 변환에 이용되는 NxN 변환 행렬을 구성하는 원소들을 N개의 변수들에 기초한 값들로 치환하여 치환된 NxN 변환 행렬을 생성하고, 상기 치환된 NxN 변환 행렬과 상기 치환된 NxN 변환 행렬의 전치 행렬의 곱셈 행렬을 획득하며, 상기 획득된 곱셈 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 상기 N개의 변수들을 획득하고 상기 획득된 N개의 변수들에 기초한 값들로 치환함으로써 획득된 치환된 NxN 변환 행렬을 이용하여 상기 NxN 크기의 블록을 변환하는 변환부를 포함하는 것을 특징으로 하는 영상 변환 장치.
  19. 영상의 변환 장치에 있어서,
    버터플라이 구조의 곱셈 인수 중 삼각 함수 성분을 유리수로 치환하고, 상기 버터플라이 구조의 4개의 곱셈 연산과 2개의 덧셈 연산 과정을 3개의 곱셈 연산과 3개의 덧셈 연산 과정으로 대체한 변경된 버터플라이 구조에 기초하여 NxN 크기(N은 정수)의 블록의 행 단위 및 열 단위 중 어느 하나에 대한 1차원 이산 코사인 변환을 수행하는 변환부를 포함하는 것을 특징으로 하는 영상 변환 장치.
  20. 영상의 역변환 방법에 있어서,
    복호화되는 영상을 구성하는 NxN(N은 정수) 크기의 블록의 양자화된 변환 계수들을 수신하는 단계;
    상기 수신된 양자화된 변환 계수들을 역양자화하는 단계; 및
    상기 NxN 크기의 블록의 1차원 이산 코사인 변환에 이용되는 NxN 변환 행렬을 구성하는 원소들을 N개의 변수들에 기초한 값들로 치환하여 치환된 NxN 변환 행렬을 생성하고, 상기 치환된 NxN 변환 행렬과 상기 치환된 NxN 변환 행렬의 전치 행렬의 곱셈 행렬을 획득하며, 상기 획득된 곱셈 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 상기 N개의 변수들을 획득하고, 상기 획득된 N개의 변수들에 기초한 값들로 치환된 NxN 변환 행렬의 역행렬인 NxN 역변환 행렬을 이용하여 상기 NxN 크기의 블록의 역양자화된 변환 계수들을 역변환하는 단계를 포함하는 것을 특징으로 하는 영상 역변환 방법.
  21. 제 20항에 있어서, 상기 치환된 NxN 변환 행렬은
    상기 NxN 변환 행렬을 구성하는 원소들의 cos(πx(i/2)/N)(i는 0부터 N-1까지의 정수)인 성분을 유리수인 N개의 ai 변수들로 치환함으로써 획득되는 것을 특징으로 하는 영상 역변환 방법.
  22. 제 21항에 있어서,
    상기 유리수인 N개의 ai 변수들의 분모는 쉬프트(shift) 연산이 가능한 2의 거듭제곱 형태의 값을 갖는 것을 특징으로 하는 영상 역변환 방법.
  23. 제 21항에 있어서,
    상기 N은 16의 값을 갖으며, 상기 획득된 N개의 변수들 ai는 다음의 값들; a1=63/64, a2= 62/64, a3= 61/64, a4 = 59/64, a5 = 56/64, a6 = 53/64, a7 = 49/64, a8 = 45/64, a9 = 40/64, a10 = 35/64, a11 = 30/64, a12 = 24/64, a13 = 18/64, a14 = 12/64 및 a15 = 6/64을 갖는 것을 특징으로 하는 영상 역변환 방법.
  24. 제 21항에 있어서,
    상기 N은 32의 값을 가지며, 상기 획득된 N개의 변수들 ai는 다음의 값들; a1 = 255/256, a2 = 254/256, a3 = 253/256, a4 = 251/256, a5 = 248/256, a6 = 244/256, a7 = 241/256, a8 = 236/256, a9 = 231/256, a10 = 225/256, a11 = 219/256, a12 = 212/256, a13 = 205/256, a14 = 197/256, a15 = 189/256, a16 = 181/256, a17 = 171/256, a18 = 162/256, a19 = 152/256, a20 = 142/256, a21 = 131/256, a22 = 120/256, a23 = 109/256, a24 = 97/256, a25 = 86/256, a26 = 74/256, a27 = 62/256, a28 = 49/256, a29 = 37/256, a30 = 25/256 및 a31 = 12/256 을 갖는 것을 특징으로 하는 영상 역변환 방법.
  25. 제 21항에 있어서,
    상기 N은 64의 값을 가지며, 상기 획득된 N개의 변수들 ai는 다음의 값들; a1 =1024/1024, a2 = 1023/1024, a3 = 1021/1024, a4 = 1019/1024, a5 = 1016/1024, a6 = 1013/1024, a7 = 1009/1024, a8 = 1004/1024, a9 = 999 /1024, a10 =993 /1024, a11 =987 /1024, a12 =980 /1024, a13 =972 /1024, a14 =964 /1024, a15 =955 /1024, a16 =946 /1024, a17 =936 /1024, a18 =926 /1024, a19 =915 /1024, a20 =903 /1024, a21 =891 /1024, a22 =878 /1024, a23 =865 /1024, a24 =851 /1024, a25 =837 /1024, a26 =822 /1024, a27 =807 /1024, a28 =792 /1024, a29 =775 /1024, a30 =759 /1024, a31 =742 /1024, a32 =724 /1024, a33 =706 /1024, a34 =688 /1024, a35 =669 /1024, a36 =650 /1024, a37 =630 /1024, a38 =610 /1024, a39 =590 /1024, a40 =569 /1024, a41 =548 /1024, a42 =526 /1024, a43 =505 /1024, a44 =483 /1024, a45 =460 /1024, a46 =438 /1024, a47 =415 /1024, a48 =392 /1024, a49 =369 /1024, a50 =345 /1024, a51 =321 /1024, a52 =297 /1024, a53 =273 /1024, a54 =249 /1024, a55 =224 /1024, a56 =200 /1024, a57 =175 /1024, a58 =150/1024, a59 =125 /1024, a60 =100 /1024, a61 =75 /1024, a62 =50/1024 및 a63 =25/1024 을 갖는 것을 특징으로 하는 영상 역변환 방법.
  26. 제 20항에 있어서,
    상기 역양자화하는 단계는
    이산 코사인 역변환에 이용되는 원래의 NxN 역변환 행렬과 상기 치환된 NxN 변환 행렬의 역행렬인 NxN 역변환 행렬 사이의 차이값을 보정하기 위한 역스케일링 행렬 및 시프트 연산을 적용하여 상기 역양자화를 수행하는 것을 특징으로 하는 영상 역변환 방법.
  27. 제 26항에 있어서,
    상기 역스케일링 행렬은
    각 i번째 행의 원소가 Si(i는 1부터 N까지의 정수)의 값을 갖는 NxN 크기의 중간 행렬의 각 원소와 상기 NxN 크기의 변환 행렬의 동일 위치의 원소들을 곱한 값과, 상기 원래의 NxN 변환 행렬 사이의 차이인 변환 오차 행렬을 획득하고, 상기 변환 오차 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 상기 Si 값들을 획득하며, 상기 획득된 Si값들을 적용한 상기 NxN 크기의 중간 행렬의 각 원소와 상기 중간 행렬의 전치 행렬의 동일 위치의 원소들을 각각 곱한 행렬에 기초하여 생성된 것을 특징으로 하는 영상 역변환 방법.
  28. 제 27항에 있어서,
    양자화 스텝을 Qstep, 상기 중간 행렬의 각 원소와 상기 중간 행렬의 동일 위치의 원소들을 각각 곱한 행렬을 PF, n은 양의 정수라고 할 때, 상기 역스케일링 행렬(V)은 다음의 수학식; V=Qstep*PF*2^n 을 통해 획득되는 것을 특징으로 하는 영상 역변환 방법.
  29. 제 28항에 있어서,
    상기 역양자화하는 단계는
    상기 역스케일링 행렬(V)와 상기 양자화된 변환 계수를 곱한 값에 대해서 floor(QP/6)(floor[x]는 x보다 작거나 같은 최대 정수, QP는 양자화 파라메터) 비트만큼 비트 시프트 연산을 함으로써 수행되는 것을 특징으로 하는 영상 역변환 방법.
  30. 제 26항에 있어서,
    상기 역스케일링 행렬은
    이산 코사인 역변환에 이용되는 원래의 NxN 역변환 행렬의 각 원소를 상기 치환된 NxN 변환 행렬의 역행렬인 NxN 역변환 행렬의 동일 위치의 원소들로 나눔으로써 중간 행렬을 획득하고, 상기 획득된 중간 행렬의 각 원소와 상기 중간 행렬의 전치 행렬의 동일 위치의 원소들을 곱하여 획득된 행렬인 것을 특징으로 하는 영상 역변환 방법.
  31. 영상의 역변환 방법에 있어서,
    복호화되는 영상을 구성하는 NxN(N은 정수) 크기의 블록의 양자화된 변환 계수들을 수신하는 단계;
    상기 수신된 양자화된 변환 계수들을 역양자화하는 단계; 및
    역양자화된 변환 계수들에 대한 1차원 이산 코사인 역변환을 수행하는 단계를 포함하며,
    상기 1차원 이산 코사인 역변환을 수행하는 단계는 버터플라이 구조의 곱셈 인수 중 삼각 함수 성분을 유리수로 치환하고, 상기 버터플라이 구조의 4개의 곱셈 연산과 2개의 덧셈 연산 과정을 3개의 곱셈 연산과 3개의 덧셈 연산 과정으로 대체한 변경된 버터플라이 구조에 기초하여 수행되는 것을 특징으로 하는 영상 역변환 방법.
  32. 제 31항에 있어서,
    상기 1차원 이산 코사인 역변환을 수행하는 단계는
    상기 N은 32, X0 내지 X31는 역변환되어야 할 입력값, A0 내지 A31, B0 내지 B31, C0 내지 C31, D0 내지 D31, E0 내지 E31, F0 내지 F31, G0 내지 G31은 중간값, t는 보조 변수, Y0 내지 Y31은 역변환된 값을 나타낸다고 할 때,
    E0= X0; F24 = X1; F12 = -X2; G16 = -X3; E4 = X4; G31 = X5; F8 = X6; F26 = -X7; E2 = X8; F21 = X9; F15 = X10; G29 = X11; F5 = X12; G18 = -X13; E13 = X14; E22 = X15; E1 = X16; E25 = X17; E10 = X18; G19 = -X19; F7 = X20; G28 = -X21 ; F14 = X22; F20 = -X23; E3 = X24; F27 = -X25; F9 = X26; G30 = -X27; E6 = X28; G17 = -X29 ; F11 = X30; F23 = -X31;
    t = (251*(G16 + G17) >> 8); F16 = t - ((201*G17) >> 8); F17 = t - ((301*G16) >> 8);
    t = (212*(G18 + G19) >> 8); F18 = t - ((70*G19) >> 8); F19 = t - ((355*G18) >> 8);
    t = ((212*(G28 + G29)) >> 8); F28 = t - ((70*G29) >> 8); F29 = t - ((355*G28) >> 8);
    t = (251*(G30 + G31) >> 8); F30 = t - ((201*G31) >> 8); F31 = t - ((301*G30) >> 8);
    E5 = ((F5 + F7)*181 >> 8); E7 = ((F5 - F7)*181 >> 8);
    t = (97*(F8 + F9) >> 8); E8 = t - ((-138*F9) >> 8); E9 = t - ((334*F8) >> 8); E11 = ((F11 + F12)*181 >> 8); E12 = ((F11 - F12)*181 >> 8);
    t = (97*(F14 + F15) >> 8); E14 = t - ((-138*F15) >> 8); E15 = t - ((334*F14) >> 8); E16 = F16 + F18; D18 = F16 - F18; D17 = F17 + F19; E19 = F17 - F19;
    t = (236*(F20 + F21) >> 8); E20 = t - ((334*F21) >> 8); E21 = t - ((138*F20) >> 8); E23 = ((F23 + F24)*181 >> 8); E24 = ((F23 - F24)*181 >> 8);
    t = (236*(F26 + F27) >> 8); E26 = t - ((334*F27) >> 8); E27 = t - ((138*F26) >> 8);
    E28 = -F28 + F30; D30 = F28 + F30; D29 = -F29 + F31; E31 = F29 + F31; D0 = ((E0 + E1)*181 >> 8); D1 = ((E0 - E1)*181 >> 8);
    t = (97*(E2 + E3) >> 8); D2 = t - ((334*E3) >> 8); D3 = t - ((-138*E2) >> 8);
    D4 = E4 + E5; D5 = E4 - E5; D6 = -E6 + E7; D7 = E6 + E7; D8 = E8 + E14; D14 = E8 - E14; D9 = E9 + E15; D15 = E9 - E15; D10 = E10 + E11; D11 = E10 - E11; D12 = E12 + E13; D13 = E12 - E13; D16 = ((E16 + E19)*181 >> 8); D19 = ((E16 - E19)*181 >> 8); D20 = E20 + E26; D26 = E20 - E26; D21 = E21 + E27; D27 = E21 - E27; D22 = E22 + E23; D23 = E22 - E23; D24 = E24 + E25; D25 = E24 - E25; D28 = ((E28 + E31)*181 >> 8); D31 = ((E28 - E31)*181 >> 8); C0 = D0 + D3; C3 = D0 - D3; C1 = D1 + D2; C2 = D1 - D2;
    t = (49*(D4 + D7) >> 8); C4 = t - ((301*D7) >> 8); C7 = t - ((-201*D4) >> 8);
    t = (142*(D5 + D6) >> 8); C5 = t - ((355*D6) >> 8); C6 = t - ((-70*D5) >> 8);
    C8 = D8 + D11; C11 = D8 - D11; C9 = D9 + D10; C10 = D9 - D10; C12 = D12 + D15; C15 = D12 - D15; C13 = D13 + D14; C14 = D13 - D14; C16 = D16 + D28; C28 = D16 - D28; C17 = D17 + D29; C29 = D17 - D29; C18 = D18 + D30; C30 = D18 - D30; C19 = D19 + D31; C31 = D19 - D31; C20 = D20 + D23; C23 = D20 - D23; C21 = D21 + D22; C22 = D21 - D22; C24 = D24 + D27; C27 = D24 - D27; C25 = D25 + D26; C26 = D25 - D26;
    B0 = C0 + C7; B7 = C0 - C7; B1 = C1 + C6; B6 = C1 - C6; B2 = C2 + C5; B5 = C2 - C5; B3 = C3 + C4; B4 = C3 - C4;
    t = (197*(C8 + C15) >> 8); B8 = t - ((360*C15) >> 8); B15 = t - ((35*C8) >> 8);
    t = (120*(C9 + C14) >> 8); B9 = t - ((-105*C14) >> 8); B14 = t - ((346*C9) >> 8);
    t = (244*(C10 + C13) >> 8); B10 = t - ((319*C13) >> 8); B13 = t - ((170*C10) >> 8);
    t = (25*(C11 + C12) >> 8); B11 = t - ((-229*C12) >> 8); B12 = t - ((279*C11) >> 8);
    B16 = C16 + C23; B23 = C16 - C23; B17 = C17 + C22; B22 = C17 - C22; B18 = C18 + C21; B21 = C18 - C21; B19 = C19 + C20; B20 = C19 - C20; B24 = C24 + C31; B31 = C24 - C31; B25 = C25 + C30; B30 = C25 - C30; B26 = C26 + C29; B29 = C26 - C29; B27 = C27 + C28; B28 = C27 - C28;
    A0 = B0 + B15; A1 = B1 + B14; A2 = B2 + B13; A3 = B3 + B12; A4 = B4 + B11; A5 = B5 + B10; A6 = B6 + B9; A7 = B7 + B8; A8 = B7 - B8; A9 = B6 - B9; A10 = B5 - B10; A11 = B4 - B11; A12 = B3 - B12; A13 = B2 - B13; A14 = B1 - B14; A15 = B0 - B15;
    t = (171*(B16 + B31) >> 8); A16 = t - ((-17*B31) >> 8); A31 = t - ((361*B16) >> 8);
    t = (205*(B17 + B30) >> 8); A17 = t - ((358*B30) >> 8); A30 = t - ((53*B17) >> 8);
    t = (131*(B18 + B29) >> 8); A18 = t - ((-87*B29) >> 8); A29 = t - ((351*B18) >> 8);
    t = (231*(B19 + B28) >> 8); A19 = t - ((340*B28) >> 8); A28 = t - ((121*B19) >> 8);
    t = (86*(B20 + B27) >> 8); A20 = t - ((-154*B27) >> 8); A27 = t - ((327*B20) >> 8);
    t = (248*(B21 + B26) >> 8); A21 = t - ((310*B26) >> 8); A26 = t - ((186*B21) >> 8);
    t = (37*(B22 + B25) >> 8); A22 = t - ((-215*B25) >> 8); A25 = t - ((290*B22) >> 8);
    t = (255*(B23 + B24) >> 8); A23 = t - ((243*B24) >> 8); A24 = t - ((268*B23) >> 8);
    Y0 = A0 + A31; Y31 = A0 - A31; Y1 = A1 + A30; Y30 = A1 - A30; Y2 = A2 + A29; Y29 = A2 - A29; Y3 = A3 + A28; Y28 = A3 - A28; Y4 = A4 + A27; Y27 = A4 - A27; Y5 = A5 + A26; Y26 = A5 - A26; Y6 = A6 + A25; Y25 = A6 - A25; Y7 = A7 + A24; Y24 = A7 - A24; Y8 = A8 + A23; Y23 = A8 - A23; Y9 = A9 + A22; Y22 = A9 - A22; Y10 = A10 + A21; Y21 = A10 - A21; Y11 = A11 + A20; Y20 = A11 - A20; Y12 = A12 + A19; Y19 = A12 - A19; Y13 = A13 + A18; Y18 = A13 - A18; Y14 = A14 + A17; Y17 = A14 - A17; Y15 = A15 + A16; Y16 = A15 - A16;
    에 의하여 역변환값을 생성하는 것을 특징으로 하는 영상 역변환 방법.
  33. 제 31항에 있어서,
    상기 1차원 이산 코사인 역변환을 수행하는 단계는
    상기 N은 32, X0 내지 X31는 역변환되어야 할 입력값, A0 내지 A31, B0 내지 B31, C0 내지 C31, D0 내지 D31, E0 내지 E31, F0 내지 F31, G0 내지 G31은 중간값, t는 보조 변수, Y0 내지 Y31은 역변환된 값을 나타낸다고 할 때,
    E0= X0; F24 = X1; F12 = X2; G16 = -X3; F7 = X4; G31 = X5; F9 = X6; F26 = -X7; E3 = X8; F21 = X9; F14 = X10; G29 = X11; E5 = X12; G18 = -X13; E13 = X14; E22 = X15; E1 = X16; E25 = X17; E10 = X18; G19 = -X19; E6 = X20; G28 = -X21 ; F15 = X22; F20 = -X23; E2 = X24; F27 = -X25; F8 = X26; G30 = -X27; F4 = X28; G17 = -X29 ; F11 = X30; F23 = -X31; F17 = G17 - ((G16*3) >> 4); F16 = G16 + ((F17*25) >> 7); F19 = G19 - ((G18*59) >> 7); F18 = G18 + ((F19*171) >> 8); F29 = G29 - ((G28*59) >> 7); F28 = G28 + ((F29*171) >> 8); F31 = G31 - ((G30*3) >> 4); F30 = G30 + ((F31*25) >> 7); E4 = (F7 >> 1) - F4; E7 = F7 - E4; E9 = -F9 + ((F8*45) >> 7); E8 = F8 - ((E9*53) >> 7); E12 = F12 + (F11 >> 1); E11 = F11 - E12; E15 = F15 + ((F14*45) >> 7); E14 = F14 - ((E15*53) >> 7); E16 = F16 + F18; D18 = F16 - F18; D17 = F17 + F19; E19 = F17 - F19; E21 = F21 + ((F20*45) >> 7); E20 = F20 - ((E21*53) >> 7); E24 = F24 + (F23 >> 1); E23 = F23 - ((E24*255) >> 8); E27 = F27 + ((F26*45) >> 7); E26 = F26 - ((E27*53) >> 7); E28 = -F28 + F30; D30 = F28 + F30; D29 = -F29 + F31; E31 = F29 + F31; D1 = (E0 >> 1) - E1; D0 = E0 - D1; D3 = E3 + ((E2*45) >> 7); D2 = ((D3*53) >> 7)- E2; D4 = E4 + E6; D6 = E4 - E6; D5 = E7 - E5; D7 = E7 + E5; D8 = E8 + E14; D14 = E8 - E14; D9 = E9 + E15; D15 = E9 - E15; D10 = E10 + E11; D11 = E10 - E11; D12 = E12 + E13; D13 = E12 - E13; D16 = ((E16 - E19)*181) >> 8; D19 = ((E16 + E19)*181) >> 8; D20 = E20 + E26; D26 = E20 - E26; D21 = E21 + E27; D27 = E21 - E27; D22 = E22 + E23; D23 = E22 - E23; D24 = E24 + E25; D25 = E24 - E25; D28 = ((E28 - E31)*181) >> 8; D31 = ((E28 + E31)*181) >> 8; C0 = D0 + D3; C3 = D0 - D3; C1 = D1 + D2; C2 = D1 - D2; D7 = D7 + ((D4*77) >> 8); C4 = D4 - ((D7*71) >> 7); C7 = D7 + ((C4*77) >> 8); D6 = D6 + ((D5*25) >> 8); C5 = D5 - ((D6*49) >> 8); C6 = D6 + ((C5*25) >> 8); C8 = D8 + D11; C11 = D8 - D11; C9 = D9 + D10; C10 = D9 - D10; C12 = D12 + D15; C15 = D12 - D15; C13 = D13 + D14; C14 = D13 - D14; C16 = D16 + D28; C28 = D16 - D28; C17 = D17 + D29; C29 = D17 - D29; C18 = D18 + D30; C30 = D18 - D30; C19 = D19 + D31; C31 = D19 - D31; C20 = D20 + D23; C23 = D20 - D23; C21 = D21 + D22; C22 = D21 - D22; C24 = D24 + D27; C27 = D24 - D27; C25 = D25 + D26; C26 = D25 - D26; B0 = C0 + C7; B7 = C0 - C7; B1 = C1 + C6; B6 = C1 - C6; B2 = C2 + C5; B5 = C2 - C5; B3 = C3 + C4; B4 = C3 - C4; C15 = C15 + ((C8*91) >> 8); B8 = C8 - ((C15*81) >> 7); B15 = C15 + ((B8*91) >> 8); C9 = C9 + ((C14*153) >> 8); B14 = C14 - ((C9*225) >> 8); B9 = C9 + ((B14*153) >> 8); C13 = C13 + ((C10*37) >> 8); B10 = C10 - ((C13*37) >> 7); B13 = C13 + ((B10*37) >> 8); C11 = C11 + ((C12*29) >> 5); B12 = C12 - ((C11*127) >> 7); B11 = C11 + ((B12*29) >> 5); B16 = C16 + C23; B23 = C16 - C23; B17 = C17 + C22; B22 = C17 - C22; B18 = C18 + C21; B21 = C18 - C21; B19 = C19 + C20; B20 = C19 - C20; B24 = C24 + C31; B31 = C24 - C31; B25 = C25 + C30; B30 = C25 - C30; B26 = C26 + C29; B29 = C26 - C29; B27 = C27 + C28; B28 = C27 - C28; A0 = B0 + B15; A1 = B1 + B14; A2 = B2 + B13; A3 = B3 + B12; A4 = B4 + B11; A5 = B5 + B10; A6 = B6 + B9; A7 = B7 + B8; A8 = B7 - B8; A9 = B6 - B9; A10 = B5 - B10; A11 = B4 - B11; A12 = B3 - B12; A13 = B2 - B13; A14 = B1 - B14; A15 = B0 - B15; B16 = B16 + ((113*B31) >> 8); A31 = B31 - ((189*B16) >> 8); A16 = B16 + ((113*A31) >> 8); B17 = B17 - ((21*B30) >> 6); A30 = B30 + ((19*B17) >> 5); A17 = B17 - ((21*A30) >> 6); B18 = B18 + ((145*B29) >> 8); A29 = B29 - ((219*B18) >> 8); A18 = B18 + ((145*A29) >> 8); B19 = B19 - ((57*B28) >> 8); A28 = B28 + ((109*B19) >> 8); A19 = B19 - ((57*A28) >> 8); B20 = B20 + ((45*B27) >> 6); A27 = B27 - ((241*B20) >> 8); A20 = B20 + ((45*A27) >> 6); B21 = B21 - ((31*B26) >> 8); A26 = B26 + ((31*B21) >> 7); A21 = B21 - ((31*A26) >> 8); B22 = B22 + ((55*B25) >> 6); A25 = B25 - ((253*B22) >> 8); A22 = B22 + ((55*A25) >> 6); B23 = B23 - ((3*B24) >> 7); A24 = B24 + ((3*B23) >> 6); A23 = B23 - ((3*A24) >> 7);
    Y0 = A0 + A31; Y31 = A0 - A31; Y1 = A1 + A30; Y30 = A1 - A30; Y2 = A2 + A29; Y29 = A2 - A29; Y3 = A3 + A28; Y28 = A3 - A28; Y4 = A4 + A27; Y27 = A4 - A27; Y5 = A5 + A26; Y26 = A5 - A26; Y6 = A6 + A25; Y25 = A6 - A25; Y7 = A7 + A24; Y24 = A7 - A24; Y8 = A8 + A23; Y23 = A8 - A23; Y9 = A9 + A22; Y22 = A9 - A22; Y10 = A10 + A21; Y21 = A10 - A21; Y11 = A11 + A20; Y20 = A11 - A20; Y12 = A12 + A19; Y19 = A12 - A19; Y13 = A13 + A18; Y18 = A13 - A18; Y14 = A14 + A17; Y17 = A14 - A17; Y15 = A15 + A16; Y16 = A15 - A16
    에 의하여 역변환값을 생성하는 것을 특징으로 하는 영상 역변환 방법.
  34. 제 31항에 있어서,
    상기 역양자화하는 단계는
    상기 버터 플라이구조에 기초한 이산 코사인 변환에 이용되는 원래의 NxN 역변환 행렬과, 상기 변경된 버터 플라이 구조에 기초한 변경된 역변환 행렬 사이의 차이값을 보정하기 위하여 역스케일링 행렬 및 시프트 연산을 적용하여 역양자화를 수행하는 것을 특징으로 하는 영상 역변환 방법.
  35. 제 34항에 있어서,
    상기 역스케일링 행렬은
    각 i번째 행의 원소가 Si(i는 1부터 N까지의 정수)의 값을 갖는 NxN 크기의 중간 행렬의 각 원소와 상기 변경된 변환 행렬의 동일 위치의 원소들을 곱한 값과, 상기 원래의 NxN 변환 행렬 사이의 차이인 변환 오차 행렬을 획득하고, 상기 변환 오차 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 상기 Si 값들을 획득하며, 상기 획득된 Si값들을 적용한 상기 NxN 크기의 중간 행렬의 각 원소와 상기 중간 행렬의 전치 행렬의 동일 위치의 원소들을 곱한 행렬에 기초하여 생성된 것을 특징으로 하는 영상 역변환 방법.
  36. 제 34항에 있어서,
    상기 역스케일링 행렬은
    이산 코사인 변환에 이용되는 원래의 NxN 변환 행렬의 각 원소를 상기 변경된 변환 행렬의 동일 위치의 원소들로 나눔으로써 중간 행렬을 획득하고, 상기 획득된 중간 행렬의 각 원소와 상기 중간 행렬의 전치 행렬의 동일 위치의 원소를 곱하여 획득된 행렬인 것을 특징으로 하는 영상 역변환 방법.
  37. 영상의 역변환 장치에 있어서,
    복호화되는 영상을 구성하는 NxN(N은 정수) 크기의 블록의 1차원 이산 코사인 변환에 이용되는 NxN 변환 행렬을 구성하는 원소들을 N개의 변수들에 기초한 값들로 치환하여 치환된 NxN 변환 행렬을 생성하고, 상기 치환된 NxN 변환 행렬과 상기 치환된 NxN 변환 행렬의 전치 행렬의 곱셈 행렬을 획득하며, 상기 획득된 곱셈 행렬의 대각 성분을 제외한 나머지 원소들의 제곱합이 최소가 되도록 하는 상기 N개의 변수들을 획득하고, 상기 획득된 N개의 변수들에 기초한 값들로 치환된 NxN 변환 행렬의 역행렬인 NxN 역변환 행렬을 이용하여, 상기 NxN 크기의 블록의 역양자화된 변환 계수들을 역변환하는 역변환부를 포함하는 것을 특징으로 하는 영상 역변환 장치.
  38. 영상의 역변환 장치에 있어서,
    버터플라이 구조의 곱셈 인수 중 삼각 함수 성분을 유리수로 치환하고, 상기 버터플라이 구조의 4개의 곱셈 연산과 2개의 덧셈 연산 과정을 3개의 곱셈 연산과 3개의 덧셈 연산 과정으로 대체한 변경된 버터플라이 구조에 기초하여 복호화되는 NxN 크기(N은 정수)의 블록의 행 단위 및 열 단위 중 어느 하나에 대한 1차원 이산 코사인 역변환을 수행하는 역변환부를 포함하는 것을 특징으로 하는 영상 역변환 장치.
PCT/KR2010/000443 2009-01-22 2010-01-22 영상의 변환 방법 및 장치, 역변환 방법 및 장치 WO2010085125A2 (ko)

Priority Applications (2)

Application Number Priority Date Filing Date Title
KR1020107017851A KR101480412B1 (ko) 2009-01-22 2010-01-22 영상의 변환 방법 및 장치, 역변환 방법 및 장치
US13/188,868 US8483501B2 (en) 2009-01-22 2011-07-22 Method and device for transformation of image and method and device for reverse transformation of image

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US14637209P 2009-01-22 2009-01-22
US61/146,372 2009-01-22

Related Child Applications (1)

Application Number Title Priority Date Filing Date
US13/188,868 Continuation US8483501B2 (en) 2009-01-22 2011-07-22 Method and device for transformation of image and method and device for reverse transformation of image

Publications (3)

Publication Number Publication Date
WO2010085125A2 true WO2010085125A2 (ko) 2010-07-29
WO2010085125A9 WO2010085125A9 (ko) 2010-09-16
WO2010085125A3 WO2010085125A3 (ko) 2010-11-04

Family

ID=42356351

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/KR2010/000443 WO2010085125A2 (ko) 2009-01-22 2010-01-22 영상의 변환 방법 및 장치, 역변환 방법 및 장치

Country Status (3)

Country Link
US (1) US8483501B2 (ko)
KR (1) KR101480412B1 (ko)
WO (1) WO2010085125A2 (ko)

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
WO2012115487A2 (ko) * 2011-02-25 2012-08-30 삼성전자 주식회사 영상의 변환 및 역변환 방법, 및 이를 이용한 영상의 부호화 및 복호화 장치
CN109522125A (zh) * 2018-11-19 2019-03-26 郑州云海信息技术有限公司 一种矩阵乘积转置的加速方法、装置及处理器

Families Citing this family (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR102074601B1 (ko) 2012-02-29 2020-02-06 소니 주식회사 화상 처리 장치 및 방법, 및 기록 매체
KR101423083B1 (ko) * 2013-01-16 2014-07-25 한밭대학교 산학협력단 Ｈｅｖｃ 복호기용 역변환기 설계 방법
US10406729B2 (en) * 2016-08-29 2019-09-10 The Boeing Company Compression molding assembly and methods for molding a thermoplastic blocker door
JP2022508245A (ja) 2018-11-27 2022-01-19 オーピー ソリューションズ， エルエルシー 文脈的区分化および処理のためのブロックベースのピクチャ融合
CN113170133A (zh) * 2018-11-27 2021-07-23 Op方案有限责任公司 用于图片的基于块的空间活动度量

Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR970022846A (ko) * 1995-10-28 1997-05-30 구자홍 영상 압축장치의 역이산 코사인 변환방법 및 장치
KR20030053108A (ko) * 2001-12-22 2003-06-28 한국과학기술원 블록 이산코사인변환 영역에서의 영상 크기 변환 방법
KR100790846B1 (ko) * 2006-09-25 2008-01-02 광운대학교 산학협력단 영상처리의 정수 변환 방법 및 그의 프로세서

Family Cites Families (9)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6044176A (en) * 1996-11-12 2000-03-28 Samsung Electronics Co., Ltd. Method of performing inverse discrete cosine transform
US6137916A (en) * 1997-11-17 2000-10-24 Sony Electronics, Inc. Method and system for improved digital video data processing using 8-point discrete cosine transforms
US6215909B1 (en) * 1997-11-17 2001-04-10 Sony Electronics, Inc. Method and system for improved digital video data processing using 4-point discrete cosine transforms
US6160920A (en) * 1998-09-15 2000-12-12 Winbond Electronics Corp. Cosine transforming and quantizing device, method of reducing multiplication operations in a video compressing apparatus
US6445829B1 (en) * 1998-09-15 2002-09-03 Winbond Electronics Corp. Joint cosine transforming and quantizing device and joint inverse quantizing and inverse cosine transforming device
US6876704B2 (en) * 2001-05-16 2005-04-05 Qualcomm, Incorporated Apparatus and method for encoding and computing a discrete cosine transform using a butterfly processor
US6870885B2 (en) * 2001-05-16 2005-03-22 Qualcomm Incorporated Apparatus and method for decoding and computing a discrete cosine transform using a butterfly processor
US6882685B2 (en) * 2001-09-18 2005-04-19 Microsoft Corporation Block transform and quantization for image and video coding
US8548265B2 (en) * 2006-01-05 2013-10-01 Fastvdo, Llc Fast multiplierless integer invertible transforms

Patent Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR970022846A (ko) * 1995-10-28 1997-05-30 구자홍 영상 압축장치의 역이산 코사인 변환방법 및 장치
KR20030053108A (ko) * 2001-12-22 2003-06-28 한국과학기술원 블록 이산코사인변환 영역에서의 영상 크기 변환 방법
KR100790846B1 (ko) * 2006-09-25 2008-01-02 광운대학교 산학협력단 영상처리의 정수 변환 방법 및 그의 프로세서

Cited By (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
WO2012115487A2 (ko) * 2011-02-25 2012-08-30 삼성전자 주식회사 영상의 변환 및 역변환 방법, 및 이를 이용한 영상의 부호화 및 복호화 장치
WO2012115487A3 (ko) * 2011-02-25 2012-12-13 삼성전자 주식회사 영상의 변환 및 역변환 방법, 및 이를 이용한 영상의 부호화 및 복호화 장치
CN109522125A (zh) * 2018-11-19 2019-03-26 郑州云海信息技术有限公司 一种矩阵乘积转置的加速方法、装置及处理器
CN109522125B (zh) * 2018-11-19 2021-12-03 郑州云海信息技术有限公司 一种矩阵乘积转置的加速方法、装置及处理器

Also Published As

Publication number Publication date
US8483501B2 (en) 2013-07-09
WO2010085125A3 (ko) 2010-11-04
US20120020583A1 (en) 2012-01-26
WO2010085125A9 (ko) 2010-09-16
KR20110114429A (ko) 2011-10-19
KR101480412B1 (ko) 2015-01-09

Similar Documents

Publication Publication Date Title
WO2012044075A2 (ko) 영상의 변환 방법 및 장치, 역변환 방법 및 장치
WO2020149648A1 (ko) 변환 스킵 플래그를 이용한 영상 코딩 방법 및 장치
WO2020262995A1 (ko) 2차 변환을 이용하는 비디오 신호 처리 방법 및 장치
WO2012044076A2 (ko) 비디오의 부호화 방법 및 장치, 복호화 방법 및 장치
WO2010085125A9 (ko) 영상의 변환 방법 및 장치, 역변환 방법 및 장치
WO2017065525A2 (ko) 영상을 부호화 또는 복호화하는 방법 및 장치
WO2019235896A1 (ko) 적응적 모션 벡터 레졸루션을 이용하는 비디오 신호 처리 방법 및 장치
WO2020080827A1 (en) Ai encoding apparatus and operation method of the same, and ai decoding apparatus and operation method of the same
WO2018030599A1 (ko) 인트라 예측 모드 기반 영상 처리 방법 및 이를 위한 장치
WO2017018664A1 (ko) 인트라 예측 모드 기반 영상 처리 방법 및 이를 위한 장치
WO2020080698A1 (ko) 영상의 주관적 품질을 평가하는 방법 및 장치
WO2018038554A1 (ko) 이차 변환을 이용한 비디오 신호의 인코딩/디코딩 방법 및 장치
WO2018047995A1 (ko) 인트라 예측 모드 기반 영상 처리 방법 및 이를 위한 장치
WO2011068360A2 (ko) 고해상도 영상의 부호화/복호화 방법 및 이를 수행하는 장치
WO2013157825A1 (ko) 영상 부호화/복호화 방법 및 장치
WO2020071616A1 (ko) Cclm에 기반한 인트라 예측 방법 및 그 장치
WO2018124333A1 (ko) 인트라 예측 모드 기반 영상 처리 방법 및 이를 위한 장치
WO2016195455A1 (ko) 그래프 기반 변환을 이용하여 비디오 신호를 처리하는 방법 및 장치
WO2018105759A1 (ko) 영상 부호화/복호화 방법 및 이를 위한 장치
WO2020111843A1 (ko) 화면 내 예측 필터링을 이용한 비디오 신호 처리 방법 및 장치
WO2021054797A1 (ko) 스케일링 프로세스를 사용하는 비디오 신호 처리 방법 및 장치
WO2020171681A1 (ko) 인트라 예측 기반 비디오 신호 처리 방법 및 장치
WO2020080782A1 (en) Artificial intelligence (ai) encoding device and operating method thereof and ai decoding device and operating method thereof
EP3868097A1 (en) Artificial intelligence (ai) encoding device and operating method thereof and ai decoding device and operating method thereof
WO2011133008A2 (ko) 영상의 변환 방법 및 장치, 역변환 방법 및 장치

Legal Events

Date Code Title Description
ENP Entry into the national phase

Ref document number: 20107017851

Country of ref document: KR

Kind code of ref document: A

121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 10733678

Country of ref document: EP

Kind code of ref document: A2

NENP Non-entry into the national phase

Ref country code: DE

122 Ep: pct application non-entry in european phase

Ref document number: 10733678

Country of ref document: EP

Kind code of ref document: A2