开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
deblock.c
资源名称：h264src.zip　[点击查看]
上传用户：sunbaby
上传日期：2013-05-31
资源大小：242k
文件大小：25k
源码类别：

mpeg/mp3

开发平台：

Visual C++

deblock.c：源码内容
  1. /*****************************************************************************
  2. *
  3. *  T264 AVC CODEC
  4. *
  5. *  Copyright(C) 2004-2005 llcc <lcgate1@yahoo.com.cn>
  6. *               2004-2005 visionany <visionany@yahoo.com.cn>
  7. * Added support for B frame,20041223 Cloud Wu<sywu@sohu.com>
  8. *  This program is free software ; you can redistribute it and/or modify
  9. *  it under the terms of the GNU General Public License as published by
  10. *  the Free Software Foundation ; either version 2 of the License, or
  11. *  (at your option) any later version.
  12. *
  13. *  This program is distributed in the hope that it will be useful,
  14. *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
  15. *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. *  GNU General Public License for more details.
  17. *
  18. *  You should have received a copy of the GNU General Public License
  19. *  along with this program ; if not, write to the Free Software
  20. *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21. *
  22. ****************************************************************************/
  24. #include "stdio.h"
  25. #include "T264.h"
  26. #include "assert.h"
  28. #define IS_INTRA(mode) (mode <= I_16x16)
  30. static const uint8_t deblock_threshold_a[] = 
  31. {
  32.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  33.     0, 0, 0, 4, 4, 5, 6, 7, 8, 9, 10, 12, 13,
  34.     15,17,20,22,25,28,32,36,40,45,50,56,63,71,
  35.     80,90,101,113,127,144,162,182,203,226,255,255
  36. };
  38. static const uint8_t deblock_threshold_b[] = 
  39. {
  40.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  41.     0, 0, 0, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,
  42.     6, 6, 7, 7, 8, 8, 9, 9,10,10,11,11,12,
  43.     12,13,13,14,14,15,15,16,16,17,17,18,18
  44. };
  46. static const uint8_t deblock_threshold_tc0[][3] = 
  47. {
  48.     { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 },
  49.     { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 },
  50.     { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 1 },
  51.     { 0, 0, 1 }, { 0, 0, 1 }, { 0, 0, 1 }, { 0, 1, 1 }, { 0, 1, 1 }, { 1, 1, 1 },
  52.     { 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 2 }, { 1, 1, 2 }, { 1, 1, 2 },
  53.     { 1, 1, 2 }, { 1, 2, 3 }, { 1, 2, 3 }, { 2, 2, 3 }, { 2, 2, 4 }, { 2, 3, 4 },
  54.     { 2, 3, 4 }, { 3, 3, 5 }, { 3, 4, 6 }, { 3, 4, 6 }, { 4, 5, 7 }, { 4, 5, 8 },
  55.     { 4, 6, 9 }, { 5, 7,10 }, { 6, 8,11 }, { 6, 8,13 }, { 7,10,14 }, { 8,11,16 },
  56.     { 9,12,18 }, {10,13,20 }, {11,15,23 }, {13,17,25 }
  57. };
  59. static void __inline
  60. get_strength(T264_t* t, uint8_t bS[4], int32_t dir, int32_t edge, T264_mb_context_t* cur, T264_mb_context_t* prev)
  61. {
  62.     int32_t row_stride, col_stride;
  63.     int32_t n;
  64.     
  65.     if (dir == 0)
  66.     {
  67.         row_stride = 4;
  68.         col_stride = 1;
  69.     }
  70.     else
  71.     {
  72.         row_stride = 1;
  73.         col_stride = 4;
  74.     }
  76.     if (IS_INTRA(cur->mb_mode) || IS_INTRA(prev->mb_mode))
  77.     {
  78.         bS[0] = bS[1] = bS[2] = bS[3] = (edge == 0) ? 4 : 3;
  79.     }
  80.     else
  81.     {
  82.         for(n = 0 ; n < 4 ; n ++)
  83.         {
  84.             int32_t pos = n * row_stride + edge * col_stride;
  85.             int32_t pos_n;
  86.             if (cur == prev)
  87.             { //If is macro blcok border
  88.                 pos_n = dir == 0 ? pos - 1 : pos - 4;
  89.             }
  90.             else
  91.             {
  92.                 pos_n = dir == 0 ? 4 * n + 3 : 12 + n;
  93.             }
  94.             if (cur->nnz[pos] || prev->nnz[pos_n])
  95.             {
  96.                 bS[n] = 2;
  97.             }
  98.             else if (t->slice_type == SLICE_P) 
  99.             {
  100.                 int32_t ref, ref_n;
  101.                 ref = cur->vec[0][pos].refno;
  102.                 ref_n = prev->vec[0][pos_n].refno;
  103.                 assert(cur->vec[0][pos].refno != -2);
  104.                 assert(prev->vec[0][pos_n].refno != -2);
  105.                 bS[n] = ((ref != ref_n) |
  106.                     (ABS(cur->vec[0][pos].x - prev->vec[0][pos_n].x) >= 4) |
  107.                     (ABS(cur->vec[0][pos].y - prev->vec[0][pos_n].y) >= 4));
  108.             }
  109.             else 
  110.             {
  111.                 int32_t ref0,ref1, ref_n0,ref_n1;
  112.                 
  113.                 ref0 = cur->vec[0][pos].refno;
  114.                 ref1 = cur->vec[1][pos].refno;                
  115.                 ref_n0 = prev->vec[0][pos_n].refno;  
  116.                 ref_n1 = prev->vec[1][pos_n].refno;       
  118. ref0 = ref0 < 0? -1 : ref0;
  119. ref1 = ref1 < 0? -1 : ref1 + MAX_REFFRAMES;
  120.                 ref_n0 = ref_n0 < 0? -1 : ref_n0;  
  121.                 ref_n1 = ref_n1 < 0? -1 : ref_n1 + MAX_REFFRAMES;  
  123.                 assert(ref0 > -1 || ref1 > -1);
  124. if((ref0 == ref_n0 && ref1 == ref_n1) ||
  125. (ref1 == ref_n0 && ref0 == ref_n1))
  126. {
  127.                  bS[n] = 0;
  128.                  if(ref0 == ref1)
  129.                 { //if all use the same reference frame
  130. bS[n] = (
  131. (ABS(cur->vec[0][pos].x - prev->vec[0][pos_n].x) >= 4) |
  132. (ABS(cur->vec[0][pos].y - prev->vec[0][pos_n].y) >= 4) |
  133. (ABS(cur->vec[1][pos].x - prev->vec[1][pos_n].x) >= 4) |
  134. (ABS(cur->vec[1][pos].y - prev->vec[1][pos_n].y) >= 4))
  135. &&
  136. (
  137. (ABS(cur->vec[0][pos].x - prev->vec[1][pos_n].x) >= 4) |
  138. (ABS(cur->vec[0][pos].y - prev->vec[1][pos_n].y) >= 4) |
  139. (ABS(cur->vec[1][pos].x - prev->vec[0][pos_n].x) >= 4) |
  140. (ABS(cur->vec[1][pos].y - prev->vec[0][pos_n].y) >= 4));
  141.                 }else
  142.               {
  143.               if(ref0 == ref_n0)
  144.                 { //if list0 reference frame are the same
  145.                  bS[n] = 
  146.                  (ABS(cur->vec[0][pos].x - prev->vec[0][pos_n].x) >= 4) |
  147. (ABS(cur->vec[0][pos].y - prev->vec[0][pos_n].y) >= 4) |
  148. (ABS(cur->vec[1][pos].x - prev->vec[1][pos_n].x) >= 4) |
  149. (ABS(cur->vec[1][pos].y - prev->vec[1][pos_n].y) >= 4);
  150.                  }else
  151.                 {
  152.                 bS[n] = 
  153.                 (ABS(cur->vec[0][pos].x - prev->vec[1][pos_n].x) >= 4) |
  154. (ABS(cur->vec[0][pos].y - prev->vec[1][pos_n].y) >= 4) |
  155. (ABS(cur->vec[1][pos].x - prev->vec[0][pos_n].x) >= 4) |
  156. (ABS(cur->vec[1][pos].y - prev->vec[0][pos_n].y) >= 4);
  157.                 }
  158.              }
  159.                 }else
  160.                 {
  161.                  bS[n] =1;
  162.                 }
  163.             }
  164.        }
  165.     }
  166. }
  168. static __inline void
  169. EdgeLoopH(T264_t* t, uint8_t* dst, int32_t stride, uint8_t indexA, int32_t alpha, int32_t beta, uint8_t bS, int32_t is_chroma)
  170. {
  171.     int32_t ap, aq, tmp;
  172.     uint8_t p[4];
  173.     uint8_t q[4];
  175.     q[0] = dst[0];
  176.     p[0] = dst[-1];
  178.     if (ABS(p[0] - q[0]) < alpha)
  179.     {
  180.         p[1] = dst[-2];
  181.         if (ABS(p[1] - p[0]) < beta)
  182.         {
  183.             q[1] = dst[1];
  184.             if (ABS(q[1] - q[0]) < beta)
  185.             {
  186.                 if (bS < 4)
  187.                 {
  188.                     int32_t tc0, tc, delta;
  190.                     tc0 = deblock_threshold_tc0[indexA][bS - 1];
  191.                     if (is_chroma == 0)
  192.                     {
  193.                         q[2] = dst[2];
  194.                         p[2] = dst[-3];
  195.                         ap = ABS(p[2] - p[0]);
  196.                         aq = ABS(q[2] - q[0]);
  198.                         tc =  tc0;
  199.                         if (ap < beta)
  200.                         {
  201.                             dst[-2] = p[1] + clip3(((p[2] + ((p[0] + q[0] + 1) >> 1) - (p[1] << 1)) >> 1), -tc0, tc0);
  202.                             tc ++;
  203.                         }
  204.                         if (aq < beta)
  205.                         {
  206.                             dst[1] = q[1] + clip3(((q[2] + ((p[0] + q[0] + 1) >> 1) - (q[1] << 1)) >> 1), -tc0, tc0);
  207.                             tc ++;
  208.                         }
  209.                     }
  210.                     else
  211.                     {
  212.                         tc = tc0 + 1;
  213.                     }
  214.                     delta = clip3(((((q[0] - p[0]) << 2) + (p[1] - q[1]) + 4) >> 3), -tc, tc);
  215.                     tmp = p[0] + delta;
  216.                     dst[-1] = CLIP1(tmp);
  217.                     tmp = q[0] - delta;
  218.                     dst[0] = CLIP1(tmp);
  219.                 }
  220.                 else
  221.                 {
  222.                     if (ABS(p[0] - q[0]) < ((alpha >> 2) + 2))
  223.                     {
  224.                         if (is_chroma == 0)
  225.                         {
  226.                             q[2] = dst[2];
  227.                             p[2] = dst[-3];
  228.                             ap = ABS(p[2] - p[0]);
  229.                             aq = ABS(q[2] - q[0]);
  231.                             if (ap < beta)
  232.                             {
  233.                                 p[3] = dst[-4];
  235.                                 dst[-1] = (p[2] + 2 * p[1] + 2 * p[0] + 2 * q[0] + q[1] + 4) >> 3;
  236.                                 dst[-2] = (p[2] + p[1] + p[0] + q[0] + 2) >> 2;
  237.                                 dst[-3] = (2 * p[3] + 3 * p[2] + p[1] + p[0] + q[0] + 4) >> 3;
  238.                             }
  239.                             else
  240.                             {
  241.                                 dst[-1] = (2 * p[1] + p[0] + q[1] + 2 ) >> 2;
  242.                             }
  243.                             if (aq < beta)
  244.                             {
  245.                                 q[3] = dst[3];
  247.                                 dst[0] = (p[1] + 2 * p[0] + 2 * q[0] + 2 * q[1] + q[2] + 4) >> 3;
  248.                                 dst[1] = (p[0] + q[0] + q[1] + q[2] + 2) >> 2;
  249.                                 dst[2] = (2 * q[3] + 3 * q[2] + q[1] + q[0] + p[0] + 4) >> 3;
  250.                             }
  251.                             else
  252.                             {
  253.                                 dst[0] = (2 * q[1] + q[0] + p[1] + 2 ) >> 2;
  254.                             }
  255.                         }
  256.                         else
  257.                         {
  258.                             dst[-1] = (2 * p[1] + p[0] + q[1] + 2 ) >> 2;
  259.                             dst[0] = (2 * q[1] + q[0] + p[1] + 2 ) >> 2;
  260.                         }
  261.                     }
  262.                     else
  263.                     {
  264.                         dst[-1] = (2 * p[1] + p[0] + q[1] + 2 ) >> 2;
  265.                         dst[0] = (2 * q[1] + q[0] + p[1] + 2 ) >> 2;
  266.                     }
  267.                 }
  268.             }
  269.         }
  270.     }
  271. }
  273. static __inline void
  274. EdgeLoopV(T264_t* t, uint8_t* dst, int32_t stride, uint8_t indexA, int32_t alpha, int32_t beta, uint8_t bS, int32_t is_chroma)
  275. {
  276.     int32_t ap, aq, tmp;
  277.     uint8_t p[4];
  278.     uint8_t q[4];
  280.     q[0] = dst[0];
  281.     p[0] = dst[-1 * stride];
  283.     if (ABS(p[0] - q[0]) < alpha)
  284.     {
  285.         p[1] = dst[-2 * stride];
  286.         if (ABS(p[1] - p[0]) < beta)
  287.         {
  288.             q[1] = dst[1 * stride];
  289.             if (ABS(q[1] - q[0]) < beta)
  290.             {
  291.                 if (bS < 4)
  292.                 {
  293.                     int32_t tc0, tc, delta;
  295.                     tc0 = deblock_threshold_tc0[indexA][bS - 1];
  296.                     if (is_chroma == 0)
  297.                     {
  298.                         q[2] = dst[2 * stride];
  299.                         p[2] = dst[-3 * stride];
  300.                         ap = ABS(p[2] - p[0]);
  301.                         aq = ABS(q[2] - q[0]);
  303.                         tc =  tc0;
  304.                         if (ap < beta)
  305.                         {
  306.                             dst[-2 * stride] = p[1] + clip3(((p[2] + ((p[0] + q[0] + 1) >> 1) - (p[1] << 1)) >> 1), -tc0, tc0);
  307.                             tc ++;
  308.                         }
  309.                         if (aq < beta)
  310.                         {
  311.                             dst[1 * stride] = q[1] + clip3(((q[2] + ((p[0] + q[0] + 1) >> 1) - (q[1] << 1)) >> 1), -tc0, tc0);
  312.                             tc ++;
  313.                         }
  314.                     }
  315.                     else
  316.                     {
  317.                         tc = tc0 + 1;
  318.                     }
  319.                     delta = clip3(((((q[0] - p[0]) << 2) + (p[1] - q[1]) + 4) >> 3), -tc, tc);
  320.                     tmp = p[0] + delta;
  321.                     dst[-1 * stride] = CLIP1(tmp);
  322.                     tmp = q[0] - delta;
  323.                     dst[0] = CLIP1(tmp);
  324.                 }
  325.                 else
  326.                 {
  327.                     if (ABS(p[0] - q[0]) < ((alpha >> 2) + 2))
  328.                     {
  329.                         if (is_chroma == 0)
  330.                         {
  331.                             q[2] = dst[2 * stride];
  332.                             p[2] = dst[-3 * stride];
  333.                             ap = ABS(p[2] - p[0]);
  334.                             aq = ABS(q[2] - q[0]);
  336.                             if (ap < beta)
  337.                             {
  338.                                 p[3] = dst[-4 * stride];
  340.                                 dst[-1 * stride] = (p[2] + 2 * p[1] + 2 * p[0] + 2 * q[0] + q[1] + 4) >> 3;
  341.                                 dst[-2 * stride] = (p[2] + p[1] + p[0] + q[0] + 2) >> 2;
  342.                                 dst[-3 * stride] = (2 * p[3] + 3 * p[2] + p[1] + p[0] + q[0] + 4) >> 3;
  343.                             }
  344.                             else
  345.                             {
  346.                                 dst[-1 * stride] = (2 * p[1] + p[0] + q[1] + 2 ) >> 2;
  347.                             }
  348.                             if (aq < beta)
  349.                             {
  350.                                 q[3] = dst[3 * stride];
  352.                                 dst[0 * stride] = (p[1] + 2 * p[0] + 2 * q[0] + 2 * q[1] + q[2] + 4) >> 3;
  353.                                 dst[1 * stride] = (p[0] + q[0] + q[1] + q[2] + 2) >> 2;
  354.                                 dst[2 * stride] = (2 * q[3] + 3 * q[2] + q[1] + q[0] + p[0] + 4) >> 3;
  355.                             }
  356.                             else
  357.                             {
  358.                                 dst[0] = (2 * q[1] + q[0] + p[1] + 2 ) >> 2;
  359.                             }
  360.                         }
  361.                         else
  362.                         {
  363.                             dst[-1 * stride] = (2 * p[1] + p[0] + q[1] + 2 ) >> 2;
  364.                             dst[0] = (2 * q[1] + q[0] + p[1] + 2 ) >> 2;
  365.                         }
  366.                     }
  367.                     else
  368.                     {
  369.                         dst[-1 * stride] = (2 * p[1] + p[0] + q[1] + 2 ) >> 2;
  370.                         dst[0] = (2 * q[1] + q[0] + p[1] + 2 ) >> 2;
  371.                     }
  372.                 }
  373.             }
  374.         }
  375.     }
  376. }
  378. void __inline
  379. deblock_mb_chroma(T264_t*t, int32_t x, int32_t y, uint8_t* dst_uv, uint8_t bSV[4][4], uint8_t bSH[4][4],
  380.                   uint8_t indexAc, int32_t alphac, int32_t betac)
  381. {
  382.     uint8_t* dst;
  383.     int32_t i;
  385.     if (x != 0)
  386.     {
  387.         dst = dst_uv;
  388.         for(i = 0 ; i < 4 ; i ++)
  389.         {
  390.             if (bSV[0][i] > 0)
  391.             {
  392.                 EdgeLoopH(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSV[0][i], 1);
  393.                 dst += t->edged_stride_uv;
  394.                 EdgeLoopH(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSV[0][i], 1);
  395.                 dst += t->edged_stride_uv;
  396.             }
  397.             else
  398.             {
  399.                 dst += 2 * t->edged_stride_uv;
  400.             }
  401.         }
  402.     }
  403.     {
  404.         dst = dst_uv + 4;
  405.         for(i = 0 ; i < 4 ; i ++)
  406.         {
  407.             if (bSV[2][i] > 0)
  408.             {
  409.                 EdgeLoopH(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSV[2][i], 1);
  410.                 dst += t->edged_stride_uv;
  411.                 EdgeLoopH(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSV[2][i], 1);
  412.                 dst += t->edged_stride_uv;
  413.             }
  414.             else
  415.             {
  416.                 dst += 2 * t->edged_stride_uv;
  417.             }
  418.         }
  419.     }
  421.     // u
  422.     if (y != 0)
  423.     {
  424.         dst = dst_uv;
  425.         for(i = 0 ; i < 4 ; i ++)
  426.         {
  427.             if (bSH[0][i] > 0)
  428.             {
  429.                 EdgeLoopV(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSH[0][i], 1);
  430.                 dst ++;
  431.                 EdgeLoopV(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSH[0][i], 1);
  432.                 dst ++;
  433.             }
  434.             else
  435.             {
  436.                 dst += 2;
  437.             }
  438.         }
  439.     }
  440.     {
  441.         dst = dst_uv + 4 * t->edged_stride_uv;
  442.         for(i = 0 ; i < 4 ; i ++)
  443.         {
  444.             if (bSH[2][i] > 0)
  445.             {
  446.                 EdgeLoopV(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSH[2][i], 1);
  447.                 dst ++;
  448.                 EdgeLoopV(t, dst, t->edged_stride_uv, indexAc, alphac, betac, bSH[2][i], 1);
  449.                 dst ++;
  450.             }
  451.             else
  452.             {
  453.                 dst += 2;
  454.             }
  455.         }
  456.     }
  457. }
  458. void __inline
  459. deblock_mb_chroma_(T264_t*t, int32_t x, int32_t y, uint8_t* org_dst_u, uint8_t* org_dst_v, uint8_t bSV[4][4], uint8_t bSH[4][4],
  460.                   uint8_t indexAc, int32_t alphac, int32_t betac)
  461. {
  462.     uint8_t* dst_u, *dst_v;
  463.     int32_t i;
  465.     if (x != 0)
  466.     {
  467.         dst_u = org_dst_u;
  468.         dst_v = org_dst_v;
  469.         for(i = 0 ; i < 4 ; i ++)
  470.         {
  471.             if (bSV[0][i] > 0)
  472.             {
  473.                 EdgeLoopH(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSV[0][i], 1);
  474.                 dst_u += t->edged_stride_uv;
  475.                 EdgeLoopH(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSV[0][i], 1);
  476.                 dst_u += t->edged_stride_uv;
  478.                 EdgeLoopH(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSV[0][i], 1);
  479.                 dst_v += t->edged_stride_uv;
  480.                 EdgeLoopH(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSV[0][i], 1);
  481.                 dst_v += t->edged_stride_uv;
  482.             }
  483.             else
  484.             {
  485.                 dst_u += 2 * t->edged_stride_uv;
  486.                 dst_v += 2 * t->edged_stride_uv;
  487.             }
  488.         }
  489.     }
  490.     {
  491.         dst_u = org_dst_u + 4;
  492.         dst_v = org_dst_v + 4;
  493.         for(i = 0 ; i < 4 ; i ++)
  494.         {
  495.             if (bSV[2][i] > 0)
  496.             {
  497.                 EdgeLoopH(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSV[2][i], 1);
  498.                 dst_u += t->edged_stride_uv;
  499.                 EdgeLoopH(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSV[2][i], 1);
  500.                 dst_u += t->edged_stride_uv;
  502.                 EdgeLoopH(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSV[2][i], 1);
  503.                 dst_v += t->edged_stride_uv;
  504.                 EdgeLoopH(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSV[2][i], 1);
  505.                 dst_v += t->edged_stride_uv;
  506.             }
  507.             else
  508.             {
  509.                 dst_u += 2 * t->edged_stride_uv;
  510.                 dst_v += 2 * t->edged_stride_uv;
  511.             }
  512.         }
  513.     }
  515.     // u
  516.     if (y != 0)
  517.     {
  518.         dst_u = org_dst_u;
  519.         dst_v = org_dst_v;
  520.         for(i = 0 ; i < 4 ; i ++)
  521.         {
  522.             if (bSH[0][i] > 0)
  523.             {
  524.                 EdgeLoopV(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSH[0][i], 1);
  525.                 dst_u ++;
  526.                 EdgeLoopV(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSH[0][i], 1);
  527.                 dst_u ++;
  529.                 EdgeLoopV(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSH[0][i], 1);
  530.                 dst_v ++;
  531.                 EdgeLoopV(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSH[0][i], 1);
  532.                 dst_v ++;
  533.             }
  534.             else
  535.             {
  536.                 dst_u += 2;
  537.                 dst_v += 2;
  538.             }
  539.         }
  540.     }
  541.     {
  542.         dst_u = org_dst_u + 4 * t->edged_stride_uv;
  543.         dst_v = org_dst_v + 4 * t->edged_stride_uv;
  544.         for(i = 0 ; i < 4 ; i ++)
  545.         {
  546.             if (bSH[2][i] > 0)
  547.             {
  548.                 EdgeLoopV(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSH[2][i], 1);
  549.                 dst_u ++;
  550.                 EdgeLoopV(t, dst_u, t->edged_stride_uv, indexAc, alphac, betac, bSH[2][i], 1);
  551.                 dst_u ++;
  553.                 EdgeLoopV(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSH[2][i], 1);
  554.                 dst_v ++;
  555.                 EdgeLoopV(t, dst_v, t->edged_stride_uv, indexAc, alphac, betac, bSH[2][i], 1);
  556.                 dst_v ++;
  557.             }
  558.             else
  559.             {
  560.                 dst_u += 2;
  561.                 dst_v += 2;
  562.             }
  563.         }
  564.     }
  565. }
  567. void
  568. deblock_mb(T264_t* t, int32_t y, int32_t x, T264_frame_t* f)
  569. {
  570.     int32_t i, j;
  571.     T264_mb_context_t* cur, *prev;
  572.     uint8_t qpav, qpavc;
  573.     uint8_t indexA, indexB, indexAc, indexBc;
  574.     int32_t alpha, beta, alphac, betac;
  575.     uint8_t bSV[4][4];
  576.     uint8_t bSH[4][4];
  577.     uint8_t* dst_y, *dst_u, *dst_v;
  578.     int32_t mb_xy = t->mb_stride * y + x;
  579.     uint8_t* dst;
  580.     
  581.     cur = &f->mb[mb_xy];
  582.     dst_y = f->Y[0] + (y << 4) * t->edged_stride + (x << 4);
  583.     dst_u = f->U + (y << 3) * t->edged_stride_uv + (x << 3);
  584.     dst_v = f->V + (y << 3) * t->edged_stride_uv + (x << 3);
  585.     // xxx current mb_qp_delta == 0 !!
  586.     qpav = (cur->mb_qp_delta + cur->mb_qp_delta + t->qp_y + t->qp_y + 1) >> 1;
  587.     indexA = clip3(qpav + 0, 0, 51);
  588.     indexB = clip3(qpav + 0, 0, 51);
  589.     alpha = deblock_threshold_a[indexA];
  590.     beta  = deblock_threshold_b[indexB];
  592.     qpavc = (cur->mb_qp_delta + cur->mb_qp_delta + t->qp_uv + t->qp_uv + 1) >> 1;
  593.     indexAc = clip3(qpavc + 0, 0, 51);
  594.     indexBc = clip3(qpavc + 0, 0, 51);
  595.     alphac = deblock_threshold_a[indexAc];
  596.     betac  = deblock_threshold_b[indexBc];
  598.     // vertical first
  599.     // mb edge
  600.     if (x != 0)
  601.     {
  602.         prev = &f->mb[mb_xy - 1];
  603.         get_strength(t, bSV[0], 0, 0, cur, prev);
  604.         
  605.         dst = dst_y;
  606.         for(i = 0 ; i < 4 ; i ++)
  607.         {
  608.             if (bSV[0][i] > 0)
  609.             {
  610.                 EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[0][i], 0);
  611.                 dst += t->edged_stride;
  612.                 EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[0][i], 0);
  613.                 dst += t->edged_stride;
  614.                 EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[0][i], 0);
  615.                 dst += t->edged_stride;
  616.                 EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[0][i], 0);
  617.                 dst += t->edged_stride;
  618.             }
  619.             else
  620.             {
  621.                 dst += 4 * t->edged_stride;
  622.             }
  623.         }
  624.     }
  625.     for(j = 1 ; j < 4 ; j ++)
  626.     {
  627.         prev = cur;
  628.         get_strength(t, bSV[j], 0, j, cur, prev);
  630.         dst = dst_y + 4 * j;
  631.         for(i = 0 ; i < 4 ; i ++)
  632.         {
  633.             if (bSV[j][i] > 0)
  634.             {
  635.                 EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[j][i], 0);
  636.                 dst += t->edged_stride;
  637.                 EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[j][i], 0);
  638.                 dst += t->edged_stride;
  639.                 EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[j][i], 0);
  640.                 dst += t->edged_stride;
  641.                 EdgeLoopH(t, dst, t->edged_stride, indexA, alpha, beta, bSV[j][i], 0);
  642.                 dst += t->edged_stride;
  643.             }
  644.             else
  645.             {
  646.                 dst += 4 * t->edged_stride;
  647.             }
  648.         }
  649.     }
  651.     // mb edge
  652.     if (y != 0)
  653.     {
  654.         prev = &f->mb[mb_xy - t->mb_stride];
  655.         get_strength(t, bSH[0], 1, 0, cur, prev);
  657.         dst = dst_y;
  658.         for(i = 0 ; i < 4 ; i ++)
  659.         {
  660.             if (bSH[0][i] > 0)
  661.             {
  662.                 EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[0][i], 0);
  663.                 dst ++;
  664.                 EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[0][i], 0);
  665.                 dst ++;
  666.                 EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[0][i], 0);
  667.                 dst ++;
  668.                 EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[0][i], 0);
  669.                 dst ++;
  670.             }
  671.             else
  672.             {
  673.                 dst += 4;
  674.             }
  675.         }
  676.     }
  677.     for(j = 1 ; j < 4 ; j ++)
  678.     {
  679.         prev = cur;
  680.         get_strength(t, bSH[j], 1, j, cur, prev);
  682.         dst = dst_y + 4 * j * t->edged_stride;
  683.         for(i = 0 ; i < 4 ; i ++)
  684.         {
  685.             if (bSH[j][i] > 0)
  686.             {
  687.                 EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[j][i], 0);
  688.                 dst ++;
  689.                 EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[j][i], 0);
  690.                 dst ++;
  691.                 EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[j][i], 0);
  692.                 dst ++;
  693.                 EdgeLoopV(t, dst, t->edged_stride, indexA, alpha, beta, bSH[j][i], 0);
  694.                 dst ++;
  695.             }
  696.             else
  697.             {
  698.                 dst += 4;
  699.             }
  700.         }
  701.     }
  703.     deblock_mb_chroma(t, x, y, dst_u, bSV, bSH, indexAc, alphac, betac);
  704.     deblock_mb_chroma(t, x, y, dst_v, bSV, bSH, indexAc, alphac, betac);
  705. }
  707. void
  708. T264_deblock_frame(T264_t* t, T264_frame_t* f)
  709. {
  710.     int32_t i, j;
  711.     
  712.     for (i = 0 ; i < t->mb_height ; i ++)
  713.     {
  714.         for (j = 0 ; j < t->mb_width ; j ++)
  715.         {
  716.             deblock_mb(t, i, j, f);
  717.         }
  718.     }
  719. }