Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright © <2010>, Intel Corporation.
  3.  *
  4.  * This program is licensed under the terms and conditions of the
  5.  * Eclipse Public License (EPL), version 1.0.  The full text of the EPL is at
  6.  * http://www.opensource.org/licenses/eclipse-1.0.php.
  7.  *
  8.  */
  9. #if !defined(__AVC_ILDB_LUMA_CORE_MBAFF__)      // Make sure this file is only included once
  10. #define __AVC_ILDB_LUMA_CORE_MBAFF__
  11.  
  12. ////////// AVC ILDB Luma Core Mbaff /////////////////////////////////////////////////////////////////////////////////
  13. //
  14. //      This core performs AVC LUMA ILDB filtering on one horizontal edge (16 pixels) of a MB.  
  15. //      If data is transposed, it can also de-block a vertical edge.
  16. //
  17. //      Bafore calling this subroutine, caller needs to set the following parameters.
  18. //
  19. //      - EdgeCntlMap1                          //      Edge control map A
  20. //      - EdgeCntlMap2                          //      Edge control map B
  21. //      - P_AddrReg                                     //      Src and dest address register for P pixels
  22. //      - Q_AddrReg                                     //      Src and dest address register for Q pixels      
  23. //      - alpha                                         //  alpha corresponding to the edge to be filtered
  24. //      - beta                                          //  beta corresponding to the edge to be filtered
  25. //      - tc0                                           //      tc0  corresponding to the edge to be filtered
  26. //
  27. //
  28. //      +----+----+----+----+----+----+----+----+
  29. //      | p3 | p2 | P1 | p0 | q0 | q1 | q2 | q3 |
  30. //      +----+----+----+----+----+----+----+----+
  31. //
  32. //      p3 = r[P_AddrReg, 0]<16;16,1>  
  33. //      p2 = r[P_AddrReg, 16]<16;16,1>
  34. //      p1 = r[P_AddrReg, 32]<16;16,1>
  35. //      p0 = r[P_AddrReg, 48]<16;16,1>
  36. //      q0 = r[Q_AddrReg, 0]<16;16,1>  
  37. //      q1 = r[Q_AddrReg, 16]<16;16,1>
  38. //      q2 = r[Q_AddrReg, 32]<16;16,1>
  39. //      q3 = r[Q_AddrReg, 48]<16;16,1>
  40. //
  41. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  42.  
  43. // The region is both src and dest
  44. // P0-P3 and Q0-Q3 should be only used if they have not been modified to new values  
  45. #undef  P3
  46. #undef  P2
  47. #undef  P1
  48. #undef  P0
  49. #undef  Q0
  50. #undef  Q1
  51. #undef  Q2
  52. #undef  Q3
  53.  
  54. #define P3              r[P_AddrReg,  0]<16;16,1>:ub
  55. #define P2              r[P_AddrReg, 16]<16;16,1>:ub
  56. #define P1              r[P_AddrReg, 32]<16;16,1>:ub
  57. #define P0              r[P_AddrReg, 48]<16;16,1>:ub
  58. #define Q0              r[Q_AddrReg,  0]<16;16,1>:ub
  59. #define Q1              r[Q_AddrReg, 16]<16;16,1>:ub
  60. #define Q2              r[Q_AddrReg, 32]<16;16,1>:ub
  61. #define Q3              r[Q_AddrReg, 48]<16;16,1>:ub
  62.  
  63. // New region as dest
  64. #undef  NewP2
  65. #undef  NewP1
  66. #undef  NewP0
  67. #undef  NewQ0
  68. #undef  NewQ1
  69. #undef  NewQ2
  70.  
  71. #define NewP2   r[P_AddrReg, 16]<1>:ub
  72. #define NewP1   r[P_AddrReg, 32]<1>:ub
  73. #define NewP0   r[P_AddrReg, 48]<1>:ub
  74. #define NewQ0   r[Q_AddrReg,  0]<1>:ub
  75. #define NewQ1   r[Q_AddrReg, 16]<1>:ub
  76. #define NewQ2   r[Q_AddrReg, 32]<1>:ub
  77.  
  78.  
  79.  
  80. // Filter one luma edge - mbaff
  81. FILTER_Y_MBAFF:
  82.  
  83. #if defined(_DEBUG)
  84.         mov             (1)             EntrySignatureC:w                       0x1111:w
  85. #endif
  86.         //---------- Derive filterSampleflag in AVC spec, equition (8-469) ----------
  87.         // bS is in MaskA
  88.  
  89.         // Src copy of the p3, p2, p1, p0, q0, q1, q2, q3
  90. //      mov (16) p0123_W(0)<1>          r[P_AddrReg]<16;16,1>:uw
  91. //      mov (16) p0123_W(1)<1>          r[P_AddrReg, 32]<16;16,1>:uw
  92. //      mov (16) q0123_W(0)<1>          r[Q_AddrReg]<16;16,1>:uw
  93. //      mov (16) q0123_W(1)<1>          r[Q_AddrReg, 32]<16;16,1>:uw
  94.  
  95.         // Move MaskA and MaskB to flag regs
  96.         mov (2) f0.0<1>:uw              MaskA<2;2,1>:uw
  97.  
  98.         add (16) q0_p0(0)<1>            Q0                      -P0                             // q0-p0
  99.         add (16) TempRow0(0)<1>         P1                      -P0                             // p1-p0
  100.         add (16) TempRow1(0)<1>         Q1                      -Q0                             // q1-q0
  101.  
  102.         // abs(q0-p0) < alpha
  103.         (f0.0) cmp.l.f0.0 (16) null:w           (abs)q0_p0(0)           Mbaff_ALPHA(0)
  104.         // abs(p1-p0) < Beta
  105.         (f0.0) cmp.l.f0.0 (16) null:w           (abs)TempRow0(0)        Mbaff_BETA(0)
  106.         // abs(q1-q0) < Beta
  107.         (f0.0) cmp.l.f0.0 (16) null:w           (abs)TempRow1(0)        Mbaff_BETA(0)
  108.  
  109.         //-----------------------------------------------------------------------------------------
  110.  
  111.     (f0.0)      if      (16)            MBAFF_Y_ENDIF1
  112.                 // For channels whose edge control map1 = 1 ---> perform de-blocking
  113.  
  114. //              mov (1)         f0.1:uw         MaskB:uw        {NoMask}                // Now check for which algorithm to apply
  115.  
  116.                 // (abs)ap = |p2-p0|
  117.                 add (16) ap(0)<1>               P2              -P0
  118.  
  119.                 // (abs)aq = |q2-q0|
  120.                 add (16) aq(0)<1>               Q2              -Q0
  121.  
  122.                 // Make a copy of unmodified p0 and p1 for use in q0'and q1' calculation
  123.                 mov (16) p0123_W(1)<1>          r[P_AddrReg, 32]<16;16,1>:uw            {NoMask}
  124.                        
  125.                 (f0.1)  if      (16)            MBAFF_Y_ELSE2
  126.  
  127.                         // For channels whose edge control map2 = 1 ---> bS = 4 algorithm
  128.  
  129.                         // Compute q0', q1' and q2'
  130.                         //-----------------------------------------------------------------------------
  131.                         // bS = 4 Algorithm :                  
  132.                         //
  133.                         // gama = |p0-q0| < ((alpha >> 2) + 2)
  134.                         // deltap = (ap<beta) && gama;                  // deep filter flag
  135.                         //      if (deltap) {
  136.                         //              p0' = (        p2 +2*p1 +2*p0 +2*q0 + q1 + 4) >> 3;
  137.                         //              p1' = (        p2 +  p1 +  p0 +  q0      + 2) >> 2;
  138.                         //              p2' = (2*p3 +3*p2 +  p1 +  p0 +  q0      + 4) >> 3;
  139.                         //      } else {  
  140.                         //              p0' = (            2*p1 +  p0 +  q1      + 2) >> 2;
  141.                         //      }
  142.                         //-----------------------------------------------------------------------------
  143.  
  144.                         // gama = |p0-q0| < ((alpha >> 2) + 2) = |p0-q0| < alpha2  
  145.                         cmp.l.f0.1 (16) null:w  (abs)q0_p0(0)   Mbaff_ALPHA2(0)
  146.  
  147.                         // Common P01 = p0 + p1
  148.                         add (16)        P0_plus_P1(0)<1>        P0                      P1     
  149.  
  150.                         // Common Q01 = q0 + q1
  151.                         add (16)        Q0_plus_Q1(0)<1>        Q0                      Q1
  152.  
  153.                         mov (1) f0.0:uw                 f0.1:uw                                         {NoMask}
  154.  
  155.                         // deltap = ((abs)ap < beta) && gama
  156.                         (f0.1) cmp.l.f0.1 (16) null:w   (abs)ap(0)              Mbaff_BETA(0)                                                   // (abs)ap < beta ?
  157.  
  158.                         // deltaq = ((abs)aq < beta) && gama
  159.                         (f0.0) cmp.l.f0.0 (16) null:w   (abs)aq(0)              Mbaff_BETA(0)                                                   // (abs)aq < beta ?
  160.  
  161.  
  162.                         (f0.1)  if      (16)            MBAFF_Y_ELSE3                   // for channels its deltap = true
  163.        
  164.                         add (16)        P2_plus_P3(0)<1>        P2              P3
  165.                        
  166.                         // A =  p1 + p0 + q0 = P01 + q0
  167.                         add (16)        A(0)<1>                 P0_plus_P1(0)           Q0                                                      // A =  P01 + q0
  168.  
  169.                         // Now acc0 = A
  170.  
  171.                         // B =  p2 + p1 + p0 + q0 + 4 = p2 + A + 4
  172.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w               4:w                                                             // p2 + 4
  173.                         add (16)        BB(0)<1>                        acc0.0<16;16,1>:w               P2                                      // B = p2 + A + 4
  174.  
  175.                         // Now acc0 = B
  176.  
  177.                         // p2' = (2*p3 +3*p2 + A + 4) >> 3 = (2*(p3+p2) + B) >> 3
  178.                         mac (16)        acc0.0<1>:w             P2_plus_P3(0)           2:w            
  179.                         shr.sat (16) TempRow3B(0)<2>    acc0.0<16;16,1>:w               3:w
  180.  
  181.                         // p1' = (p2 + A + 2) >> 2 = (B - 2) >> 2
  182.                         add (16)        acc0.0<1>:w             BB(0)                   -2:w
  183.                         shr.sat (16) TempRow1B(0)<2>    acc0.0<16;16,1>:w               2:w
  184.        
  185.                         // p0' = (p2 +2*A + q1 + 4) >> 3 = (B + A + q1) >> 3
  186.                         add (16)        acc0.0<1>:w             Q1                              A(0)                                                    // B + A
  187.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w               BB(0)                                                   // B + A + q1
  188.                         shr.sat (16) TempRow0B(0)<2>    acc0.0<16;16,1>:w               3:w                                                             // (B + A + q1) >> 3
  189.  
  190.                         mov (16)        NewP2           TempRow3B(0)                                            // p2'
  191.                         mov (16)        NewP1           TempRow1B(0)                                            // p1'                 
  192.                         mov (16)        NewP0           TempRow0B(0)                                            // p0'
  193.  
  194. MBAFF_Y_ELSE3:
  195.                         else (16)               MBAFF_Y_ENDIF3          // for channels its deltap = false
  196.  
  197.                         // p0' = (2*p1 + p0 + q1 + 2) >> 2 =  (p1 + P01 + q1 + 2) >> 2
  198.                         add (16)        acc0.0<1>:w             P1                      P0_plus_P1(0)                   // p1 + P01 (TempRow1(0) = P01)
  199.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w       Q1                             
  200.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w       2:w                     // p1 + P01 + q1 + 2
  201.  
  202.                         shr.sat (16) TempRow0B(0)<2>    acc0.0<16;16,1>:w               2:w     // >> 2
  203.                         mov (16)        NewP0           TempRow0B(0)                                            // p0'
  204.  
  205.                         endif
  206.  
  207. MBAFF_Y_ENDIF3:
  208.                         // Compute q0', q1' and q2'
  209.                         //-----------------------------------------------------------------------------
  210.                         // bS = 4 Algorithm (cont):                    
  211.                         //
  212.                         //      deltaq = (aq<beta) && gama;             // deep filter flag
  213.                         //      if (deltaq) {
  214.                         //              q0' = (        q2 +2*q1 +2*q0 +2*p0 + p1 + 4) >> 3;
  215.                         //              q1' = (        q2 +  q1 +  q0 +  p0      + 2) >> 2;
  216.                         //              q2' = (2*q3 +3*q2 +  q1 +  q0 +  p0      + 4) >> 3;
  217.                         //      } else {
  218.                         //              q0' = (            2*q1 +  q0 +  p1      + 2) >> 2;
  219.                         //      }
  220.                        
  221.                         (f0.0)  if      (16)            MBAFF_Y_ELSE4                   // for channels its deltaq = true
  222.                        
  223.                         add (16)        Q2_plus_Q3(0)<1>        Q2                      Q3
  224.  
  225.                         // A =  q1 + q0 + p0 = Q01 + p0
  226.                         add (16)        A(0)<1>                 Q0_plus_Q1(0)           p0(0)                                                   // A =  q1+q0 + p0
  227.  
  228.                         // B =  q2 + q1 + q0 + p0 + 4 = q2 + A + 4
  229.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w               4:w                                                     // q2 + 4
  230.                         add (16)        BB(0)<1>                        acc0.0<16;16,1>:w               Q2                                                              // B = q2 + A + 4
  231.                        
  232.                         // Acc0 = B
  233.  
  234.                         // q2' = (2*q3 +3*q2 + A + 4) >> 3 = (2*(q3+q2) + B) >> 3
  235.                         mac (16)        acc0.0<1>:w             Q2_plus_Q3(0)   2:w
  236.                         shr.sat (16) TempRow3B(0)<2>    acc0.0<16;16,1>:w               3:w
  237.  
  238.                         // q1' = (q2 + A + 2) >> 2 = (B - 2) >> 2
  239.                         add (16)        acc0.0<1>:w             BB(0)                   -2:w
  240.                         shr.sat (16) TempRow1B(0)<2>    acc0.0<16;16,1>:w       2:w
  241.                        
  242.                         // q0' = (q2 +2*A + p1 + 4) >> 3 = (B + A + p1) >> 3
  243.                         add (16)        acc0.0<1>:w             p1(0)                                   A(0)
  244.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w               BB(0)
  245.                         shr.sat (16) TempRow0B(0)<2>    acc0.0<16;16,1>:w       3:w
  246.                        
  247.                         mov (16)        NewQ2           TempRow3B(0)                                            // q2'
  248.                         mov (16)        NewQ1           TempRow1B(0)                                            // q1'
  249.                         mov (16)        NewQ0           TempRow0B(0)                                            // q0'
  250.  
  251. MBAFF_Y_ELSE4:
  252.                         else (16)               MBAFF_Y_ENDIF4          // for channels its deltaq = false
  253.  
  254.                         // q0' = (2*q1 + q0 + p1 + 2) >> 2 =  (q1 + Q01 + p1 + 2) >> 2
  255.                         // Use original p1 values in p1(0)
  256.                         add (16)        acc0.0<1>:w             p1(0)                   Q0_plus_Q1(0)                   // p1 + P01 (TempRow1(0) = P01)
  257.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w       Q1                             
  258.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w       2:w                     // p1 + P01 + q1 + 2
  259.  
  260.                         shr.sat (16)    TempRow0B(0)<2>         acc0.0<16;16,1>:w               2:w                                                             // >> 2
  261.                         mov (16)        NewQ0           TempRow0B(0)                                            // q0'
  262.  
  263.                         endif
  264. MBAFF_Y_ENDIF4:
  265.  
  266.                        
  267.                         // Done with bS = 4 algorithm
  268.                        
  269. MBAFF_Y_ELSE2:
  270.                 else    (16)            MBAFF_Y_ENDIF2
  271.                         // For channels whose edge control map2 = 0 ---> bS < 4 algorithm
  272.  
  273.                         //-----------------------------------------------------------------------------
  274.                         // bS < 4 Algorithm :
  275.                         // tc = tc0 + (|p2-p0|<Beta ? 1 : 0) + (|q2-q0|<Beta ? 1 : 0)
  276.                         // delta = Clip3(-tc, tc, ((((q0-p0)<<2) + (p1-q1) + 4) >> 3))
  277.                         // p0' = Clip1(p0 + delta) = Clip3(0, 0xFF, p0 + delta)
  278.                         // q0' = Clip1(q0 - delta) = Clip3(0, 0xFF, q0 - delta)
  279.                         // if (|p2-p0|<Beta)
  280.                         //              p1' = p1 + Clip3(-tc0, tc0, (p2 + ((p0+q0+1)>>1) - (p1<<1)) >> 1 )
  281.                         // if (|q2-q0|<Beta)
  282.                         //              q1' = q1 + Clip3(-tc0, tc0, (q2 + ((p0+q0+1)>>1) - (q1<<1)) >> 1 )
  283.                         //-----------------------------------------------------------------------------
  284.                        
  285.                         mov (16)        tc_exp(0)<1>            Mbaff_TC0(0)                                                            // tc = tc0_exp first
  286.                        
  287.                         cmp.l.f0.0 (16) null:w          (abs)ap(0)                      Mbaff_BETA(0)                           // |p2-p0|<Beta ?
  288.                         cmp.l.f0.1 (16) null:w          (abs)aq(0)                      Mbaff_BETA(0)                           // |q2-q0|<Beta ?
  289.                                
  290.                         //--- Use free cycles here ---
  291.                         // delta = Clip3(-tc, tc, ((((q0-p0)<<2) + (p1-q1) + 4) >> 3))
  292.                         // 4 * (q0-p0) + p1 - q1 + 4
  293.                         add (16) acc0<1>:w              P1                      4:w                                                     // p1 + 4
  294.                         mac (16) acc0<1>:w              q0_p0(0)        4:w                                                     // 4 * (q0-p0) + p1 + 4
  295.                         add (16) acc0<1>:w              acc0<16;16,1>:w         -Q1                                     // 4 * (q0-p0) + p1 - q1 + 4
  296.                         shr (16) TempRow0(0)<1> acc0<16;16,1>:w         3:w
  297.                                                
  298.                         // Continue on getting tc_exp
  299.                         (f0.0) add (16) tc_exp(0)<1>    tc_exp(0)       1:w                                                     // tc0_exp + (|p2-p0|<Beta ? 1 : 0)
  300.                         mov (2) CTemp1_W<1>:w           f0.0<2;2,1>:w                   {NoMask}                                        // Save |p2-p0|<Beta flag                      
  301.                         (f0.1) add (16) tc_exp(0)<1>    tc_exp(0)       1:w                                                     // tc_exp = tc0_exp + (|p2-p0|<Beta ? 1 : 0) + (|q2-q0|<Beta ? 1 : 0)
  302.                                
  303.                         // Continue on cliping tc to get delta
  304.                         cmp.g.f0.0      (16) null:w             TempRow0(0)             tc_exp(0)                                       // Clip if delta' > tc
  305.                         cmp.l.f0.1      (16) null:w             TempRow0(0)             -tc_exp(0)                                      // Clip if delta' < -tc
  306.  
  307.                         //--- Use free cycles here ---
  308.                         // common = (p0+q0+1) >> 1        --->  TempRow2(0)
  309.                         // Same as avg of p0 and q0
  310.                         avg (16) TempRow2(0)<1>         P0                      Q0
  311.  
  312.                         // Continue on cliping tc to get delta
  313.                         (f0.0) mov (16) TempRow0(0)<1>                          tc_exp(0)
  314.                         (f0.1) mov (16) TempRow0(0)<1>                          -tc_exp(0)
  315.  
  316.                         //--- Use free cycles here ---
  317.                         mov (2) f0.0<1>:w               CTemp1_W<2;2,1>:w       {NoMask}                        // CTemp1_W = (|p2-p0|<Beta)
  318.                                                                                                                                                         // CTemp2_W = (|q2-q0|<Beta)           
  319.  
  320.                         // p0' = Clip1(p0 + delta) = Clip3(0, 0xFF, p0 + delta)
  321.                         // q0' = Clip1(q0 - delta) = Clip3(0, 0xFF, q0 - delta)
  322.                         add.sat (16) TempRow1B(0)<2>            P0                      TempRow0(0)                                     // p0+delta
  323.                         add.sat (16) TempRow0B(0)<2>            Q0                      -TempRow0(0)                            // q0-delta
  324.                        
  325.                         mov (16) NewP0          TempRow1B(0)                                    // p0'
  326.                         mov (16) NewQ0          TempRow0B(0)                                    // q0'
  327.  
  328.                         //-----------------------------------------------------------------------
  329.  
  330.                         // Now compute p1' and q1'
  331.  
  332.                         // if (|p2-p0|<Beta)
  333.                         (f0.0)  if      (16)            MBAFF_Y_ENDIF6
  334.  
  335.                         // p1' = p1 + Clip3(-tc0, tc0, adj)
  336.                         // adj = (p2 + common - (p1<<1)) >> 1 = (p2 + common - (p1*2)) >> 1
  337.                         add (16) acc0<1>:w      P2              TempRow2(0)                                                     // TempRow2(0) = common = (p0+q0+1) >> 1
  338.                         mac (16) acc0<1>:w      P1              -2:w
  339.                         shr (16) TempRow1(0)<1>         acc0<16;16,1>:w         1:w
  340.  
  341.                         // tc clip to get tc_adj
  342.                         cmp.g.f0.0      (16) null:w             TempRow1(0)             Mbaff_TC0(0)                                    // Clip if delta' > tc
  343.                         cmp.l.f0.1      (16) null:w             TempRow1(0)             -Mbaff_TC0(0)                                   // Clip if delta' < -tc
  344.                        
  345.                         (f0.0) mov (16) TempRow1(0)<1>                          Mbaff_TC0(0)
  346.                         (f0.1) mov (16) TempRow1(0)<1>                          -Mbaff_TC0(0)
  347.  
  348.                         //--- Use free cycles here ---
  349.                         mov (1) f0.1:w          CTemp2_W:w                              {NoMask}                        // CTemp2_W = (|q2-q0|<Beta)
  350.  
  351.                         // p1' = p1 + tc_adj
  352.                         add.sat (16) TempRow1B(0)<2>            P1                      TempRow1(0)                                     // p1+tc_adj
  353.                         mov (16) NewP1                  TempRow1B(0)                            // p1'
  354.                         //------------------------------------------------------------------------
  355.  
  356. MBAFF_Y_ENDIF6:
  357.                         endif
  358.                        
  359.                         // if (|q2-q0|<Beta)
  360.                         (f0.1)  if      (16)            MBAFF_Y_ENDIF7
  361.  
  362.                         // q1' = q1 + Clip3(-tc0, tc0, adj)
  363.                         // adj = (q2 + common - (q1<<1)) >> 1
  364.                         // same as q2 + common - (q1 * 2)
  365.                         add (16) acc0<1>:w      Q2              TempRow2(0)
  366.                         mac (16) acc0<1>:w      Q1              -2:w
  367.                         shr (16) TempRow1(0)<1>         acc0<16;16,1>:w         1:w    
  368.                                        
  369.                         // tc clip to get tc_adj
  370.                         cmp.g.f0.0      (16) null:w             TempRow1(0)             Mbaff_TC0(0)                                    // Clip if delta' > tc
  371.                         cmp.l.f0.1      (16) null:w             TempRow1(0)             -Mbaff_TC0(0)                                   // Clip if delta' < -tc
  372.  
  373.                         (f0.0) mov (16) TempRow1(0)<1>                          Mbaff_TC0(0)
  374.                         (f0.1) mov (16) TempRow1(0)<1>                          -Mbaff_TC0(0)
  375.                        
  376.                         // q1' = q1 + tc_adj
  377.                         add.sat (16) TempRow1B(0)<2>            Q1                      TempRow1(0)                                     // q1+tc_adj
  378.                         mov (16) NewQ1                  TempRow1B(0)                            // q1'
  379.                        
  380.                         //------------------------------------------------------------------------                     
  381. MBAFF_Y_ENDIF7:
  382.                         endif
  383.  
  384.                 endif
  385. MBAFF_Y_ENDIF2:
  386. MBAFF_Y_ENDIF1:
  387.         endif
  388.  
  389. RETURN
  390.  
  391. #endif  // !defined(__AVC_ILDB_LUMA_CORE_MBAFF__)
  392.