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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
weighted_prediction.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：27k
源码类别：

Audio

开发平台：

Visual C++

weighted_prediction.c：源码内容
  2. /*!
  3. *************************************************************************************
  4. * file weighted_prediction.c
  5. *
  6. * brief
  7. *    Estimate weights for WP using DC method
  8. *
  9. * author
  10. *    Main contributors (see contributors.h for copyright, address and affiliation details)
  11. *     - Alexis Michael Tourapis         <alexismt@ieee.org>
  12. *     - Athanasios Leontaris            <aleon@dolby.com>
  13. *************************************************************************************
  14. */
  15. #include "contributors.h"
  17. #include "global.h"
  18. #include "image.h"
  19. #include "wp.h"
  21. /*!
  22. ************************************************************************
  23. * brief
  24. *    Initialize weighting parameter functions
  25. ************************************************************************
  26. */
  27. void InitWP(InputParameters *params)
  28. {
  29.   switch ( params->WPMethod )
  30.   {
  31.   default:
  32.   case 0:
  33.     EstimateWPPSlice = EstimateWPPSliceAlg0;
  34.     EstimateWPBSlice = EstimateWPBSliceAlg0;
  35.     TestWPPSlice = TestWPPSliceAlg0;
  36.     TestWPBSlice = TestWPBSliceAlg0;
  37.     break;
  38.   case 1:
  39.     EstimateWPPSlice = EstimateWPPSliceAlg1;
  40.     EstimateWPBSlice = EstimateWPBSliceAlg1;
  41.     TestWPPSlice = TestWPPSliceAlg1;
  42.     TestWPBSlice = TestWPBSliceAlg1;
  43.     break;
  44.   }
  45. }
  47. /*!
  48. ************************************************************************
  49. * brief
  50. *    Compute sum of samples in a picture
  51. ************************************************************************
  52. */
  53. double ComputeImgSum(imgpel **CurrentImage, int height, int width)
  54. {
  55.   int i, j;
  56.   double sum_value = 0.0;
  58.   for (i = 0; i < height; i++)
  59.   {
  60.     for (j = 0; j < width; j++)
  61.     {
  62.       sum_value += (double) CurrentImage[i][j];
  63.     }
  64.   }
  65.   return sum_value;
  66. }
  68. /*!
  69. ************************************************************************
  70. * brief
  71. *    Estimates reference picture weighting factors for P slices
  72. ************************************************************************
  73. */
  75. void EstimateWPPSliceAlg0(ImageParameters *img, InputParameters *params, int select_offset)
  76. {
  77.   double dc_org = 0.0;
  78.   double dc_org_UV[2] = {0.0};
  79.   double dc_ref[MAX_REFERENCE_PICTURES] = { 0.0 };
  80.   double dc_ref_UV[MAX_REFERENCE_PICTURES][2] = { {0.0}};
  82.   int i, n, k;
  83.   int default_weight[3];
  84.   int list_offset   = ((img->MbaffFrameFlag)&&(img->mb_data[img->current_mb_nr].mb_field))? (img->current_mb_nr & 0x01) ? 4 : 2 : 0;
  85.   int weight[2][MAX_REFERENCE_PICTURES][3];
  86.   int offset[2][MAX_REFERENCE_PICTURES][3];
  87.   int clist;
  89.   imgpel **tmpPtr;
  91.   luma_log_weight_denom   = 5;
  92.   chroma_log_weight_denom = 5;
  94.   wp_luma_round           = 1 << (luma_log_weight_denom - 1);
  95.   wp_chroma_round         = 1 << (chroma_log_weight_denom - 1);
  96.   default_weight[0]       = 1 << luma_log_weight_denom;
  97.   default_weight[1]       = default_weight[2] = 1 << chroma_log_weight_denom;
  98.   
  99.   dc_org = ComputeImgSum(pCurImg, img->height, img->width);
  101.   if (params->ChromaWeightSupport == 1)
  102.   {
  103.     for (k = 0; k < 2; k++)
  104.     {
  105.       dc_org_UV[k] = ComputeImgSum(pImgOrg[k + 1], img->height_cr, img->width_cr);
  106.     } 
  107.   }
  109.   for (clist = 0; clist < 2 + list_offset; clist++)
  110.   {
  111.     for (n = 0; n < listXsize[clist]; n++)
  112.     {
  113.       if ( wpxDetermineWP( params, img, clist, n ) )
  114.       {
  115.         /* set all values to defaults */
  116.         for (i = 0; i < 3; i++)
  117.         {
  118.           weight[clist][n][i]    = default_weight[i];
  119.           wp_weight[clist][n][i] = default_weight[i];
  120.           wp_offset[clist][n][i] = 0;
  121.           offset[clist][n][i]    = 0;
  122.         }
  124.         // Y
  125.         tmpPtr = listX[clist][n]->p_curr_img;      
  126.         dc_ref[n] = ComputeImgSum(tmpPtr, img->height, img->width);
  128.         if (params->ChromaWeightSupport == 1)
  129.         {
  130.           for (k = 0; k < 2; k++)
  131.           {
  132.             // UV
  133.             tmpPtr = listX[clist][n]->imgUV[k];
  134.             dc_ref_UV[n][k] = ComputeImgSum(tmpPtr, img->height_cr, img->width_cr);
  135.           }        
  136.         }
  138.         if (select_offset == 0)
  139.         {
  140.           if (dc_ref[n] != 0.0)
  141.             weight[clist][n][0] = (int) (default_weight[0] * dc_org / dc_ref[n] + 0.5);
  142.           else
  143.             weight[clist][n][0] = default_weight[0];  // only used when reference picture is black
  144.           weight[clist][n][0] = iClip3(-128, 127, weight[clist][n][0]);
  145.           if (params->ChromaWeightSupport == 1)
  146.           {
  147.             if (dc_ref_UV[n][0] != 0)
  148.               weight[clist][n][1] = (int) (default_weight[1] * dc_org_UV[0] / dc_ref_UV[n][0] + 0.5);
  149.             else
  150.               weight[clist][n][1] = default_weight[1];  // only used when reference picture is black
  151.             weight[clist][n][1] = iClip3(-128, 127, weight[clist][n][1]);
  153.             if (dc_ref_UV[n][1] != 0)
  154.               weight[clist][n][2] = (int) (default_weight[2] * dc_org_UV[1] / dc_ref_UV[n][1] + 0.5);
  155.             else
  156.               weight[clist][n][2] = default_weight[2];  // only used when reference picture is black
  157.             weight[clist][n][2] = iClip3(-64, 128, weight[clist][n][2]);
  158.           }
  159.         }
  160.         else
  161.         {
  162.           offset[clist][n][0] = (int) ((dc_org - dc_ref[n])/(img->size)+0.5);
  163.           offset[clist][n][0] = (offset[clist][n][0]+((img->bitdepth_luma-8)>>1))>>(img->bitdepth_luma-8);
  164.           offset[clist][n][0] = iClip3( -128, 127, offset[clist][n][0]);
  165.           offset[clist][n][0] = offset[clist][n][0]<<(img->bitdepth_luma-8);
  166.           weight[clist][n][0] = default_weight[0];
  168.           if (params->ChromaWeightSupport == 1)
  169.           {
  170.             offset[clist][n][1] = (int) ((dc_org_UV[0] - dc_ref_UV[n][0])/(img->size_cr)+0.5);
  171.             offset[clist][n][1] = (offset[clist][n][1] + ((img->bitdepth_chroma - 8)>>1))>>(img->bitdepth_chroma-8);
  172.             offset[clist][n][1] = iClip3( -128, 127, offset[clist][n][1]);
  173.             offset[clist][n][1] = offset[clist][n][1]<<(img->bitdepth_chroma - 8);
  174.             
  175.             weight[clist][n][1] = default_weight[1];
  177.             offset[clist][n][2] = (int) ((dc_org_UV[1] - dc_ref_UV[n][1])/(img->size_cr)+0.5);
  178.             offset[clist][n][2] = (offset[clist][n][2] + ((img->bitdepth_chroma - 8)>>1))>>(img->bitdepth_chroma-8);
  179.             offset[clist][n][2] = iClip3( -128, 127, offset[clist][n][2]);
  180.             offset[clist][n][2] = offset[clist][n][2]<<(img->bitdepth_chroma - 8);
  182.             weight[clist][n][2] = default_weight[2];
  183.           }
  184.         }
  186.         for (i=0; i < 3; i ++)
  187.         {
  188.           wp_weight[clist][n][i] = weight[clist][n][i];
  189.           wp_offset[clist][n][i] = offset[clist][n][i];
  190. #if DEBUG_WP
  191.           printf("index %d component %d weight %d offset %dn",n,i,weight[0][n][i],offset[0][n][i]);
  192. #endif
  193.         }
  194.       }
  195.     }
  196.   }
  197. }
  199. /*!
  200. ************************************************************************
  201. * brief
  202. *    Estimates reference picture weighting factors for B slices
  203. ************************************************************************
  204. */
  205. void EstimateWPBSliceAlg0(ImageParameters *img, InputParameters *params)
  206. {
  207.   int i, j, k, n;
  209.   int tx,DistScaleFactor;
  211.   int index;
  212.   int comp;
  213.   double dc_org = 0.0;
  214.   double dc_org_UV[2] = { 0.0 };
  215.   double dc_ref[6][MAX_REFERENCE_PICTURES] = { {0.0} };
  216.   double dc_ref_UV[6][MAX_REFERENCE_PICTURES][2] = { {{0.0}} };
  218.   int default_weight[3];
  219.   int list_offset   = ((img->MbaffFrameFlag)&&(img->mb_data[img->current_mb_nr].mb_field))? (img->current_mb_nr & 0x01) ? 4 : 2 : 0;
  220.   int weight[6][MAX_REFERENCE_PICTURES][3];
  221.   int offset[6][MAX_REFERENCE_PICTURES][3];
  222.   int im_weight[6][MAX_REFERENCE_PICTURES][MAX_REFERENCE_PICTURES][3];
  223.   int clist;
  224.   int wf_weight, wf_offset;
  225.   imgpel **tmpPtr;
  227.   if (active_pps->weighted_bipred_idc == 2) //! implicit mode. Values are fixed and it is important to show it here
  228.   {
  229.     luma_log_weight_denom = 5;
  230.     chroma_log_weight_denom = 5;
  231.   }
  232.   else                                     //! explicit mode. Values can be changed for higher precision.
  233.   {
  234.     luma_log_weight_denom = 5;
  235.     chroma_log_weight_denom = 5;
  236.   }
  238.   wp_luma_round     = 1 << (luma_log_weight_denom - 1);
  239.   wp_chroma_round   = 1 << (chroma_log_weight_denom - 1);
  240.   default_weight[0] = 1 << luma_log_weight_denom;
  241.   default_weight[1] = 1 << chroma_log_weight_denom;
  242.   default_weight[2] = 1 << chroma_log_weight_denom;
  244.   if (active_pps->weighted_bipred_idc == 2) //! implicit mode
  245.   {
  246.     for (i = 0; i < listXsize[LIST_0]; i++)
  247.     {
  248.       for (j = 0; j < listXsize[LIST_1]; j++)
  249.       {
  250.         int td, tb;
  251.         td = iClip3(-128, 127,(listX[LIST_1][j]->poc - listX[LIST_0][i]->poc));
  252.         tb = iClip3(-128, 127,(enc_picture->poc - listX[LIST_0][i]->poc));
  253.         for (comp = 0; comp < 3; comp++)
  254.         {
  255.           // implicit weights
  256.           if (td == 0)
  257.           {
  258.             im_weight[0][i][j][comp] = default_weight[comp];
  259.             im_weight[1][i][j][comp] = default_weight[comp];
  260.           }
  261.           else
  262.           {
  263.             tx = (16384 + iabs(td/2))/td;
  264.             DistScaleFactor = iClip3(-1024, 1023, (tx*tb + 32 )>>6);
  265.             im_weight[1][i][j][comp] = DistScaleFactor>>2;
  266.             if (im_weight[1][i][j][comp] < -64 || im_weight[1][i][j][comp] >128)
  267.               im_weight[1][i][j][comp] = default_weight[comp];
  268.             im_weight[0][i][j][comp] = 64 - im_weight[1][i][j][comp];
  269.           }
  270.         }
  271. #if DEBUG_WP
  272.         printf ("%d imp weight[%d][%d] = %d  , %d (%d %d %d) (%d %d) (%d %d)n",enc_picture->poc, i, j,  im_weight[0][i][j][0], im_weight[1][i][j][0],
  273.           enc_picture->poc,listX[LIST_0][i]->poc, listX[LIST_1][j]->poc,
  274.           DistScaleFactor ,tx,td,tb);
  275. #endif
  276.       }
  277.     }
  279.     for (k = 0; k < 2; k++)
  280.     {
  281.       for (i = 0; i < listXsize[LIST_0]; i++)
  282.       {
  283.         for (j = 0; j < listXsize[LIST_1]; j++)
  284.         {
  285.           for (comp = 0; comp < 3; comp++)
  286.           {
  287.             wbp_weight[k][i][j][comp] = im_weight[k][i][j][comp];
  288.           }
  289.         }
  290.       }
  291.     }
  293.     for (clist=0; clist<2 + list_offset; clist++)
  294.     {
  295.       for (index = 0; index < listXsize[clist]; index++)
  296.       {
  297.         for (comp = 0; comp < 3; comp++)
  298.         {
  299.           wp_weight[clist][index][comp] = default_weight[comp];
  300.           wp_offset[clist][index][comp] = 0;
  301.         }
  302.       }
  303.     }
  304.   }
  305.   else
  306.   {
  307.     dc_org = ComputeImgSum(pCurImg, img->height, img->width);
  309.     if (params->ChromaWeightSupport == 1)
  310.     {
  311.       for (k = 0; k < 2; k++)
  312.       {
  313.         dc_org_UV[k] = ComputeImgSum(pImgOrg[k + 1], img->height_cr, img->width_cr);
  314.       } 
  315.     }
  317.     for (clist=0; clist<2 + list_offset; clist++)
  318.     {
  319.       for (n = 0; n < listXsize[clist]; n++)
  320.       {
  321.         if ( wpxDetermineWP( params, img, clist, n ) )
  322.         {
  323.           /* set all values to defaults */
  324.           for (i = 0; i < 3; i++)
  325.           {
  326.             wp_weight[clist][n][i] = default_weight[i];
  327.             wp_offset[clist][n][i] = 0;
  328.             offset   [clist][n][i] = 0;
  329.             weight   [clist][n][i] = default_weight[i];
  330.           }
  331.           // To simplify these computations we may wish to perform these after a reference is 
  332.           // stored in the reference buffer and attach them to the storedimage structure!!!
  333.           // Y
  334.           tmpPtr = listX[clist][n]->p_curr_img;
  335.           dc_ref[clist][n] = ComputeImgSum(tmpPtr, img->height, img->width);
  337.           if (dc_ref[clist][n] != 0.0)
  338.             wf_weight = (int) (default_weight[0] * dc_org / dc_ref[clist][n] + 0.5);
  339.           else
  340.             wf_weight = default_weight[0];  // only used when reference picture is black
  341.           wf_weight = iClip3(-128, 127, wf_weight);
  342.           wf_offset = 0;
  344.           //    printf("dc_org = %d, dc_ref = %d, weight[%d] = %dn",dc_org, dc_ref[n],n,weight[n][0]);
  346.           weight[clist][n][0] = wf_weight;
  347.           offset[clist][n][0] = wf_offset;
  349.           // UV
  350.           if (params->ChromaWeightSupport == 1)
  351.           {          
  352.             for (k = 0; k < 2; k++)
  353.             {        
  354.               tmpPtr = listX[clist][n]->imgUV[k];
  355.               dc_ref_UV[clist][n][k] = ComputeImgSum(tmpPtr, img->height_cr, img->width_cr);
  357.               if (dc_ref_UV[clist][n][k] != 0.0)
  358.                 wf_weight = (int) (default_weight[k + 1] * dc_org_UV[k] / dc_ref_UV[clist][n][k] + 0.5);
  359.               else
  360.                 wf_weight = default_weight[k + 1];  // only used when reference picture is black
  361.               wf_weight = iClip3(-128, 127, wf_weight);
  362.               wf_offset = 0;
  364.               weight[clist][n][k + 1] = wf_weight;
  365.               offset[clist][n][k + 1] = wf_offset;
  366.             }
  367.           }
  368.           else
  369.           {
  370.             weight[clist][n][1] = default_weight[1];
  371.             weight[clist][n][2] = default_weight[2];        
  372.             offset[clist][n][1] = 0;
  373.             offset[clist][n][2] = 0;
  374.           }
  376.           for (i = 0; i < 3; i++)
  377.           {
  378.             wp_weight[clist][n][i] = weight[clist][n][i];
  379.             wp_offset[clist][n][i] = offset[clist][n][i];
  380. #if DEBUG_WP
  381.             printf("%d %dn",wp_weight[clist][index][comp],wp_offset[clist][index][comp]);
  382. #endif
  383.           }
  384.         }
  385.       }
  386.     }
  388.     if (active_pps->weighted_bipred_idc != 1)
  389.     {
  390.       for (clist=0; clist<2 + list_offset; clist++)
  391.       {
  392.         for (index = 0; index < listXsize[clist]; index++)
  393.         {
  394.           memcpy(wp_weight[clist][index], default_weight, 3 * sizeof(int));
  395.           memset(wp_offset[clist][index], 0, 3 * sizeof(int));
  396.         }
  397.       }
  398.     }
  401.     for (i = 0; i < listXsize[LIST_0]; i++)
  402.     {
  403.       for (j = 0; j < listXsize[LIST_1]; j++)
  404.       {
  405.         for (comp = 0; comp < 3; comp++)
  406.         {
  407.           wbp_weight[0][i][j][comp] = wp_weight[0][i][comp];
  408.           wbp_weight[1][i][j][comp] = wp_weight[1][j][comp];
  409.         }
  410. #if DEBUG_WP
  411.         printf ("bpw weight[%d][%d] = %d  , %d (%d %d %d) (%d %d) (%d %d)n", i, j, wbp_weight[0][i][j][0], wbp_weight[1][i][j][0],
  412.           enc_picture->poc,listX[LIST_0][i]->poc, listX[LIST_1][j]->poc,
  413.           DistScaleFactor ,tx,tx,tx);
  414. #endif
  415.       }
  416.     }
  417.   }
  418. }
  421. /*!
  422. ************************************************************************
  423. * brief
  424. *    Tests P slice weighting factors to perform or not WP RD decision
  425. ************************************************************************
  426. */
  428. int TestWPPSliceAlg0(ImageParameters *img, InputParameters *params, int select_offset)
  429. {
  430.   int i, j, k, n;
  432.   int index;
  433.   int comp;
  434.   double dc_org = 0.0;
  435.   double dc_org_UV[2] = {0.0};  
  436.   double dc_ref[MAX_REFERENCE_PICTURES] = { 0.0 };
  437.   double dc_ref_UV[MAX_REFERENCE_PICTURES][2] = { {0.0}};
  439.   int default_weight[3];
  441.   int list_offset   = ((img->MbaffFrameFlag)&&(img->mb_data[img->current_mb_nr].mb_field))? (img->current_mb_nr & 0x01) ? 4 : 2 : 0;
  442.   int weight[2][MAX_REFERENCE_PICTURES][3];
  443.   int offset[2][MAX_REFERENCE_PICTURES][3];
  444.   int clist;
  445.   int perform_wp = 0;
  446.   imgpel **tmpPtr;
  448.   luma_log_weight_denom = 5;
  449.   chroma_log_weight_denom = 5;
  450.   wp_luma_round = 1 << (luma_log_weight_denom - 1);
  451.   wp_chroma_round = 1 << (chroma_log_weight_denom - 1);
  452.   default_weight[0] = 1 << luma_log_weight_denom;
  453.   default_weight[1] = default_weight[2] = 1 << chroma_log_weight_denom;
  455.   /* set all values to defaults */
  456.   for (i = 0; i < 2 + list_offset; i++)
  457.   {
  458.     for (j = 0; j < listXsize[i]; j++)
  459.     {
  460.       for (n = 0; n < 3; n++)
  461.       {
  462.         weight[i][j][n] = default_weight[n];
  463.         wp_weight[i][j][n] = default_weight[n];
  464.         wp_offset[i][j][n] = 0;
  465.         offset[i][j][n] = 0;
  466.       }
  467.     }
  468.   }
  470.   dc_org = ComputeImgSum(pCurImg, img->height, img->width);
  472.   if (params->ChromaWeightSupport == 1)
  473.   {
  474.     for (k = 0; k < 2; k++)
  475.     {
  476.       dc_org_UV[k] = ComputeImgSum(pImgOrg[k + 1], img->height_cr, img->width_cr);
  477.     } 
  478.   }
  480.   for (clist = 0; clist < 2 + list_offset; clist++)
  481.   {
  482.     for (n = 0; n < listXsize[clist]; n++)
  483.     {
  484.       tmpPtr = listX[clist][n]->p_curr_img;
  485.       dc_ref[n] = ComputeImgSum(tmpPtr, img->height, img->width);
  487.       if (params->ChromaWeightSupport == 1)
  488.       {
  489.         for (k = 0; k < 2; k++)
  490.         {
  491.           tmpPtr = listX[clist][n]->imgUV[k];
  492.           dc_ref_UV[n][k] = ComputeImgSum(tmpPtr, img->height_cr, img->width_cr);
  493.         }        
  494.       }
  496.       if (select_offset == 0)
  497.       {
  498.         if (dc_ref[n] != 0.0)
  499.           weight[clist][n][0] = (int) (default_weight[0] * dc_org / dc_ref[n] + 0.5);
  500.         else
  501.           weight[clist][n][0] = default_weight[0];  // only used when reference picture is black
  502.         weight[clist][n][0] = iClip3(-128, 127, weight[clist][n][0]);
  503.         if (params->ChromaWeightSupport == 1)
  504.         {
  505.           if (dc_ref_UV[n][0] != 0)
  506.             weight[clist][n][1] = (int) (default_weight[1] * dc_org_UV[0] / dc_ref_UV[n][0] + 0.5);
  507.           else
  508.             weight[clist][n][1] = default_weight[1];  // only used when reference picture is black
  509.           weight[clist][n][1] = iClip3(-128, 127, weight[clist][n][1]);
  511.           if (dc_ref_UV[n][1] != 0)
  512.             weight[clist][n][2] = (int) (default_weight[2] * dc_org_UV[1] / dc_ref_UV[n][1] + 0.5);
  513.           else
  514.             weight[clist][n][2] = default_weight[2];  // only used when reference picture is black
  515.           weight[clist][n][2] = iClip3(-64, 128, weight[clist][n][2]);
  516.         }
  517.       }
  518.       else
  519.       {
  520.         offset[clist][n][0] = (int) ((dc_org - dc_ref[n])/(img->size)+0.5);
  521.         offset[clist][n][0] = (offset[clist][n][0]+((img->bitdepth_luma-8)>>1))>>(img->bitdepth_luma-8);
  522.         offset[clist][n][0] = iClip3( -128, 127, offset[clist][n][0]);
  523.         offset[clist][n][0] = offset[clist][n][0]<<(img->bitdepth_luma-8);
  524.         weight[clist][n][0] = default_weight[0];
  526.         if (params->ChromaWeightSupport == 1)
  527.         {
  528.             offset[clist][n][1] = (int) ((dc_org_UV[0] - dc_ref_UV[n][0])/(img->size_cr)+0.5);
  529.             offset[clist][n][1] = (offset[clist][n][1] + ((img->bitdepth_chroma - 8)>>1))>>(img->bitdepth_chroma-8);
  530.             offset[clist][n][1] = iClip3( -128, 127, offset[clist][n][1]);
  531.             offset[clist][n][1] = offset[clist][n][1]<<(img->bitdepth_chroma - 8);
  532.             
  533.             weight[clist][n][1] = default_weight[1];
  535.             offset[clist][n][2] = (int) ((dc_org_UV[1] - dc_ref_UV[n][1])/(img->size_cr)+0.5);
  536.             offset[clist][n][2] = (offset[clist][n][2] + ((img->bitdepth_chroma - 8)>>1))>>(img->bitdepth_chroma-8);
  537.             offset[clist][n][2] = iClip3( -128, 127, offset[clist][n][2]);
  538.             offset[clist][n][2] = offset[clist][n][2]<<(img->bitdepth_chroma - 8);
  540.             weight[clist][n][2] = default_weight[2];
  541.         }
  542.       }
  543.     }
  544.   }
  546.   for (clist=0; clist<2 + list_offset; clist++)
  547.   {
  548.     for (index = 0; index < listXsize[clist]; index++)
  549.     {
  550.       for (comp=0; comp < 3; comp ++)
  551.       {
  552.         int offset_test = params->RDPSliceBTest && active_sps->profile_idc != 66
  553.           ? iabs(offset[clist][index][comp]) > 2
  554.           : offset[clist][index][comp] != 0;
  556.         if (weight[clist][index][comp] != default_weight[0] || offset_test)
  557.         {
  558.           perform_wp = 1;
  559.           break;
  560.         }
  561.       }
  562.       if (perform_wp == 1) break;
  563.     }
  564.     if (perform_wp == 1) break;
  565.   }
  567.   return perform_wp;
  568. }
  570. /*!
  571. ************************************************************************
  572. * brief
  573. *    TestWPBSliceAlg0:
  574. *    Tests B slice weighting prediction
  575. ************************************************************************
  576. */
  577. int TestWPBSliceAlg0(ImageParameters *img, InputParameters *params, int select_method)
  578. {
  579.   int i, j, k, n;
  581.   int tx,DistScaleFactor;
  583.   int index;
  584.   int comp;
  585.   double dc_org = 0.0;
  586.   double dc_org_UV[2] = { 0.0 };    
  587.   double dc_ref[6][MAX_REFERENCE_PICTURES] = { {0.0} };  
  588.   double dc_ref_UV[6][MAX_REFERENCE_PICTURES][2] = { {{0.0}} };
  590.   int default_weight[3];
  591.   // this needs to be fixed.
  592.   int list_offset   = ((img->MbaffFrameFlag)&&(img->mb_data[img->current_mb_nr].mb_field))? (img->current_mb_nr & 0x01) ? 4 : 2 : 0;
  593.   int weight[6][MAX_REFERENCE_PICTURES][3];
  594.   int offset[6][MAX_REFERENCE_PICTURES][3];
  595.   int im_weight[6][MAX_REFERENCE_PICTURES][MAX_REFERENCE_PICTURES][3];
  596.   int clist;
  597.   int wf_weight, wf_offset;
  598.   int perform_wp = 0;
  599.   imgpel **tmpPtr;
  601.   if (select_method == 1) //! implicit mode
  602.   {
  603.     luma_log_weight_denom = 5;
  604.     chroma_log_weight_denom = 5;
  605.   }
  606.   else
  607.   {
  608.     luma_log_weight_denom = 5;
  609.     chroma_log_weight_denom = 5;
  610.   }
  612.   wp_luma_round     = 1 << (luma_log_weight_denom - 1);
  613.   wp_chroma_round   = 1 << (chroma_log_weight_denom - 1);
  614.   default_weight[0] = 1 << luma_log_weight_denom;
  615.   default_weight[1] = 1 << chroma_log_weight_denom;
  616.   default_weight[2] = 1 << chroma_log_weight_denom;
  618.   /* set all values to defaults */
  619.   for (i = 0; i < 2 + list_offset; i++)
  620.   {
  621.     for (j = 0; j < listXsize[i]; j++)
  622.     {
  623.       for (n = 0; n < 3; n++)
  624.       {
  625.         wp_weight[i][j][n] = default_weight[n];
  626.         wp_offset[i][j][n] = 0;
  627.         offset   [i][j][n] = 0;
  628.         weight   [i][j][n] = default_weight[n];
  629.       }
  630.     }
  631.   }
  633.   for (i = 0; i < listXsize[LIST_0]; i++)
  634.   {
  635.     for (j = 0; j < listXsize[LIST_1]; j++)
  636.     {
  637.       int td, tb;
  638.       td = iClip3(-128, 127,(listX[LIST_1][j]->poc - listX[LIST_0][i]->poc));
  639.       tb = iClip3(-128, 127,(enc_picture->poc - listX[LIST_0][i]->poc));
  640.       for (comp = 0; comp < 3; comp++)
  641.       {
  642.         // implicit weights
  643.         if (td == 0)
  644.         {
  645.           im_weight[0][i][j][comp] = default_weight[comp];
  646.           im_weight[1][i][j][comp] = default_weight[comp];
  647.         }
  648.         else
  649.         {
  650.           tx = (16384 + iabs(td/2))/td;
  651.           DistScaleFactor = iClip3(-1024, 1023, (tx*tb + 32 )>>6);
  652.           im_weight[1][i][j][comp] = DistScaleFactor >> 2;
  653.           if (im_weight[1][i][j][comp] < -64 || im_weight[1][i][j][comp] >128)
  654.             im_weight[1][i][j][comp] = default_weight[comp];
  655.           im_weight[0][i][j][comp] = 64 - im_weight[1][i][j][comp];
  656.         }
  657.       }
  658.     }
  659.   }
  662.   if (select_method == 1) //! implicit mode
  663.   {
  664.     for (i = 0; i < listXsize[LIST_0]; i++)
  665.     {
  666.       for (j = 0; j < listXsize[LIST_1]; j++)
  667.       {
  668.         for (comp = 0; comp < 3; comp++)
  669.         {
  670.           wbp_weight[1][i][j][comp] = im_weight[1][i][j][comp] ;
  671.           wbp_weight[0][i][j][comp] = im_weight[0][i][j][comp];
  672.         }
  673.       }
  674.     }
  676.     for (clist=0; clist<2 + list_offset; clist++)
  677.     {
  678.       for (index = 0; index < listXsize[clist]; index++)
  679.       {
  680.         for (comp = 0; comp < 3; comp++)
  681.         {
  682.           wp_weight[clist][index][comp] = default_weight[comp];
  683.           wp_offset[clist][index][comp] = 0;
  684.         }
  685.       }
  686.     }
  687.   }
  688.   else
  689.   {
  690.     dc_org = ComputeImgSum(pCurImg, img->height, img->width);
  692.     if (params->ChromaWeightSupport == 1)
  693.     {
  694.       for (k = 0; k < 2; k++)
  695.       {
  696.         dc_org_UV[k] = ComputeImgSum(pImgOrg[k + 1], img->height_cr, img->width_cr);
  697.       } 
  698.     }
  700.     for (clist=0; clist<2 + list_offset; clist++)
  701.     {
  702.       for (n = 0; n < listXsize[clist]; n++)
  703.       {
  704.         // To simplify these computations we may wish to perform these after a reference is 
  705.         // stored in the reference buffer and attach them to the storedimage structure!!!
  706.         // Y
  707.         tmpPtr = listX[clist][n]->p_curr_img;
  708.         dc_ref[clist][n] = ComputeImgSum(tmpPtr, img->height, img->width);
  710.         if (dc_ref[clist][n] != 0.0)
  711.           wf_weight = (int) (default_weight[0] * dc_org / dc_ref[clist][n] + 0.5);
  712.         else
  713.           wf_weight = default_weight[0];  // only used when reference picture is black
  714.         wf_weight = iClip3(-128, 127, wf_weight);
  715.         wf_offset = 0;
  717.         weight[clist][n][0] = wf_weight;
  718.         offset[clist][n][0] = wf_offset;
  720.         // UV
  721.         if (params->ChromaWeightSupport == 1)
  722.         {          
  723.           for (k = 0; k < 2; k++)
  724.           {
  725.             tmpPtr = listX[clist][n]->imgUV[k];
  726.             dc_ref_UV[clist][n][k] = ComputeImgSum(tmpPtr, img->height_cr, img->width_cr);
  728.             if (dc_ref_UV[clist][n][k] != 0.0)
  729.               wf_weight = (int) (default_weight[k + 1] * dc_org_UV[k] / dc_ref_UV[clist][n][k] + 0.5);
  730.             else
  731.               wf_weight = default_weight[k + 1];  // only used when reference picture is black
  732.             wf_weight = iClip3(-128, 127, wf_weight);
  733.             wf_offset = 0;
  735.             weight[clist][n][k + 1] = wf_weight;
  736.             offset[clist][n][k + 1] = wf_offset;
  737.           }
  738.         }
  739.         else
  740.         {
  741.           weight[clist][n][1] = default_weight[1];
  742.           weight[clist][n][2] = default_weight[2];        
  743.           offset[clist][n][1] = 0;
  744.           offset[clist][n][2] = 0;
  745.         }
  746.       }
  747.     }
  749.     if (select_method == 0) //! explicit mode
  750.     {
  751.       for (clist=0; clist<2 + list_offset; clist++)
  752.       {
  753.         for (index = 0; index < listXsize[clist]; index++)
  754.         {
  755.           memcpy(wp_weight[clist][index], weight[clist][index], 3 * sizeof(int));
  756.           memcpy(wp_offset[clist][index], offset[clist][index], 3 * sizeof(int));
  757.         }
  758.       }
  759.     }
  760.     else
  761.     {
  762.       for (clist=0; clist<2 + list_offset; clist++)
  763.       {
  764.         for (index = 0; index < listXsize[clist]; index++)
  765.         {
  766.           memcpy(wp_weight[clist][index], default_weight, 3 * sizeof(int));
  767.           memset(wp_offset[clist][index], 0, 3 * sizeof(int));
  768.         }
  769.       }
  770.     }
  772.     for (i = 0; i < listXsize[LIST_0]; i++)
  773.     {
  774.       for (j = 0; j < listXsize[LIST_1]; j++)
  775.       {
  776.         for (comp = 0; comp < 3; comp++)
  777.         {
  778.           wbp_weight[0][i][j][comp] = wp_weight[0][i][comp];
  779.           wbp_weight[1][i][j][comp] = wp_weight[1][j][comp];
  780.         }
  781. #if DEBUG_WP
  782.         printf ("bpw weight[%d][%d] = %d  , %d (%d %d %d) (%d %d) (%d %d)n", i, j, wbp_weight[0][i][j][0], wbp_weight[1][i][j][0],
  783.         enc_picture->poc,listX[LIST_0][i]->poc, listX[LIST_1][j]->poc,
  784.         DistScaleFactor ,tx,tx,tx);
  785. #endif
  786.       }
  787.     }
  788.   }
  790.   if (select_method == 0) //! implicit mode
  791.   {
  792.     int active_refs[2];
  794.     active_refs[0] = (params->B_List0_refs == 0 ? listXsize[0] : imin(params->B_List0_refs, listXsize[0]));
  795.     active_refs[1] = (params->B_List1_refs == 0 ? listXsize[1] : imin(params->B_List1_refs, listXsize[1]));
  797.     for (clist=0; clist<2 + list_offset; clist++)
  798.     {
  799.       for (index = 0; index < active_refs[clist]; index++)
  800.       {
  801.         for (comp=0; comp < 3; comp ++)
  802.         {
  803.           if (wp_weight[clist][index][comp] != default_weight[comp])
  804.           {
  805.             perform_wp = 1;
  806.             break;
  807.           }
  808.         }
  809.         if (perform_wp == 1) break;
  810.       }
  811.       if (perform_wp == 1) break;
  812.     }
  813.   }
  814.   return perform_wp;
  815. }