Abstract:
The present invention provides a system and method for adaptively compensating distortion caused by video compression, the method first conducts an edge texture detection and block boundary detection to an image, classifies the area where the pixels to be processed is located to determine whether the pixel is located at a ringing artifact prone area or near the block boundary with blocking artifact. Next, according to the area of the pixel to be processed and the degree of distortion, the present invention adaptively compensate the distortion using different filtering strategies, so as to improve image effect of low bit-rate transmission at the display end, so that a real time requirement that playing at a high-definition, and ultra high-definition display is satisfied.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
     This application is a continuation of International Application No. PCT/CN2014/076078, filed on Apr. 24, 2014, which claims priority to Chinese Patent Application No. 201410095798.2, filed on Mar. 14, 2014, both of which are hereby incorporated by reference in their entireties. 
    
    
     FIELD OF INVENTION 
     The present invention relates to the technical field of digital video image processing and display and, in particular, relates to a system and a method for adaptively compensating distortion caused by video compression based on image feature detection, which can protect details of original image. 
     BACKGROUND OF INVENTION 
     With the rapid development of internet television and smart television, video content source of digital television is increasingly diversified, wherein online video has become one of the major video contents being watched on television. Due to the limitations of certain factors such as bandwidth and media storage, compression and decompression technology are applied to online video for removing redundant information so as to achieve a low bit-rate transmission, compression standard of which includes video coding and decoding standard of block-based discrete cosine transform (Block-based Discrete Cosine Transform, BDCT) such as MPEG-4 Visual, H.264/AVC, AVS and so on. 
     However, online video is affected by factors like transmission manner and code-rate control during transmission process, the content of original video image is subjected to distortion of different extents. Positive and negative DCT transformation itself is lossless to video image, however, quantization and inverse quantization during a coding process are main reasons in generating distortion during compression. The distortion caused by video compression primarily includes ringing artifacts and blocking artifact. Near edges of an image, coarse quantization applied to high-frequency information of an image would result in ringing artifacts; in a block-based coding mode, since the correlation between adjacent blocks during block coding is not considered, quantization differences between blocks leads to inconsistency between the blocks, thereby generating blocking artifacts. If such low quality video is displayed on a large-screen flat-panel television, user&#39;s visual experience will be seriously affected. 
     In the existing technology of ringing artifact suppression, US patent publication No. U.S. Pat. No. 7,894,685B2 discloses a method and an apparatus for reducing ringing artifact. The method classifies pixels according to information like mean absolute deviation (Mean Absolute Deviation, MAD) and sum of gradients of pixels&#39; brightness, based on this, counts the number of pixels in flat area and at edges of strong/weak within a 8*8 coding-decoding block, finds an edge block satisfying the conditions and then conducts a Sigma filtering to non-edge flat pixels within the block so as to reduce the ringing artifact. The patent requires coding-decoding information like quantization parameter (Quantization Parameter, QP) to control filtering strength, in addition, the process method based on an 8*8 block is not well applicable for many universal international video coding standards. Therefore, when coding-decoding information like QP is unknown or block with a variable size is adopted during coding-decoding, the effect of the method will be restricted. In other technologies of ringing artifact suppression of the prior art, either image details are blurred while effectively reducing ringing artifact, or effect of ringing artifact reduction is poor while effectively protecting the detail information, i.e., it is difficult to keep a balance therebetween. 
     Existing method for detecting blocking artifact mainly conducts a block boundary strength detection when the location of block boundary is known. Due to the diversity of original resolution and coding-decoding standards in online video, the video might have already been processed when arriving at the display end, for example, being simply scaling or shifted to any direction. In this case, the result of detecting the block strength at a known block location is certainly inaccurate. 
     In conclusion, it is necessary to propose a method having an improved robustness, which effectively reduces ringing artifact and blocking artifact while protecting important original information such as edge information and texture information. 
     SUMMARY OF INVENTION 
     An objective of the present invention is to provide a system and a method for adaptively compensating distortion caused by video compression, to overcome the defects of the prior art; the present invention effectively compensates the distortion caused by compression, meanwhile enhancing the protection of information of edges and details, so that image effect of an online video is improved, to satisfy the requirement of playing on a displayer with high-definition or even ultra-high-definition. To improve the robustness, the present invention is neither limited to video coding-decoding information and coding-decoding standards, nor limited to video source image shifting or a small amplitude scaling. 
     The following technical schemes are adopted in the present invention to achieve the above objective: 
     Firstly, the present invention conducts a feature detection on an input video image, classifies image pixels, and locates a ringing artifact prone area and blocking artifact filtering area; next, it adaptively filters different categories of pixels that satisfies the condition within the area to compensate distortion caused by compression, however, it does not filter the pixels located at the edges and textures to retain important original information. 
     The present invention proposes a system for adaptively compensating distortion caused by video compression, the system includes an edge detector, a flat/texture detector, a ringing artifact area locator, a line detector, a block boundary detector, a blocking artifact filtering area locator, a blocking artifact suppressing enable judge, an adaptive mean filter, a filtering selector and an output fusion. 
     Input ends of the edge detector, the flat/texture detector, the line detector, the block boundary detector, the adaptive mean filter, the filtering selector and the output fusion are connected to input port of a video image; output ends of the edge detector and the flat/texture detector are both connected to an input end of the ringing artifact area locator; an output end of the line detector is connected to an input end of the blocking artifact filtering area locator; an output end of the block boundary detector is connected to an output end of the blocking artifact filtering area locator and is connected to an input end of the blocking artifact suppressing enable judge; output ends of the ringing artifact area locator, the blocking artifact filtering area locator and the adaptive mean filter are connected to the input end of the filtering selector; an output end of the filtering selector is connected to an input end of the output fusion. 
     The further improvement of the present invention lies in that: 
     The edge detector is configured to obtain edge and strength information of an input video image; 
     The flat/texture detector is configured to obtain flat/textural information from the input video image; 
     The line detector is configured to facilitate detecting and retaining of weak single pixel lines in a flat area; 
     The block boundary detector is configured to detect location and strength information of a block boundary having blocking artifact in the input video image; 
     The ringing artifact area locator is configured to locate a ringing artifact prone area and label filtering strength thereof, according to the edge information and flat/texture information; 
     The blocking artifact filtering area locator is configured to locate a blocking artifact filtering area and label the filtering strength thereof, according to the edge information, the flat/texture information, the single-pixel line information and block boundary information; 
     The blocking artifact suppressing filtering enable judge is configured to calculate a ratio of block boundary in the present frame to the image of a whole frame, turn on the blocking artifact suppressing filtering strength enable when the blocking artifact exceeds a threshold value, for use in a next frame; 
     The adaptive mean filter is configured to generate results of filtering with different strengths; 
     The filtering selector is configured to select corresponding filtering results from the results of the original input video image and the adaptive mean filter, according to the results from the ringing artifact area locator, the blocking artifact filtering area locator and the blocking artifact suppressing filtering enable obtained from a previous frame; 
     The output fusion finally output a weighted sum of an original value and the filtering results of pixel to be possessed of the input video image; 
     The present invention proposes a method for adaptively compensating distortion caused by video compression, the method includes the following steps: 
     Edge detection, detecting edge information of an input video image, and conducting erosion and dilation to obtain edge and strength information; 
     Flat/texture detection, obtaining flat/texture information of the input video image; 
     Line detection, detecting single pixel line of the input video image; 
     Block boundary detection, detecting location and strength information of the block boundary of the input video image with blocking artifact; 
     After excluding edge and texture information, locating a ringing artifact prone area and labeling required filtering strength according to the edge and flat/texture feature information; 
     After excluding pixels on weak single pixel line of the edge, texture and flat area, locating a blocking artifact filtering area and labeling a required filtering strength according to detected block boundary information; 
     Calculating a ratio of the detected block boundary of an image in the present frame to the image of a whole frame according to a block boundary result detected by block boundary detector, when a blocking artifact exceeds a threshold value, turning on blocking artifact suppressing filtering strength enable deblk_glen N  for use in a next frame; 
     Selecting corresponding filtering results output from adaptive filtering coefficients according to the results from the above feature detection and the blocking artifact suppressing filtering enable obtained from a previous frame; and 
     Outputting a weighted sum of as the original value of pixel to be processed and the filtering results, the value of weighted coefficients is decided by the degree of difference between the pixel to be processed and surrounding pixels. 
     Compared with the prior art, the present invention has the following technical advantages and effects: 
     1. The present invention can be used at video decoder end, or at a video display processing end which is relatively independent from a video decoder. The present invention is compatible with many present video coding-decoding standards, and does not require known coding-decoding information such as QP and is also not limited to the selection of the size of coding block; 
     2. The present invention effectively compensates the distortion caused by compression, and meanwhile protecting the original information such as edge and textural information; 
     3. In the present invention, block boundary information is detected without a requirement for predicting the location of the block boundary in advance. When the video image undergoes a pre-treatment of shifting or small-amplitude scaling, the detection result of block boundary information of the present invention correlates to that of the block boundary of an actual image, so that no false detection will occur; 
     4. The present invention is based on spatial information processing, having low complexity and is easily achieved by hardware so as to satisfy a real-time requirement. 
    
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
         FIG. 1  is a block diagram of an embodiment illustrating a method for compensating distortion caused by compression according to the present invention being processed at a video display end; 
         FIG. 2  is a block diagram of an embodiment illustrating a method and a system for compensating distortion caused by compression of the present invention; 
         FIG. 3  is a schematic diagram showing gradient operators A v , A h , A r  and A l  being detected in four directions by Sobel edge detection; 
         FIG. 4  is a 3×3 pixels brightness matrix X for line detection, edge detection and flat/texture detection, (2,2) is the location of pixel to be processed; 
         FIG. 5  is a schematic diagram of an implementing method for locating the ringing artifact area in an embodiment of the present invention; 
         FIG. 6  is a schematic diagram of a method for detecting single-pixel line, which mainly detects the single-pixel line in the vertical or horizontal direction; 
         FIG. 7( a )  and  FIG. 7( b )  are schematic diagrams of a method for detecting the block boundary in embodiments of the present invention,  FIG. 7( a )  shows an assumed brightness relationship between six adjacent pixels P 1 , P 2 , P 3 , Q 3 , Q 2  and Q 1  which are perpendicular to the block boundary;  FIG. 7( b )  shows the extra conditions which need to be satisfied during blocking artifact detection process, and the block boundary with blocking artifact can only be determined after satisfying any one of the four conditions; and 
         FIG. 8  is a 4×4 window used for locating the blocking artifact filtering area, (3,3) refers to the location of the pixel to be processed. 
     
    
    
     DETAILED DESCRIPTION OF EMBODIMENTS 
     The present invention can be used in combination with a video decoder, and also can act as a part of video display process independently. The present invention will be further described in detail with reference to the accompany drawings and embodiments. 
       FIG. 1  is a block diagram of an embodiment of a method for compensating the distortion caused by compression, the method is used in a system for compensating the distortion caused by compression during video display process according to the present invention. After being compressed by video encoding  101 , original video source  100  is transmitted to video decoding  103  at a receiving end of a user through a communication channel  102 . A damaged decoded video as the input of video display process  104  undergoes a distortion compensation of suppressing ringing artifact  105  and suppressing blocking artifact  106  and other video display process, then is sent to video output  107  for display. 
     The  200  of  FIG. 2  is a block diagram of an embodiment of a system for compensating distortion caused by compression as given in  FIG. 1 . The present invention proposes a system for adaptively compensating distortion caused by video compression, the system including an edge detector  201 , a flat/texture detector  202 , a ringing artifact area locator  203 , a line detector  204 , a block boundary detector  205 , a blocking artifact filtering area locator  206 , a blocking artifact suppressing enable judge  207 , an adaptive mean filter  208 , a filtering selector  209  and an output fusion  210 . 
     Input video signal enters into input ends of the edge detector  201 , the flat/texture detector  202 , the line detector  204 , the block boundary detector  205 , the adaptive mean filter  208 , the filtering selector  209 , the output fusion  210 ; output ends of the edge detector  201  and the flat/texture detector  202  are both connected to the ringing artifact area locator  203 ; an output end of the line detector  204  is connected to an input end of the blocking artifact filtering area locator  206 ; an output end of the block boundary detector  205  is connected to an input end of the blocking artifact filtering area locator  206  and to an input end of the blocking artifact suppressing enable judge  207 ; output ends of the ringing artifact area locator  203 , the blocking artifact filtering area locator  206 , and the adaptive mean filter  208  are connected to the input end of the filtering selector  209 ; an output end of the filtering selector  209  is connected to an input end of the output fusion  210 . 
     The edge detector  201 , the flat/texture detector  202 , the line detector  204  and the block boundary detector  205  are four major feature detectors of system  200  for adaptively compensating distortion caused by video compression, of which the edge detector  201  detects edge information of an input video image and conducts erosion and dilation to obtain relatively accurate edge and strength information; the flat/texture detector  202  obtains flat/textural information from the input video image to retain the textural information and to facilitate locating the distortion prone areas; the line detector  204  detects the single-pixel line from the input video image to help retain single-pixel weak line in a flat area, avoiding loss of layers and details of the video image due to false filtering while conducting a blocking artifact suppressing process; the block boundary detector  205  detects the location and strength information of block boundary of an input video image with blocking artifact. By analyzing the detection results from these four feature detectors, the present invention can perfectly protect important feature information such as edge and texture of the original image and the single-pixel weak lines in a flat area, thereby preventing a secondary damage to a damaged video image and providing a dependency for locating the artifact area and deciding filtering strength. 
     After excluding important information like edge and textural information, the ringing artifact area locator  203  locates the ringing artifact prone area and labels required filtering strength according to the edge and flat feature information; after removing pixels at the edge, texture as well as at the single-pixel weak line in flat areas, the blocking artifact area locator  206  locates blocking artifact filtering area and labels required filtering strength according to the detected block boundary information; the blocking artifact suppressing enable judge  207  obtains the block boundary results from the block boundary detector  205 , calculates the ratio of block boundary to the image of the whole frame in the present frame, when the blocking artifact is relatively serious, turn on the blocking artifact suppressing filtering strength enable deblk_glen N  for use of the next frame. 
     The adaptive filter  208  generates adaptive filtering results with different strengths for selection; the filtering selector  209  selects the corresponding adaptive filtering result according to the result of the above feature detection and the blocking artifact suppressing filtering enable deblk_glen N−1  obtained from the previous frame; the output fusion  210  achieves a weighted sum of the original values of the pixel to be processed and the filtering result, the value of the weight coefficient depends on the degree of difference between the pixel to be processed and the surrounding pixels so as to better protect the original image. 
       FIG. 3  shows gradient operators A v , A h , A r  and A l  of four directions in Sobel edge detection used by the edge detector  201  of embodiment  200  in the present invention. Calculate gradient values G v , G h , G r  and G l  of four directions in combination with a 3×3 pixel brightness matrix X of  FIG. 4 , and then take the maximum value from gradient absolute value as G max , compare, respectively, with the threshold values SOBEL_HIGH_TH ( 270 ) and SOBEL_LOW_TH (  65 ), and classify the image pixels to obtain whole edge information and strong edge information, as shown in equations (1) and (2).
 
 G   max =max(| G   h   |, |G   v   |, |G   r |, |G l |)   (1)
 
