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__)    // Make sure this file is only included once
  10. #define __AVC_ILDB_LUMA_CORE__
  11.  
  12. ////////// AVC ILDB Luma Core /////////////////////////////////////////////////////////////////////////////////
  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. // Filter one luma edge
  79. FILTER_Y:
  80.  
  81. #if defined(_DEBUG)
  82.         mov             (1)             EntrySignatureC:w                       0x1111:w
  83. #endif
  84.         //---------- Derive filterSampleflag in AVC spec, equition (8-469) ----------
  85.         // bS is in MaskA
  86.  
  87.         // Src copy of the p3, p2, p1, p0, q0, q1, q2, q3
  88. //      mov (16) p0123_W(0)<1>          r[P_AddrReg]<16;16,1>:uw
  89. //      mov (16) p0123_W(1)<1>          r[P_AddrReg, 32]<16;16,1>:uw
  90. //      mov (16) q0123_W(0)<1>          r[Q_AddrReg]<16;16,1>:uw
  91. //      mov (16) q0123_W(1)<1>          r[Q_AddrReg, 32]<16;16,1>:uw
  92.  
  93.         mov (2) f0.0<1>:uw              MaskA<2;2,1>:uw
  94.  
  95.         add (16) q0_p0(0)<1>            Q0              -P0                             // q0-p0
  96.         add (16) TempRow0(0)<1>         P1              -P0                             // p1-p0
  97.         add (16) TempRow1(0)<1>         Q1              -Q0                             // q1-q0
  98.  
  99.         // Build FilterSampleFlag
  100.         // abs(q0-p0) < alpha
  101.         (f0.0) cmp.l.f0.0 (16) null:w           (abs)q0_p0(0)                   alpha:w
  102.         // abs(p1-p0) < Beta
  103.         (f0.0) cmp.l.f0.0 (16) null:w           (abs)TempRow0(0)                beta:w
  104.         // abs(q1-q0) < Beta
  105.         (f0.0) cmp.l.f0.0 (16) null:w           (abs)TempRow1(0)                beta:w
  106.  
  107.         //-----------------------------------------------------------------------------------------
  108.  
  109.     (f0.0)      if      (16)            Y_ENDIF1
  110.                 // For channels whose edge control map1 = 1 ---> perform de-blocking
  111.  
  112. //              mov (1)         f0.1:uw         MaskB:uw        {NoMask}                // Now check for which algorithm to apply
  113.  
  114.                 // (abs)ap = |p2-p0|
  115.                 add (16) ap(0)<1>               P2              -P0             // ap = p2-p0
  116.                 // (abs)aq = |q2-q0|
  117.                 add (16) aq(0)<1>               Q2              -Q0             // aq = q2-q0
  118.  
  119.                 // Make a copy of unmodified p0 and p1 for use in q0'and q1' calculation
  120.                 mov (16) p0123_W(1)<1>          r[P_AddrReg, 32]<16;16,1>:uw            {NoMask}
  121.  
  122.                 (f0.1)  if      (16)            Y_ELSE2
  123.  
  124.                         // For channels whose edge control map2 = 1 ---> bS = 4 algorithm
  125.  
  126.                         // Compute q0', q1' and q2'
  127.                         //-----------------------------------------------------------------------------
  128.                         // bS = 4 Algorithm :                  
  129.                         //
  130.                         // gama = |p0-q0| < ((alpha >> 2) + 2)
  131.                         // deltap = (ap<beta) && gama;                  // deep filter flag
  132.                         //      if (deltap) {
  133.                         //              p0' = (        p2 +2*p1 +2*p0 +2*q0 + q1 + 4) >> 3;
  134.                         //              p1' = (        p2 +  p1 +  p0 +  q0      + 2) >> 2;
  135.                         //              p2' = (2*p3 +3*p2 +  p1 +  p0 +  q0      + 4) >> 3;
  136.                         //      } else {  
  137.                         //              p0' = (            2*p1 +  p0 +  q1      + 2) >> 2;
  138.                         //      }
  139.                         //-----------------------------------------------------------------------------
  140.  
  141.                         // gama = |p0-q0| < ((alpha >> 2) + 2) = |p0-q0| < alpha2  
  142.                         cmp.l.f0.1 (16) null:w  (abs)q0_p0(0)   alpha2:w
  143.  
  144.                         // Common P01 = p0 + p1
  145.                         add (16)        P0_plus_P1(0)<1>        P0                      P1     
  146.  
  147.                         // Common Q01 = q0 + q1
  148.                         add (16)        Q0_plus_Q1(0)<1>        Q0                      Q1
  149.  
  150. //                      mov (1) CTemp1_W:w              f0.1:uw                                         {NoMask}
  151.                         mov (1) f0.0:uw                 f0.1:uw                                         {NoMask}
  152.        
  153.                         // deltap = ((abs)ap < beta) && gama
  154.                         (f0.1) cmp.l.f0.1 (16) null:w   (abs)ap(0)              beta<0;1,0>:w                                                   // (abs)ap < beta ?
  155.  
  156.                         // deltaq = ((abs)aq < beta) && gama
  157.                         (f0.0) cmp.l.f0.0 (16) null:w   (abs)aq(0)              beta<0;1,0>:w                                                   // (abs)aq < beta ?
  158.  
  159.  
  160. //                      mov (1) CTemp1_W:w              f0.0:uw                                         {NoMask}                                        // gama = |p0-q0| < ((alpha >> 2) + 2) for each channel
  161. //                      and (1)         f0.1:w          f0.1:uw         CTemp1_W:w              {NoMask}                                        // deltap = (ap<beta) && gama
  162.  
  163.  
  164.                         (f0.1)  if      (16)            Y_ELSE3                 // for channels its deltap = true
  165.  
  166.                         add (16)        P2_plus_P3(0)<1>        P2              P3
  167.                        
  168.                         // A =  (p1 + p0) + q0 = P01 + q0
  169.                         add (16)        A(0)<1>                 P0_plus_P1(0)           Q0                                                      // A =  P01 + q0
  170.  
  171.                         // Now acc0 = A
  172.  
  173.                         // B =  p2 + (p1 + p0 + q0) + 4 = p2 + A + 4
  174. //                      add (16)        acc0.0<1>:w             P2                              4:w                                                             // p2 + 4
  175. //                      add (16)        BB(0)<1>                        acc0.0<16;16,1>:w               A(0)                                    // B = p2 + A + 4
  176.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w               4:w                                                             // p2 + 4
  177.                         add (16)        BB(0)<1>                        acc0.0<16;16,1>:w               P2                                      // B = p2 + A + 4
  178.                        
  179.                         // Now acc0 = B
  180.  
  181.                         // p2' = (2*p3 +3*p2 + A + 4) >> 3 = (2*(p3+p2) + B) >> 3
  182. //                      mov     (16)    acc0.0<1>:w             BB(0)
  183.                         mac (16)        acc0.0<1>:w             P2_plus_P3(0)           2:w            
  184.                         shr.sat (16) TempRow3B(0)<2>    acc0.0<16;16,1>:w               3:w
  185.                        
  186.                         // p1' = (p2 + A + 2) >> 2 = (B - 2) >> 2
  187.                         add (16)        acc0.0<1>:w             BB(0)                   -2:w
  188.                         shr.sat (16) TempRow1B(0)<2>    acc0.0<16;16,1>:w               2:w
  189.        
  190.                         // p0' = (p2 +2*A + q1 + 4) >> 3 = (B + A + q1) >> 3
  191.                         add (16)        acc0.0<1>:w             Q1                              A(0)                                                    // B + A
  192.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w               BB(0)                                                   // B + A + q1
  193.                         shr.sat (16) TempRow0B(0)<2>    acc0.0<16;16,1>:w               3:w                                                             // (B + A + q1) >> 3
  194.  
  195.                         // p2' = (2*p3 +3*p2 + A + 4) >> 3 = (2*(p3+p2) + B) >> 3
  196. //                      mov     (16)    acc0.0<1>:w             BB(0)
  197. //                      mac (16)        acc0.0<1>:w             P2_plus_P3(0)           2:w            
  198. //                      shr.sat (16) TempRow3B(0)<2>    acc0.0<16;16,1>:w               3:w
  199.  
  200.                         mov (16)        NewP2           TempRow3B(0)                                            // p2'
  201.                         mov (16)        NewP1           TempRow1B(0)                                            // p1'                 
  202.                         mov (16)        NewP0           TempRow0B(0)                                            // p0'
  203.  
  204. Y_ELSE3:
  205.                         else (16)               Y_ENDIF3                // for channels its deltap = false
  206.  
  207.                         // p0' = (2*p1 + p0 + q1 + 2) >> 2 =  (p1 + P01 + q1 + 2) >> 2
  208.                         add (16)        acc0.0<1>:w             P1                      P0_plus_P1(0)                   // p1 + P01 (TempRow1(0) = P01)
  209.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w       Q1                             
  210.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w       2:w                     // p1 + P01 + q1 + 2
  211.  
  212.                         shr.sat (16) TempRow0B(0)<2>    acc0.0<16;16,1>:w               2:w     // >> 2
  213.                         mov (16)        NewP0           TempRow0B(0)                                            // p0'
  214.  
  215.                         endif
  216. Y_ENDIF3:
  217.                         // Compute q0', q1' and q2'
  218.                         //-----------------------------------------------------------------------------
  219.                         // bS = 4 Algorithm (cont):                    
  220.                         //
  221.                         //      deltaq = (aq<beta) && gama;             // deep filter flag
  222.                         //      if (deltaq) {
  223.                         //              q0' = (        q2 +2*q1 +2*q0 +2*p0 + p1 + 4) >> 3;
  224.                         //              q1' = (        q2 +  q1 +  q0 +  p0      + 2) >> 2;
  225.                         //              q2' = (2*q3 +3*q2 +  q1 +  q0 +  p0      + 4) >> 3;
  226.                         //      } else {
  227.                         //              q0' = (            2*q1 +  q0 +  p1      + 2) >> 2;
  228.                         //      }
  229.                        
  230.                         // deltaq = ((abs)aq < beta) && gama
  231. //                      cmp.l.f0.1 (16) null:w  (abs)aq(0)              beta<0;1,0>:w                                                   // (abs)aq < beta ?
  232.  
  233.                         // Common Q01 = q0 + q1
  234. //                      add (16)        Q0_plus_Q1(0)<1>        Q0                      Q1
  235.                        
  236. //                      and (1)         f0.1:w          f0.1:uw         CTemp1_W:w              {NoMask}                                // deltaq = ((abs)ap < beta) && gama
  237.  
  238.                         (f0.0)  if      (16)            Y_ELSE4                 // for channels its deltaq = true
  239.                        
  240.                         add (16)        Q2_plus_Q3(0)<1>        Q2                      Q3
  241.  
  242.                         // A =  (q1 + q0) + p0 = Q01 + p0
  243.                         add (16)        A(0)<1>                 Q0_plus_Q1(0)           p0(0)                                                   // A =  q1+q0 + p0
  244.  
  245.                         // Acc0 = A
  246.  
  247.                         // B =  q2 + q1 + q0 + p0 + 4 = q2 + A + 4
  248.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w               4:w                                                     // q2 + 4
  249.                         add (16)        BB(0)<1>                        acc0.0<16;16,1>:w               Q2                                                              // B = q2 + A + 4
  250.  
  251.                         // Acc0 = B
  252.                        
  253.                         // q2' = (2*q3 +3*q2 + A + 4) >> 3 = (2*(q3+q2) + B) >> 3
  254. //                      mov (16)        acc0.0<1>:w             BB(0)  
  255.                         mac (16)        acc0.0<1>:w             Q2_plus_Q3(0)   2:w
  256.                         shr.sat (16) TempRow3B(0)<2>    acc0.0<16;16,1>:w               3:w
  257.  
  258.                         // q1' = (q2 + A + 2) >> 2 = (B - 2) >> 2
  259.                         add (16)        acc0.0<1>:w             BB(0)                   -2:w
  260.                         shr.sat (16) TempRow1B(0)<2>    acc0.0<16;16,1>:w       2:w
  261.                        
  262.                         // q0' = (q2 +2*A + p1 + 4) >> 3 = (B + A + p1) >> 3
  263.                         add (16)        acc0.0<1>:w             p1(0)                                   A(0)
  264.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w               BB(0)
  265.                         shr.sat (16) TempRow0B(0)<2>    acc0.0<16;16,1>:w       3:w
  266.                        
  267.                         mov (16)        NewQ2           TempRow3B(0)                                            // q2'
  268.                         mov (16)        NewQ1           TempRow1B(0)                                            // q1'
  269.                         mov (16)        NewQ0           TempRow0B(0)                                            // q0'
  270.  
  271. Y_ELSE4:
  272.                         else (16)               Y_ENDIF4                // for channels its deltaq = false
  273.  
  274.                         // q0' = (2*q1 + q0 + p1 + 2) >> 2 =  (q1 + Q01 + p1 + 2) >> 2
  275.                         // Use original p1 values in p1(0)
  276.                         add (16)        acc0.0<1>:w             p1(0)                   Q0_plus_Q1(0)                   // p1 + P01 (TempRow1(0) = P01)
  277.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w       Q1                             
  278.                         add (16)        acc0.0<1>:w             acc0.0<16;16,1>:w       2:w                     // p1 + P01 + q1 + 2
  279.  
  280.                         shr.sat (16)    TempRow0B(0)<2>         acc0.0<16;16,1>:w               2:w                                                             // >> 2
  281.                         mov (16)        NewQ0           TempRow0B(0)                                            // q0'
  282.  
  283.                         endif
  284. Y_ENDIF4:
  285.  
  286.                        
  287.                         // Done with bS = 4 algorithm
  288.                        
  289. Y_ELSE2:
  290.                 else    (16)            Y_ENDIF2
  291.                         // For channels whose edge control map2 = 0 ---> bS < 4 algorithm
  292.  
  293.                         //-----------------------------------------------------------------------------
  294.                         // bS < 4 Algorithm :
  295.                         // tc = tc0 + (|p2-p0|<Beta ? 1 : 0) + (|q2-q0|<Beta ? 1 : 0)
  296.                         // delta = Clip3(-tc, tc, ((((q0-p0)<<2) + (p1-q1) + 4) >> 3))
  297.                         // p0' = Clip1(p0 + delta) = Clip3(0, 0xFF, p0 + delta)
  298.                         // q0' = Clip1(q0 - delta) = Clip3(0, 0xFF, q0 - delta)
  299.                         // if (|p2-p0|<Beta)
  300.                         //              p1' = p1 + Clip3(-tc0, tc0, (p2 + ((p0+q0+1)>>1) - (p1<<1)) >> 1 )
  301.                         // if (|q2-q0|<Beta)
  302.                         //              q1' = q1 + Clip3(-tc0, tc0, (q2 + ((p0+q0+1)>>1) - (q1<<1)) >> 1 )
  303.                         //-----------------------------------------------------------------------------
  304.                        
  305.                         // Expand tc0
  306.                         mov (16)        tc_exp(0)<1>    tc0<1;4,0>:ub   {NoMask}
  307.                         mov (16)        tc0_exp(0)<1>   tc0<1;4,0>:ub   {NoMask}                                        // tc0_exp = tc0, each tc0 is duplicated 4 times for 4 adjcent 4 pixels
  308.                                                
  309.                         // tc_exp = tc0_exp + (|p2-p0|<Beta ? 1 : 0) + (|q2-q0|<Beta ? 1 : 0)                  
  310. //                      mov (16)        tc_exp(0)<1>            tc0_exp(0)                                                                      // tc = tc0_exp first
  311.                        
  312.  
  313.                         cmp.l.f0.0 (16) null:w          (abs)ap(0)                      beta:w                                          // |p2-p0|< Beta ? ---> (abs)ap < Beta ?
  314.                         cmp.l.f0.1 (16) null:w          (abs)aq(0)                      beta:w                                          // |q2-q0|< Beta ? ---> (abs)aq < Beta ?
  315.                        
  316.                         //--- Use free cycles here ---
  317.                         // delta = Clip3(-tc, tc, ((((q0-p0)<<2) + (p1-q1) + 4) >> 3))
  318.                         // 4 * (q0-p0) + p1 - q1 + 4
  319.                         add (16) acc0<1>:w              P1                      4:w                                                     // p1 + 4
  320.                         mac (16) acc0<1>:w              q0_p0(0)        4:w                                                     // 4 * (q0-p0) + p1 + 4
  321.                         add (16) acc0<1>:w              acc0<16;16,1>:w         -Q1                                     // 4 * (q0-p0) + p1 - q1 + 4
  322.                         shr (16) TempRow0(0)<1> acc0<16;16,1>:w         3:w
  323.                                                
  324.                         // Continue on getting tc_exp
  325.                         (f0.0) add (16) tc_exp(0)<1>    tc_exp(0)       1:w                                                     // tc0_exp + (|p2-p0|<Beta ? 1 : 0)
  326.                         mov (2) CTemp1_W<1>:w           f0.0<2;2,1>:w                   {NoMask}                                        // Save |p2-p0|<Beta flag                      
  327.                         (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)
  328.                        
  329.  
  330.                         // Continue on cliping tc to get delta
  331.                         cmp.g.f0.0      (16) null:w             TempRow0(0)             tc_exp(0)                                       // Clip if delta' > tc
  332.                         cmp.l.f0.1      (16) null:w             TempRow0(0)             -tc_exp(0)                                      // Clip if delta' < -tc
  333.  
  334.                         //--- Use free cycles here ---
  335.                         // common = (p0+q0+1) >> 1        --->  TempRow2(0)
  336.                         // Same as avg of p0 and q0
  337.                         avg (16) TempRow2(0)<1>         P0                      Q0
  338.  
  339.                         // Continue on cliping tc to get delta
  340.                         (f0.0) mov (16) TempRow0(0)<1>                          tc_exp(0)
  341.                         (f0.1) mov (16) TempRow0(0)<1>                          -tc_exp(0)
  342.  
  343.                         //--- Use free cycles here ---
  344.                         mov (2) f0.0<1>:w               CTemp1_W<2;2,1>:w       {NoMask}                        // CTemp1_W = (|p2-p0|<Beta)
  345.                                                                                                                                                         // CTemp2_W = (|q2-q0|<Beta)           
  346.                         //-----------------------------------------------------------------------
  347.  
  348.                         // p0' = Clip1(p0 + delta) = Clip3(0, 0xFF, p0 + delta)
  349.                         // q0' = Clip1(q0 - delta) = Clip3(0, 0xFF, q0 - delta)
  350.                         add.sat (16) TempRow1B(0)<2>            P0                      TempRow0(0)                                     // p0+delta
  351.                         add.sat (16) TempRow0B(0)<2>            Q0                      -TempRow0(0)                            // q0-delta
  352.                         mov (16) NewP0          TempRow1B(0)                                    // p0'
  353.                         mov (16) NewQ0          TempRow0B(0)                                    // q0'
  354.                         //-----------------------------------------------------------------------
  355.  
  356.                         // Now compute p1' and q1'
  357.  
  358.                         // if (|p2-p0|<Beta)
  359. //                      mov (1) f0.0:w          CTemp1_W:w                              {NoMask}                        // CTemp1_W = (|p2-p0|<Beta)
  360.                         (f0.0)  if      (16)            Y_ENDIF6
  361.                
  362.                         // p1' = p1 + Clip3(-tc0, tc0, adj)
  363.                         // adj = (p2 + common - (p1<<1)) >> 1 = (p2 + common - (p1*2)) >> 1
  364.                         add (16) acc0<1>:w      P2              TempRow2(0)                                                     // TempRow2(0) = common = (p0+q0+1) >> 1
  365.                         mac (16) acc0<1>:w      P1              -2:w
  366.                         shr (16) TempRow1(0)<1>         acc0<16;16,1>:w         1:w
  367.  
  368.                         // tc clip to get tc_adj
  369.                         cmp.g.f0.0      (16) null:w             TempRow1(0)             tc0_exp(0)                                      // Clip if delta' > tc
  370.                         cmp.l.f0.1      (16) null:w             TempRow1(0)             -tc0_exp(0)                                     // Clip if delta' < -tc
  371.                        
  372.                         (f0.0) mov (16) TempRow1(0)<1>                          tc0_exp(0)
  373.                         (f0.1) mov (16) TempRow1(0)<1>                          -tc0_exp(0)
  374.  
  375.                         //--- Use free cycles here ---
  376.                         mov (1) f0.1:w          CTemp2_W:w                              {NoMask}                        // CTemp2_W = (|q2-q0|<Beta)
  377.  
  378.                         // p1' = p1 + tc_adj
  379.                         add.sat (16) TempRow1B(0)<2>            P1                      TempRow1(0)                                     // p1+tc_adj
  380.                         mov (16) NewP1                  TempRow1B(0)                            // p1'
  381.  
  382.                         //------------------------------------------------------------------------
  383. Y_ENDIF6:
  384.                         endif
  385.                        
  386.                         // if (|q2-q0|<Beta)
  387. //                      mov (1) f0.1:w          CTemp2_W:w                              {NoMask}                        // CTemp2_W = (|q2-q0|<Beta)
  388.                         (f0.1)  if      (16)            Y_ENDIF7
  389.                                        
  390.                         // q1' = q1 + Clip3(-tc0, tc0, adj)
  391.                         // adj = (q2 + common - (q1<<1)) >> 1
  392.                         // same as q2 + common - (q1 * 2)
  393.                         add (16) acc0<1>:w      Q2              TempRow2(0)
  394.                         mac (16) acc0<1>:w      Q1              -2:w
  395.                         shr (16) TempRow1(0)<1>         acc0<16;16,1>:w         1:w    
  396.  
  397.                         // tc clip to get tc_adj
  398.                         cmp.g.f0.0      (16) null:w             TempRow1(0)             tc0_exp(0)                                      // Clip if delta' > tc
  399.                         cmp.l.f0.1      (16) null:w             TempRow1(0)             -tc0_exp(0)                                     // Clip if delta' < -tc
  400.  
  401.                         (f0.0) mov (16) TempRow1(0)<1>                          tc0_exp(0)
  402.                         (f0.1) mov (16) TempRow1(0)<1>                          -tc0_exp(0)
  403.  
  404.                         // q1' = q1 + tc_adj
  405.                         add.sat (16) TempRow1B(0)<2>            Q1                      TempRow1(0)                                     // q1+tc_adj
  406.                         mov (16) NewQ1                  TempRow1B(0)                            // q1'
  407.  
  408.                         //------------------------------------------------------------------------                     
  409. Y_ENDIF7:
  410.                         endif
  411.  
  412.                 endif
  413. Y_ENDIF2:
  414. Y_ENDIF1:
  415.         endif
  416.  
  417. RETURN
  418.  
  419. #endif  // !defined(__AVC_ILDB_LUMA_CORE__)
  420.