edge_tmp( i, j )=( G   max &gt;SOBEL_LOW_TH)?1:0
 
stedge_tmp( i, j )=( G   max &gt;SOBEL_HIGH_TH)?1:0  (2)
 
     In the equations, edge_tmp(i, j) and stedge_tmp(i, j) are the whole edge information and the strong edge information of a pixel at the location (i, j) of an image respectively. 
     Due to the interference such as artifact, the result from above edge detection is not accurate to some extent. Thus, the edge detector  201  further conducts erosion and dilation to the result obtained from the Sobel edge detection so as to obtain relatively accurate edge information. The specific process of erosion and dilation is shown in equations (3) and (4). The final output of whole edge information by the edge detector  201  is shown in equation (5). 
     
       
         
           
             
               
                 
                   
                     edge_corrosion 
                     ⁢ 
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       edge_tmp 
                       ⁢ 
                       
                         ( 
                         
                           i 
                           , 
                           j 
                         
                         ) 
                       
                     
                     &amp;&amp; 
                     
                       ( 
                       
                         
                           
                             ∑ 
                             
                               s 
                               = 
                               
                                 - 
                                 1 
                               
                             
                             1 
                           
                           ⁢ 
                           
                             
                               ∑ 
                               
                                 t 
                                 = 
                                 
                                   - 
                                   1 
                                 
                               
                               1 
                             
                             ⁢ 
                             
                               edge_tmp 
                               ⁢ 
                               
                                 ( 
                                 
                                   
                                     i 
                                     + 
                                     s 
                                   
                                   , 
                                   
                                     j 
                                     + 
                                     t 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                         ≥ 
                         3 
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
             
               
                 
                   
                     edge_expansion 
                     ⁢ 
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       [ 
                       
                         ! 
                         
                           edge_tmp 
                           ⁢ 
                           
                             ( 
                             
                               i 
                               , 
                               j 
                             
                             ) 
                           
                         
                       
                       ] 
                     
                     &amp;&amp; 
                     
                       { 
                       
                         
                           [ 
                           
                             
                               edge_tmp 
                               ⁢ 
                               
                                 ( 
                                 
                                   
                                     i 
                                     - 
                                     1 
                                   
                                   , 
                                   
                                     j 
                                     - 
                                     1 
                                   
                                 
                                 ) 
                               
                             
                             &amp;&amp; 
                             
                               edge_tmp 
                               ⁢ 
                               
                                 ( 
                                 
                                   
                                     i 
                                     + 
                                     1 
                                   
                                   , 
                                   
                                     j 
                                     + 
                                     1 
                                   
                                 
                                 ) 
                               
                             
                           
                           ] 
                         
                         ⁢ 
                         
                           
                              
                              
                           
                           ⁡ 
                           
                             [ 
                             
                               
                                 edge_tmp 
                                 ⁢ 
                                 
                                   ( 
                                   
                                     i 
                                     , 
                                     
                                       j 
                                       - 
                                       1 
                                     
                                   
                                   ) 
                                 
                               
                               &amp;&amp; 
                               
                                 edge_tmp 
                                 ⁢ 
                                 
                                   ( 
                                   
                                     i 
                                     , 
                                     
                                       j 
                                       + 
                                       1 
                                     
                                   
                                   ) 
                                 
                               
                             
                             ] 
                           
                         
                         ⁢ 
                         
                           
                              
                              
                           
                           ⁡ 
                           
                             [ 
                             
                               
                                 edge_tmp 
                                 ⁢ 
                                 
                                   ( 
                                   
                                     
                                       i 
                                       + 
                                       1 
                                     
                                     , 
                                     
                                       j 
                                       - 
                                       1 
                                     
                                   
                                   ) 
                                 
                               
                               &amp;&amp; 
                               
                                 edge_tmp 
                                 ⁢ 
                                 
                                   ( 
                                   
                                     
                                       i 
                                       - 
                                       1 
                                     
                                     , 
                                     
                                       j 
                                       + 
                                       1 
                                     
                                   
                                   ) 
                                 
                               
                             
                             ] 
                           
                         
                         ⁢ 
                         
                           
                              
                              
                           
                           ⁡ 
                           
                             [ 
                             
                               
                                 edge_tmp 
                                 ⁢ 
                                 
                                   ( 
                                   
                                     
                                       i 
                                       - 
                                       1 
                                     
                                     , 
                                     j 
                                   
                                   ) 
                                 
                               
                               &amp;&amp; 
                               
                                 edge_tmp 
                                 ⁢ 
                                 
                                   ( 
                                   
                                     
                                       i 
                                       + 
                                       1 
                                     
                                     , 
                                     j 
                                   
                                   ) 
                                 
                               
                             
                             ] 
                           
                         
                       
                       } 
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
             
               
                 
                   
                     edge_map 
                     ⁢ 
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     edge_corriosion 
                     ⁢ 
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                     ⁢ 
                     
                        
                        
                     
                     ⁢ 
                     edge_expansion 
                     ⁢ 
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
     In the equations, edge_corrosion(i, j) is the whole edge information of pixel at location (i, j) of an image after erosion, edge_expansion(i, j) is the whole edge information of a pixel at location of (i, j) of an image after dilation, and edge_map(i, j) is relatively accurate whole edge information of a pixel at location of (i, j) of an image output by the edge detector  201 . 
     Similarly, conduct the same dilation and erosion process to the strong edge information. The edge detector  201  outputs strong edge information of stedge_map(i, j) of a pixel at location of (i, j) of an image. 
     The flat/texture detector  202  of the embodiment of the present invention performs mathematical statistics to brightness value of surrounding pixels of the pixel to be processed. In this method, a brightness mean value μ and a brightness mean absolute deviation MAD of a 3×3 pixel brightness matrix X is calculated to analyze brightness change of the matrix where the pixel to be processed is located, as shown in equations (6) and (7). 
     
       
         
           
             
               
                 
                   μ 
                   = 
                   
                     
                       1 
                       9 
                     
                     ⁢ 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         3 
                       
                       ⁢ 
                       
                         
                           ∑ 
                           
                             j 
                             = 
                             1 
                           
                           3 
                         
                         ⁢ 
                         
                           X 
                           ⁡ 
                           
                             ( 
                             
                               i 
                               , 
                               j 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
             
               
                 
                   MAD 
                   = 
                   
                     
                       1 
                       9 
                     
                     ⁢ 
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         3 
                       
                       ⁢ 
                       
                         
                           ∑ 
                           
                             j 
                             = 
                             1 
                           
                           3 
                         
                         ⁢ 
                         
                            
                           
                             
                               X 
                               ⁡ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                             - 
                             μ 
                           
                            
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
     Compare the calculated brightness change value with defined threshold values TEXTURE_HIGH_TH (16), 2·TEXTURE_LOW_TH and TEXTURE_LOW_TH (2), if the brightness mean absolute deviation MAD is relatively large, it represents that the pixel to be processed is in a textural area; if the brightness mean absolute deviation MAD is relatively small, it represents that the pixel to be processed is in a flat area. 
     
       
         
           
             
               
                 
                   
                     texture_map 
                     ⁢ 
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             3 
                             , 
                           
                         
                         
                           
                             
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               MAD 
                             
                             ≥ 
                             
                               TEXTURE_HIGH 
                               ⁢ 
                               _TH 
                             
                           
                         
                       
                       
                         
                           
                             2 
                             , 
                           
                         
                         
                           
                             
                               else 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               MAD 
                             
                             ≥ 
                             
                               
                                 2 
                                 · 
                                 TEXTURE_LOW 
                               
                               ⁢ 
                               _TH 
                             
                           
                         
                       
                       
                         
                           
                             1 
                             , 
                           
                         
                         
                           
                             
                               else 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               MAD 
                             
                             ≥ 
                             
                               TEXTURE_LOW 
                               ⁢ 
                               _TH 
                             
                           
                         
                       
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           others 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
     In the equation, texture_map(i, j) represents a textural degree of a pixel at location (i, j) of an image, the smaller the value represents that the pixel to be processed is located in even flatter area. 
       FIG. 5  shows a method for implementing the ringing artifact area locator  203  in the embodiment  200  of the present invention. The method conducts an overall analysis to the above obtained edge information and flat/textural information in a 7×11 window, so as to judge whether the pixel to be processed is located in a ringing artifact area and to determine the degree of significance, as shown in equation (9). 
     
       
         
           
             
               
                 
                   
                     ring_map 
                     ⁢ 
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             3 
                             , 
                           
                         
                         
                           
                             
                               if 
                               ⁢ 
                               
                                   
                               
                               [ 
                               
                                 
                                   edge_map 
                                   ⁢ 
                                   
                                     ( 
                                     
                                       i 
                                       , 
                                       j 
                                     
                                     ) 
                                   
                                 
                                 = 
                                 1 
                               
                               ] 
                             
                             ⁢ 
                             
                               
                                  
                                  
                               
                               ⁡ 
                               
                                 [ 
                                 
                                   
                                     texture_map 
                                     ⁢ 
                                     
                                       ( 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                   = 
                                   2 
                                 
                                 ] 
                               
                             
                           
                         
                       
                       
                         
                           
                             2 
                             , 
                           
                         
                         
                           
                             
                               else 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 
                                   ∑ 
                                   
                                     s 
                                     = 
                                     
                                       - 
                                       3 
                                     
                                   
                                   3 
                                 
                                 ⁢ 
                                 
                                   
                                     ∑ 
                                     
                                       t 
                                       = 
                                       
                                         - 
                                         3 
                                       
                                     
                                     3 
                                   
                                   ⁢ 
                                   
                                     stedge_map 
                                     ⁢ 
                                     
                                       ( 
                                       
                                         
                                           i 
                                           + 
                                           s 
                                         
                                         , 
                                         
                                           j 
                                           + 
                                           t 
                                         
                                       
                                       ) 
                                     
                                   
                                 
                               
                             
                             ≥ 
                             3 
                           
                         
                       
                       
                         
                           
                             1 
                             , 
                           
                         
                         
                           
                             
                               else 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 
                                   ∑ 
                                   
                                     s 
                                     = 
                                     
                                       - 
                                       3 
                                     
                                   
                                   3 
                                 
                                 ⁢ 
                                 
                                   
                                     ∑ 
                                     
                                       t 
                                       = 
                                       
                                         - 
                                         5 
                                       
                                     
                                     5 
                                   
                                   ⁢ 
                                   
                                     edge_map 
                                     ⁢ 
                                     
                                       ( 
                                       
                                         
                                           i 
                                           + 
                                           s 
                                         
                                         , 
                                         
                                           j 
                                           + 
                                           t 
                                         
                                       
                                       ) 
                                     
                                   
                                 
                               
                             
                             ≥ 
                             5 
                           
                         
                       
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           others 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
     In the equation, ring_map(i, j) represents the ringing artifact condition of a pixel at location of (i, j) of an image: if ring_map(i, j) is equal to 3, it represents that the pixel to be processed is located at the edge or a textural area, which is required to be retained instead of being filtered; if ring_map(i, j) is equal to 2, it represents that the pixel to be processed is close to a strong edge, since the ringing artifact is more serious when close to the strong edge, thus a stronger filtering method is required to suppress the ringing artifact; if ring_map(i, j) is equal to 1, it represents that a pixel to be processed is close to a weak edge, a weaker filtering method is required to suppress the ringing artifact; and if ring_map(i, j) is equal to 0, it represents that a pixel to be processed is not a pixel having ringing artifact, the suppression of ringing artifact is not required. 
       FIG. 6  shows a method for implementing single-pixel line detection by the line detector  204  of the embodiment  200  of the present invention. Taking a single-pixel line in a vertical direction as an example, when the conditions as shown in  FIG. 6( a )  and  FIG. 6( b )  are satisfied, i.e., the pixels A 1 , A 2  and A 3  in continuous three rows are simultaneously and respectively smaller or greater than D 1  and E 1 , D 2  and E 2 , and D 3  and E 3  with LINE_TH1, and the difference between the maximum value and the minimum value of A 1 , A 2 , and A 3  is smaller than LINE_TH2, then the pixel at the present location is located in a vertical single-pixel line, vline_map(i, j) is labeled as 1. Likewise, when the conditions shown in  FIG. 6( c )  and  FIG. 6( d )  are satisfied, i.e., the pixels A 4 , A 5  and A 6  in continuous three rows are simultaneously and respectively smaller or greater than B 1  and C 1 , B 2  and C 2 , and B 3  and C 3  with LINE_TH1, the difference between the maximum value and the minimum value of A 4 , A 5  and A 6  is smaller than LINE_TH2, the pixel at the present location is located in a horizontal single-pixel line, hline_map(i, j) is labeled as 1. In the embodiment of the present invention, both threshold values LINE_TH1 and LINE_TH2 are defined as 2. A final output line_map(i, j) of the line detector  204  is obtained from equation (10).
 
line_map( i, j )= v line_map( i, j )∥ h line_map( i, j )  (10)
 
       FIG. 7  shows a method of the block boundary detector  205  of embodiment  200  of the present invention. Taking a vertical block boundary as an example,  FIG. 7( a )  shows a brightness relationship between six assumed adjacent pixels P 1 , P 2 , P 3 , Q 3 , Q 2  and Q 1  close to the block boundary: a brightness jumping change of a certain extent exists between P 3  and Q 3  locating at the left-side and right-side of the block boundary with blocking artifact, whereas brightness change between the adjacent pixels locating at the left-side and right-side of the block boundary a relatively small. According to this feature of block boundary, the embodiment of the present invention determines whether the present pixel is located at the block boundary by observing gradient changes between adjacent pixels, and determines the strength of block boundary by observing the jumping change of pixels P 3  and Q 3  at both sides of block boundary. If P 1 , P 2 , P 3 , Q 3 , Q 2  and Q 1  simultaneously satisfy the three conditions of equation (11), a vertical block boundary may exist between pixels P 3  and Q 3 .
 
Condition1: BLK_MID_TH&lt;D 3 &lt;BLK_HIGH_TH;
 
Condition2: max( D   1   , D   2   , D   4   , D   5 )&lt;BLK_LOW_TH;
 
Condition3:  D   3 &gt;max( D   1   , D   2   , D   4   , D   5 ).  (11)
 
     In the equations, D 1 , D 2 , D 3 , D 4  and D 5  respectively represent |P 1 −P 2 |, |P 2 −P 3 |, |P 3 −Q 3 |, |Q 3 −Q 2 | and |Q 2 −Q 1 |. BLK_LOW_TH (2), BLK_MID_TH (1) and BLK_HIGH_TH (15) are defined experience threshold values. 
     Based on the above, the embodiment of the present invention adopts four conditions of  FIG. 7( b )  to determine whether blocking artifact exists between P 3  and Q 3 . The row i of  FIG. 7( b )  denotes the present row, the dotted line denotes an assumed location of a vertical block boundary, and the gray area are four continuous rows satisfying the conditions. In a 7×6 window, according to the continuity of the block boundary in a vertical direction, only if at least four continuous rows satisfy the three conditions of equation (53) and satisfy that P 3 −Q 3  at least in four continuous rows has the same mathematical symbol, then it represents that the pixel to be processed is located at a vertical block boundary with blocking artifact. After detecting the location information of block boundary with blocking artifact, determine the strength of block boundary according to equation (12) to control the strength of the following filtering process. The detection result vbd_map(i, j) of block boundary in the vertical direction is shown in equation (12), where P 3  corresponds to a location of (i, j) in an image. 
     
       
         
           
             
               
                 
                   
                     vbd_map 
                     ⁢ 
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             2 
                             , 
                           
                         
                         
                           
                             
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                  
                                 
                                   
                                     P 
                                     3 
                                   
                                   - 
                                   
                                     Q 
                                     3 
                                   
                                 
                                  
                               
                             
                             &gt; 
                             
                               
                                 5 
                                 · 
                                 BLK_MID 
                               
                               ⁢ 
                               _TH 
                             
                           
                         
                       
                       
                         
                           
                             1 
                             , 
                           
                         
                         
                           
                             
                               else 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                  
                                 
                                   
                                     P 
                                     3 
                                   
                                   - 
                                   
                                     Q 
                                     3 
                                   
                                 
                                  
                               
                             
                             &gt; 
                             
                               BLK_MID 
                               ⁢ 
                               _TH 
                             
                           
                         
                       
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           others 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
           
         
       
     
     The method for detecting horizontal block boundary is similar that a 6×7 window is taken as the candidate pixel matrix. Taking the similar detection method, finally a detection result of hbd_map(i, j) of a horizontal block boundary is obtained. 
     In combination with the vertical and horizontal block boundary information, finally whole block boundary information bd_map(i, j) and strong block boundary information stbd_map(i, j) is obtained as the output of the block boundary detector  205 . 
     
       
         
           
             
               
                 
                   
                     stbd_map 
                     ⁢ 
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             1 
                             , 
                           
                         
                         
                           
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 [ 
                                 
                                   
                                     vbd_map 
                                     ⁢ 
                                     
                                       ( 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                   == 
                                   2 
                                 
                                 ] 
                               
                               ⁢ 
                               
                                 
                                    
                                    
                                 
                                 ⁡ 
                                 
                                   [ 
                                   
                                     
                                       hbd_map 
                                       ⁢ 
                                       
                                         ( 
                                         
                                           i 
                                           , 
                                           j 
                                         
                                         ) 
                                       
                                     
                                     == 
                                     2 
                                   
                                   ] 
                                 
                               
                             
                             ⁢ 
                             
                                 
                             
                           
                         
                       
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           others 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
             
               
                 
                   
                     bd_map 
                     ⁢ 
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             1 
                             , 
                           
                         
                         
                           
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 [ 
                                 
                                   
                                     vbd_map 
                                     ⁢ 
                                     
                                       ( 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                   ≠ 
                                   0 
                                 
                                 ] 
                               
                               ⁢ 
                               
                                 
                                    
                                    
                                 
                                 ⁡ 
                                 
                                   [ 
                                   
                                     
                                       hbd_map 
                                       ⁢ 
                                       
                                         ( 
                                         
                                           i 
                                           , 
                                           j 
                                         
                                         ) 
                                       
                                     
                                     ≠ 
                                     0 
                                   
                                   ] 
                                 
                               
                             
                             ⁢ 
                             
                                 
                             
                           
                         
                       
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           others 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
     The blocking artifact filtering area locator  206  of embodiment  200  of the present invention, on the basis of the block boundary information bd_map(i, j) obtained from the block boundary detector  205 , locates an area required to be filtered at a block boundary and its surroundings. Since a pixel on left-side or upper-sides of a block boundary is labeled during block boundary detection, the blocking artifact filtering area locator  206  uses a 4×4 window with the third row and the third column defined as the location of the pixel to be processed so as to locate a blocking artifact filtering area and to quantify the severity of the blocking artifact, as shown in  FIG. 8 . The location process is shown in equation (15). 
     
       
         
           
             
               
                 
                   
                     blk_map 
                     ⁢ 
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             3 
                             , 
                           
                         
                         
                           
                             
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 
                                   ∑ 
                                   
                                     s 
                                     = 
                                     
                                       - 
                                       2 
                                     
                                   
                                   1 
                                 
                                 ⁢ 
                                 
                                   
                                     ∑ 
                                     
                                       t 
                                       = 
                                       
                                         - 
                                         2 
                                       
                                     
                                     1 
                                   
                                   ⁢ 
                                   
                                     stbd_map 
                                     ⁢ 
                                     
                                       ( 
                                       
                                         
                                           i 
                                           + 
                                           s 
                                         
                                         , 
                                         
                                           j 
                                           + 
                                           t 
                                         
                                       
                                       ) 
                                     
                                   
                                 
                               
                             
                             ≥ 
                             1 
                           
                         
                       
                       
                         
                           
                             2 
                             , 
                           
                         
                         
                           
                             
                               else 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 
                                   ∑ 
                                   
                                     s 
                                     = 
                                     
                                       - 
                                       2 
                                     
                                   
                                   1 
                                 
                                 ⁢ 
                                 
                                   
                                     ∑ 
                                     
                                       t 
                                       = 
                                       
                                         - 
                                         2 
                                       
                                     
                                     1 
                                   
                                   ⁢ 
                                   
                                     bd_map 
                                     ⁢ 
                                     
                                       ( 
                                       
                                         
                                           i 
                                           + 
                                           s 
                                         
                                         , 
                                         
                                           j 
                                           + 
                                           t 
                                         
                                       
                                       ) 
                                     
                                   
                                 
                               
                             
                             ≥ 
                             1 
                           
                         
                       
                       
                         
                           
                             1 
                             , 
                           
                         
                         
                           
                             
                               else 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 [ 
                                 
                                   
                                     texture_map 
                                     ⁢ 
                                     
                                       ( 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                   == 
                                   0 
                                 
                                 ] 
                               
                             
                             &amp;&amp; 
                             
                               [ 
                               
                                 ∼ 
                                 
                                   line_map 
                                   ⁢ 
                                   
                                     ( 
                                     
                                       i 
                                       , 
                                       j 
                                     
                                     ) 
                                   
                                 
                               
                               ] 
                             
                           
                         
                       
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           others 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   15 
                   ) 
                 
               
             
           
         
       
     
     The blocking artifact suppressing filtering enable judge  207  in embodiment  200  of the present invention counts non-zero conditions, in the present frame, of block boundary information bd_map(i, j) that obtained from the above detection process, and calculates the percentage of the counting result of pixels in a whole frame of an image, denoted as ratio. According to the degree of severity of the blocking artifact, output blocking artifact suppressing filtering enable deblk_glen N  with different strengths for use in a next frame. 
     
       
         
           
             
               
                 
                   
                     deblk_glen 
                     N 
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             2 
                             , 
                           
                         
                         
                           
                             
                                 
                             
                             ⁢ 
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 ratio 
                               
                               &gt; 
                               
                                 TH_BLK 
                                 ⁢ 
                                 _RATIO 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 2 
                               
                             
                           
                         
                       
                       
                         
                           
                             1 
                             , 
                           
                         
                         
                           
                             
                               else 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               ratio 
                             
                             &gt; 
                             
                               TH_BLK 
                               ⁢ 
                               _RATIO 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               1 
                             
                           
                         
                       
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           others 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   16 
                   ) 
                 
               
             
           
         
       
     
     In the equation, TH_BLK_RATIO1 (1/64) and TH_BLK_RATIO2 (23/512) are defined experience percentage threshold values. If deblk_glen N  is equal to 2, it represents that a video image has a relatively serious blocking artifact; if deblk_glen N  is equal to 1, it represents that a video image has a relatively obvious blocking artifact that requires a blocking artifact suppressing process; if deblk_glen N  is equal to 0, it represents that a video image does not have blocking artifact or has a non-obvious blocking artifact which does not require a blocking artifact suppressing process. 
     In the adaptive mean filter  208  of embodiment  200  of the present invention, an adaptive mean filter is used for suppressing the ringing artifact and blocking artifact, the brightness filtering result is shown in equation (17). 
     
       
         
           
             
               
                 
                   
                     
                       y 
                       ′ 
                     
                     ⁡ 
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           s 
                           = 
                           
                             - 
                             
                               
                                 M 
                                 - 
                                 1 
                               
                               2 
                             
                           
                         
                         
                           
                             M 
                             - 
                             1 
                           
                           2 
                         
                       
                       ⁢ 
                       
                         
                           ∑ 
                           
                             t 
                             = 
                             
                               - 
                               
                                 
                                   N 
                                   - 
                                   1 
                                 
                                 2 
                               
                             
                           
                           
                             
                               N 
                               - 
                               1 
                             
                             2 
                           
                         
                         ⁢ 
                         
                           
                             ω 
                             ⁡ 
                             
                               ( 
                               
                                 
                                   i 
                                   + 
                                   s 
                                 
                                 , 
                                 
                                   j 
                                   + 
                                   t 
                                 
                               
                               ) 
                             
                           
                           · 
                           
                             y 
                             ⁡ 
                             
                               ( 
                               
                                 
                                   i 
                                   + 
                                   s 
                                 
                                 , 
                                 
                                   j 
                                   + 
                                   t 
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                     
                       
                         ∑ 
                         
                           s 
                           = 
                           
                             - 
                             
                               
                                 M 
                                 - 
                                 1 
                               
                               2 
                             
                           
                         
                         
                           
                             M 
                             - 
                             1 
                           
                           2 
                         
                       
                       ⁢ 
                       
                         
                           ∑ 
                           
                             t 
                             = 
                             
                               - 
                               
                                 
                                   N 
                                   - 
                                   1 
                                 
                                 2 
                               
                             
                           
                           
                             
                               N 
                               - 
                               1 
                             
                             2 
                           
                         
                         ⁢ 
                         
                           ω 
                           ⁡ 
                           
                             ( 
                             
                               
                                 i 
                                 + 
                                 s 
                               
                               , 
                               
                                 j 
                                 + 
                                 t 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   17 
                   ) 
                 
               
             
             
               
                 
                   
                     ω 
                     ⁡ 
                     
                       ( 
                       
                         
                           i 
                           + 
                           s 
                         
                         , 
                         
                           j 
                           + 
                           t 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             1 
                             , 
                           
                         
                         
                           
                             
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                  
                                 
                                   
                                     y 
                                     ⁡ 
                                     
                                       ( 
                                       
                                         
                                           i 
                                           + 
                                           s 
                                         
                                         , 
                                         
                                           j 
                                           + 
                                           t 
                                         
                                       
                                       ) 
                                     
                                   
                                   - 
                                   
                                     y 
                                     ⁡ 
                                     
                                       ( 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                 
                                  
                               
                             
                             &lt; 
                             filter_th 
                           
                         
                       
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           others 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   18 
                   ) 
                 
               
             
           
         
       
     
     In the equations, y(i, j) is the brightness of the present pixel to be processed; y′(i, j) is a brightness filtering result using a M×N window with y(i, j) as a central pixel during filtering; y(i+s, j+t) is a brightness value of a pixel at the location of (i+s, j+t) within a M×N window; ω(i+s, j+t) is the weight corresponding to the pixel y(i+s, j+t); and filter_th is an adaptive filtering threshold value obtained from equation (19). 
     
       
         
           
             
               
                 
                   filter_th 
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 α 
                                 1 
                               
                               · 
                               
                                 y 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     i 
                                     , 
                                     j 
                                   
                                   ) 
                                 
                               
                             
                             , 
                           
                         
                         
                           
                             A 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             strong 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             filtering 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             for 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             suppressing 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             ringing 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             noise 
                           
                         
                       
                       
                         
                           
                             
                               min 
                               ⁡ 
                               
                                 [ 
                                 
                                   
                                     FILTER_TH 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     1 
                                   
                                   , 
                                   
                                     
                                       α 
                                       2 
                                     
                                     · 
                                     
                                       y 
                                       ⁡ 
                                       
                                         ( 
                                         
                                           i 
                                           , 
                                           j 
                                         
                                         ) 
                                       
                                     
                                   
                                 
                                 ] 
                               
                             
                             , 
                           
                         
                         
                           
                             A 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             weak 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             filtering 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             for 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             suppressing 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             ringing 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             noise 
                           
                         
                       
                       
                         
                           
                             
                               FILTER_TH 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               2 
                             
                             , 
                           
                         
                         
                           
                             A 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             strong 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             filtering 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             for 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             suppressing 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             blocking 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             effect 
                           
                         
                       
                       
                         
                           
                             
                               FILTER_TH 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               3 
                             
                             , 
                           
                         
                         
                           
                             A 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             weak 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             filtering 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             for 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             suppressing 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             blocking 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             effect 
                           
                         
                       
                       
                         
                           
                             
                               FILTER_TH 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               4 
                             
                             , 
                           
                         
                         
                           
                             A 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             flat 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             area 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             filtering 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             for 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             suppressing 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             blocking 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             effect 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   19 
                   ) 
                 
               
             
           
         
       
     
     In the equation, α 1  and α 2  are threshold adjusting coefficients that are independently defined to be ⅛ and 3/32 in this embodiment; and FILTER_TH1, FILTER_TH2, FILTER_TH3 and FILTER_TH4 take the values of 6, 15, 8 and 4. 
     The adaptive filter  208  of this embodiment, according to the different threshold values of filter_th, outputs five types of filtering results that respectively indicated as a strong filtering result y stdr (i, j) and a weak filtering result y wkdr (i, j) for suppressing the ringing artifact, a strong filtering result y stdb (i, j) and a weak filtering result y wkdb (i, j) for suppressing blocking artifact, and a supplementary filtering result y flatdb (i, j) in a flat area. The filtering process of this embodiment uses a 5×7 window. 
     The filtering selector  209  of the embodiment  200  of the present invention, according to the information of ring_map(i, j) and blk_map(i, j) obtained from the above, retains the weak single-pixel lines in the edge, texture and flat area; next, according to the area where the pixel to be processed is located and the artifact strength, and the blocking artifact suppressing filtering enable deblk_glen N−1  obtained from the previous frame, select appropriate results from y(i, j), y stdr (i, j), y wkdr (i, j), y stdb (i, j), y wkdb (i, j) and y flatdb (i, j) as final filtering result y filtered (i, j) that is to be output from the filtering selector  209 . The specific selection process is shown in equation (20). 
     
       
         
           
             
               
                 
                   
                     
                       y 
                       filtered 
                     
                     ⁡ 
                     
                       ( 
                       
                         i 
                         , 
                         j 
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               y 
                               ⁡ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                             , 
                           
                         
                         
                           
                             
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               ring_map 
                               ⁢ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                             == 
                             3 
                           
                         
                       
                       
                         
                           
                             
                               
                                 y 
                                 stdr 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                             , 
                           
                         
                         
                           
                             
                               else 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               ring_map 
                               ⁢ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                             == 
                             2 
                           
                         
                       
                       
                         
                           
                             
                               
                                 y 
                                 wkdr 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                             , 
                           
                         
                         
                           
                             
                               else 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               ring_map 
                               ⁢ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                             == 
                             1 
                           
                         
                       
                       
                         
                           
                             
                               
                                 y 
                                 stdb 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                             , 
                           
                         
                         
                           
                             
                               else 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 [ 
                                 
                                   
                                     blk_map 
                                     ⁢ 
                                     
                                       ( 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                   == 
                                   3 
                                 
                                 ] 
                               
                             
                             &amp;&amp; 
                             
                               [ 
                               
                                 
                                   deblk_glen 
                                   
                                     N 
                                     - 
                                     1 
                                   
                                 
                                 == 
                                 1 
                               
                               ] 
                             
                           
                         
                       
                       
                         
                           
                             
                               
                                 y 
                                 wkdb 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                             , 
                           
                         
                         
                           
                             
                               
                                 
                                   else 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   if 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   
                                     { 
                                     
                                       
                                         [ 
                                         
                                           
                                             blk_map 
                                             ⁢ 
                                             
                                               ( 
                                               
                                                 i 
                                                 , 
                                                 j 
                                               
                                               ) 
                                             
                                           
                                           == 
                                           2 
                                         
                                         ] 
                                       
                                       &amp;&amp; 
                                       
                                         [ 
                                         
                                           
                                             deblk_glen 
                                             
                                               N 
                                               - 
                                               1 
                                             
                                           
                                           == 
                                           1 
                                         
                                         ] 
                                       
                                     
                                     } 
                                   
                                   ⁢ 
                                   
                                      
                                      
                                   
                                 
                               
                             
                             
                               
                                 
                                   { 
                                   
                                     
                                       [ 
                                       
                                         
                                           texture_map 
                                           ⁢ 
                                           
                                             ( 
                                             
                                               i 
                                               , 
                                               j 
                                             
                                             ) 
                                           
                                         
                                         ≤ 
                                         1 
                                       
                                       ] 
                                     
                                     &amp;&amp; 
                                     
                                       
                                         deblk_glen 
                                         
                                           N 
                                           - 
                                           1 
                                         
                                       
                                       == 
                                       2 
                                     
                                   
                                   } 
                                 
                               
                             
                           
                         
                       
                       
                         
                           
                             
                               
                                 y 
                                 flatdb 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                             , 
                           
                         
                         
                           
                             
                               else 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               blk_map 
                               ⁢ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                             == 
                             1 
                           
                         
                       
                       
                         
                           
                             
                               y 
                               ⁡ 
                               
                                 ( 
                                 
                                   i 
                                   , 
                                   j 
                                 
                                 ) 
                               
                             
                             , 
                           
                         
                         
                           others 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   20 
                   ) 
                 
               
             
           
         
       
     
     For better preventing an excessive filtering, embodiment  200  of the present invention uses a weights sum of the original brightness value of the pixel to be processed and the filtering result before finally output the result. The value of weight coefficients is adaptively obtained according to the degree of difference between the pixel to be processed and its surrounding pixels for better preserving an original image. All of these are completed in the output fusion  210 .
 
 y   out ( i, j )=λ· y ( i, j )+(1−λ)· y   filtered ( i, j )  (21)
 
     In the equation, y out (i, j) is a final brightness output and λ is fusion weights coefficient. The value of λ is calculated from equations (22) and (23). 
     
       
         
           
             
               
                 
                   
                       
                   
                   ⁢ 
                   
                     λ 
                     = 
                     
                       { 
                       
                         
                           
                             
                               
                                 1 
                                 2 
                               
                               , 
                             
                           
                           
                             
                               
                                 if 
                                 ⁢ 
                                 
                                     
                                 
                                 [ 
                                 
                                   
                                     ∑ 
                                     
                                       s 
                                       = 
                                       
                                         - 
                                         2 
                                       
                                     
                                     2 
                                   
                                   ⁢ 
                                   
                                     
                                       ∑ 
                                       
                                         t 
                                         = 
                                         
                                           - 
                                           2 
                                         
                                       
                                       2 
                                     
                                     ⁢ 
                                     
                                       
                                         ω 
                                         ′ 
                                       
                                       ⁡ 
                                       
                                         ( 
                                         
                                           
                                             i 
                                             + 
                                             s 
                                           
                                           , 
                                           
                                             j 
                                             + 
                                             t 
                                           
                                         
                                         ) 
                                       
                                     
                                   
                                 
                                 ] 
                               
                               ≥ 
                               21 
                             
                           
                         
                         
                           
                             
                               
                                 1 
                                 4 
                               
                               , 
                             
                           
                           
                             
                               
                                 else 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   if 
                                   ⁢ 
                                   
                                       
                                   
                                   [ 
                                   
                                     
                                       ∑ 
                                       
                                         s 
                                         = 
                                         
                                           - 
                                           2 
                                         
                                       
                                       2 
                                     
                                     ⁢ 
                                     
                                       
                                         ∑ 
                                         
                                           t 
                                           = 
                                           
                                             - 
                                             2 
                                           
                                         
                                         2 
                                       
                                       ⁢ 
                                       
                                         
                                           ω 
                                           ′ 
                                         
                                         ⁡ 
                                         
                                           ( 
                                           
                                             
                                               i 
                                               + 
                                               s 
                                             
                                             , 
                                             
                                               j 
                                               + 
                                               t 
                                             
                                           
                                           ) 
                                         
                                       
                                     
                                   
                                   ] 
                                 
                               
                               ≥ 
                               16 
                             
                           
                         
                         
                           
                             
                               0 
                               , 
                             
                           
                           
                             others 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   22 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       ω 
                       ′ 
                     
                     ⁡ 
                     
                       ( 
                       
                         
                           i 
                           + 
                           s 
                         
                         , 
                         
                           j 
                           + 
                           t 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             1 
                             , 
                           
                         
                         
                           
                             
                               if 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               
                                  
                                 
                                   
                                     y 
                                     ⁡ 
                                     
                                       ( 
                                       
                                         
                                           i 
                                           + 
                                           s 
                                         
                                         , 
                                         
                                           j 
                                           + 
                                           t 
                                         
                                       
                                       ) 
                                     
                                   
                                   - 
                                   
                                     y 
                                     ⁡ 
                                     
                                       ( 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                       ) 
                                     
                                   
                                 
                                  
                               
                             
                             ≤ 
                             BLEND_TH 
                           
                         
                       
                       
                         
                           
                             0 
                             , 
                           
                         
                         
                           others 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   23 
                   ) 
                 
               
             
           
         
       
     
     In the equations, ω′(i+s, j+t) represents brightness differences between a central pixel and other pixels within a 5×5 window with pixel (i, j) being a central pixel, and the threshold value BLEND_TH is defined to be 3. 
     In summary, embodiment  200  of the present invention can effectively suppress the ringing artifact and blocking artifact, and meanwhile well protect important original information such as edge and textural information.