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

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

Audio

开发平台：

Visual C++

wp_lms.c：源码内容
  2. /*!
  3. *************************************************************************************
  4. * file wp_lms.c
  5. *
  6. * brief
  7. *    Estimate weights for WP using LMS 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. static inline double ComputeNormMean(imgpel **CurrentImage, double mean_value, int height, int width)
  22. {
  23.   int i, j;
  24.   double sum_value = 0.0;
  26.   for (i = 0; i < height; i++)
  27.   {
  28.     for (j = 0; j < width; j++)
  29.     {
  30.       sum_value += dabs((double) CurrentImage[i][j] - mean_value);
  31.     }
  32.   }
  33.   return sum_value;
  34. }
  36. /*!
  37. ************************************************************************
  38. * brief
  39. *    Estimates reference picture weighting factors for P slices
  40. ************************************************************************
  41. */
  43. void EstimateWPPSliceAlg1(ImageParameters *img, InputParameters *params, int select_offset)
  44. {
  45.   double dc_org = 0.0;
  46.   double dc_org_UV[2] = {0.0};
  47.   double dc_ref[MAX_REFERENCE_PICTURES] = { 0.0 };
  48.   double dc_ref_UV[MAX_REFERENCE_PICTURES][2] = { {0.0}};
  49.   double norm_org = 0.0;
  50.   double norm_ref[MAX_REFERENCE_PICTURES] = { 0.0 };
  51.   double numer = {0.0};
  52.   double denom[MAX_REFERENCE_PICTURES] = {0.0};  
  54.   int i, n, k;
  55.   int default_weight[3];
  56.   int list_offset   = ((img->MbaffFrameFlag)&&(img->mb_data[img->current_mb_nr].mb_field))? (img->current_mb_nr & 0x01) ? 4 : 2 : 0;
  57.   int weight[2][MAX_REFERENCE_PICTURES][3];
  58.   int offset[2][MAX_REFERENCE_PICTURES][3];
  59.   int clist;
  61.   imgpel **tmpPtr;
  63.   luma_log_weight_denom   = 5;
  64.   chroma_log_weight_denom = 5;
  66.   wp_luma_round           = 1 << (luma_log_weight_denom - 1);
  67.   wp_chroma_round         = 1 << (chroma_log_weight_denom - 1);
  68.   default_weight[0]       = 1 << luma_log_weight_denom;
  69.   default_weight[1]       = default_weight[2] = 1 << chroma_log_weight_denom;
  70.   
  71.   dc_org = ComputeImgSum(pCurImg, img->height, img->width);
  73.   norm_org = dc_org / ((double) img->size);
  74.   numer = ComputeNormMean(pCurImg, norm_org, img->height, img->width);
  76.   if (params->ChromaWeightSupport == 1)
  77.   {
  78.     for (k = 0; k < 2; k++)
  79.     {
  80.       dc_org_UV[k] = ComputeImgSum(pImgOrg[k + 1], img->height_cr, img->width_cr);
  81.     } 
  82.   }
  84.   for (clist = 0; clist < 2 + list_offset; clist++)
  85.   {
  86.     for (n = 0; n < listXsize[clist]; n++)
  87.     {
  88.       if ( wpxDetermineWP( params, img, clist, n ) )
  89.       {
  90.         /* set all values to defaults */
  91.         for (i = 0; i < 3; i++)
  92.         {
  93.           weight[clist][n][i]    = default_weight[i];
  94.           wp_weight[clist][n][i] = default_weight[i];
  95.           wp_offset[clist][n][i] = 0;
  96.           offset[clist][n][i]    = 0;
  97.         }
  99.         // Y
  100.         tmpPtr = listX[clist][n]->p_curr_img;      
  101.         dc_ref[n] = ComputeImgSum(tmpPtr, img->height, img->width);
  103.         norm_ref[n] = dc_ref[n] / ((double) img->size);
  104.         denom[n] = ComputeNormMean(tmpPtr, norm_ref[n], img->height, img->width);
  106.         if (params->ChromaWeightSupport == 1)
  107.         {
  108.           for (k = 0; k < 2; k++)
  109.           {
  110.             // UV
  111.             tmpPtr = listX[clist][n]->imgUV[k];
  112.             dc_ref_UV[n][k] = ComputeImgSum(tmpPtr, img->height_cr, img->width_cr);
  113.           }        
  114.         }
  116.         if (select_offset == 0)
  117.         {
  118.           if (denom[n] != 0)
  119.             weight[clist][n][0] = (int) (default_weight[0] * numer / denom[n] + 0.5);
  120.           else
  121.             weight[clist][n][0] = default_weight[0];  // only used when reference picture is black
  122.           weight[clist][n][0] = iClip3(-128, 127, weight[clist][n][0]);
  124.           offset[clist][n][0] = (int) (norm_org - ((double) weight[clist][n][0] * norm_ref[n] / (double) default_weight[0]) + 0.5);
  125.           offset[clist][n][0] = (offset[clist][n][0]+((img->bitdepth_luma-8)>>1))>>(img->bitdepth_luma-8);
  126.           offset[clist][n][0] = iClip3( -128, 127, offset[clist][n][0]);
  127.           offset[clist][n][0] = offset[clist][n][0]<<(img->bitdepth_luma-8);
  129.           if (params->ChromaWeightSupport == 1)
  130.           {
  131.             if (dc_ref_UV[n][0] != 0)
  132.               weight[clist][n][1] = (int) (default_weight[1] * dc_org_UV[0] / dc_ref_UV[n][0] + 0.5);
  133.             else
  134.               weight[clist][n][1] = default_weight[1];  // only used when reference picture is black
  135.             weight[clist][n][1] = iClip3(-128, 127, weight[clist][n][1]);
  137.             if (dc_ref_UV[n][1] != 0)
  138.               weight[clist][n][2] = (int) (default_weight[2] * dc_org_UV[1] / dc_ref_UV[n][1] + 0.5);
  139.             else
  140.               weight[clist][n][2] = default_weight[2];  // only used when reference picture is black
  141.             weight[clist][n][2] = iClip3(-64, 128, weight[clist][n][2]);
  142.           }
  143.         }
  144.         else
  145.         {
  146.           offset[clist][n][0] = (int) ((dc_org - dc_ref[n])/(img->size)+0.5);
  147.           offset[clist][n][0] = (offset[clist][n][0]+((img->bitdepth_luma-8)>>1))>>(img->bitdepth_luma-8);
  148.           offset[clist][n][0] = iClip3( -128, 127, offset[clist][n][0]);
  149.           offset[clist][n][0] = offset[clist][n][0]<<(img->bitdepth_luma-8);
  150.           weight[clist][n][0] = default_weight[0];
  152.           if (params->ChromaWeightSupport == 1)
  153.           {
  154.             offset[clist][n][1] = (int) ((dc_org_UV[0] - dc_ref_UV[n][0])/(img->size_cr)+0.5);
  155.             offset[clist][n][1] = (offset[clist][n][1] + ((img->bitdepth_chroma - 8)>>1))>>(img->bitdepth_chroma-8);
  156.             offset[clist][n][1] = iClip3( -128, 127, offset[clist][n][1]);
  157.             offset[clist][n][1] = offset[clist][n][1]<<(img->bitdepth_chroma - 8);
  158.             
  159.             weight[clist][n][1] = default_weight[1];
  161.             offset[clist][n][2] = (int) ((dc_org_UV[1] - dc_ref_UV[n][1])/(img->size_cr)+0.5);
  162.             offset[clist][n][2] = (offset[clist][n][2] + ((img->bitdepth_chroma - 8)>>1))>>(img->bitdepth_chroma-8);
  163.             offset[clist][n][2] = iClip3( -128, 127, offset[clist][n][2]);
  164.             offset[clist][n][2] = offset[clist][n][2]<<(img->bitdepth_chroma - 8);
  166.             weight[clist][n][2] = default_weight[2];
  167.           }
  168.         }
  170.         for (i=0; i < 3; i ++)
  171.         {
  172.           wp_weight[clist][n][i] = weight[clist][n][i];
  173.           wp_offset[clist][n][i] = offset[clist][n][i];
  174. #if DEBUG_WP
  175.           printf("index %d component %d weight %d offset %dn",n,i,weight[0][n][i],offset[0][n][i]);
  176. #endif
  177.         }
  178.       }
  179.     }
  180.   }
  181. }
  183. /*!
  184. ************************************************************************
  185. * brief
  186. *    Estimates reference picture weighting factors for B slices
  187. ************************************************************************
  188. */
  189. void EstimateWPBSliceAlg1(ImageParameters *img, InputParameters *params)
  190. {
  191.   int i, j, n;
  193.   int tx,DistScaleFactor;
  195.   int index;
  196.   int comp;
  197.   double dc_org = 0.0;
  198.   double dc_org_UV[2] = { 0.0 };
  199.   double dc_ref[6][MAX_REFERENCE_PICTURES] = { {0.0} };
  200.   double dc_ref_UV[6][MAX_REFERENCE_PICTURES][2] = { {{0.0}} };
  201.   double norm_org = 0.0;
  202.   double norm_ref[MAX_REFERENCE_PICTURES] = { 0.0 };
  203.   double numer = {0.0};
  204.   double denom[MAX_REFERENCE_PICTURES] = {0.0};
  205.   int k;
  207.   int default_weight[3];
  208.   int list_offset   = ((img->MbaffFrameFlag)&&(img->mb_data[img->current_mb_nr].mb_field))? (img->current_mb_nr & 0x01) ? 4 : 2 : 0;
  209.   int weight[6][MAX_REFERENCE_PICTURES][3];
  210.   int offset[6][MAX_REFERENCE_PICTURES][3];
  211.   int im_weight[6][MAX_REFERENCE_PICTURES][MAX_REFERENCE_PICTURES][3];
  212.   int clist;
  213.   int wf_weight, wf_offset;
  214.   imgpel **tmpPtr;
  216.   if (active_pps->weighted_bipred_idc == 2) //! implicit mode. Values are fixed and it is important to show it here
  217.   {
  218.     luma_log_weight_denom = 5;
  219.     chroma_log_weight_denom = 5;
  220.   }
  221.   else                                     //! explicit mode. Values can be changed for higher precision.
  222.   {
  223.     luma_log_weight_denom = 5;
  224.     chroma_log_weight_denom = 5;
  225.   }
  227.   wp_luma_round     = 1 << (luma_log_weight_denom - 1);
  228.   wp_chroma_round   = 1 << (chroma_log_weight_denom - 1);
  229.   default_weight[0] = 1 << luma_log_weight_denom;
  230.   default_weight[1] = 1 << chroma_log_weight_denom;
  231.   default_weight[2] = 1 << chroma_log_weight_denom;
  233.   if (active_pps->weighted_bipred_idc == 2) //! implicit mode
  234.   {
  235.     for (i = 0; i < listXsize[LIST_0]; i++)
  236.     {
  237.       for (j = 0; j < listXsize[LIST_1]; j++)
  238.       {
  239.         int td, tb;
  240.         td = iClip3(-128, 127,(listX[LIST_1][j]->poc - listX[LIST_0][i]->poc));
  241.         tb = iClip3(-128, 127,(enc_picture->poc - listX[LIST_0][i]->poc));
  242.         for (comp = 0; comp < 3; comp++)
  243.         {
  244.           // implicit weights
  245.           if (td == 0)
  246.           {
  247.             im_weight[0][i][j][comp] = default_weight[comp];
  248.             im_weight[1][i][j][comp] = default_weight[comp];
  249.           }
  250.           else
  251.           {
  252.             tx = (16384 + iabs(td/2))/td;
  253.             DistScaleFactor = iClip3(-1024, 1023, (tx*tb + 32 )>>6);
  254.             im_weight[1][i][j][comp] = DistScaleFactor>>2;
  255.             if (im_weight[1][i][j][comp] < -64 || im_weight[1][i][j][comp] >128)
  256.               im_weight[1][i][j][comp] = default_weight[comp];
  257.             im_weight[0][i][j][comp] = 64 - im_weight[1][i][j][comp];
  258.           }
  259.         }
  260. #if DEBUG_WP
  261.         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],
  262.         enc_picture->poc,listX[LIST_0][i]->poc, listX[LIST_1][j]->poc,
  263.         DistScaleFactor ,tx,td,tb);
  264. #endif
  265.       }
  266.     }
  268.     for (k = 0; k < 2; k++)
  269.     {
  270.       for (i = 0; i < listXsize[LIST_0]; i++)
  271.       {
  272.         for (j = 0; j < listXsize[LIST_1]; j++)
  273.         {
  274.           for (comp = 0; comp < 3; comp++)
  275.           {
  276.             wbp_weight[k][i][j][comp] = im_weight[k][i][j][comp];
  277.           }
  278.         }
  279.       }
  280.     }
  282.     for (clist=0; clist<2 + list_offset; clist++)
  283.     {
  284.       for (index = 0; index < listXsize[clist]; index++)
  285.       {
  286.         for (comp = 0; comp < 3; comp++)
  287.         {
  288.           wp_weight[clist][index][comp] = default_weight[comp];
  289.           wp_offset[clist][index][comp] = 0;
  290.         }
  291.       }
  292.     }
  293.   }
  294.   else // explicit WP mode (or no WP at all)
  295.   {
  296.     dc_org = ComputeImgSum(pCurImg, img->height, img->width);
  298.     if (params->EnhancedBWeightSupport)
  299.     {
  300.       norm_org = dc_org / ((double) img->size);
  301.       numer = ComputeNormMean(pCurImg, norm_org, img->height, img->width);
  302.     }
  304.     if (params->ChromaWeightSupport == 1)
  305.     {
  306.       for (k = 0; k < 2; k++)
  307.       {
  308.         dc_org_UV[k] = ComputeImgSum(pImgOrg[k + 1], img->height_cr, img->width_cr);
  309.       } 
  310.     }
  312.     for (clist=0; clist<2 + list_offset; clist++)
  313.     {
  314.       for (n = 0; n < listXsize[clist]; n++)
  315.       {
  316.         if ( wpxDetermineWP( params, img, clist, n ) )
  317.         {
  318.           /* set all values to defaults */
  319.           for (i = 0; i < 3; i++)
  320.           {
  321.             wp_weight[clist][n][i] = default_weight[i];
  322.             wp_offset[clist][n][i] = 0;
  323.             offset   [clist][n][i] = 0;
  324.             weight   [clist][n][i] = default_weight[i];
  325.           }
  326.           // To simplify these computations we may wish to perform these after a reference is 
  327.           // stored in the reference buffer and attach them to the storedimage structure!!!
  328.           // Y
  329.           tmpPtr = listX[clist][n]->p_curr_img;
  330.           dc_ref[clist][n] = ComputeImgSum(tmpPtr, img->height, img->width);
  332.           if (params->EnhancedBWeightSupport)
  333.           {
  334.             norm_ref[n] = dc_ref[clist][n] / ((double) img->size);
  335.             denom[n] = ComputeNormMean(tmpPtr, norm_ref[n], img->height, img->width);
  336.           }
  337.           if (params->EnhancedBWeightSupport)
  338.           {
  339.             if (denom[n] != 0)
  340.               wf_weight = (int) (default_weight[0] * numer / denom[n] + 0.5);
  341.             else
  342.               wf_weight = default_weight[0];  // only used when reference picture is black
  343.             wf_weight = iClip3(-128, 127, wf_weight);
  345.             wf_offset = (int) (norm_org - ((double) wf_weight * norm_ref[n] / (double) default_weight[0]) + 0.5);
  346.             wf_offset = (wf_offset + ((img->bitdepth_luma - 8)>>1))>>(img->bitdepth_luma-8);
  347.             wf_offset = iClip3( -128, 127, wf_offset);
  348.             wf_offset = wf_offset <<(img->bitdepth_luma - 8);
  349.           }
  350.           else
  351.           {
  352.             if (dc_ref[clist][n] != 0.0)
  353.               wf_weight = (int) (default_weight[0] * dc_org / dc_ref[clist][n] + 0.5);
  354.             else
  355.               wf_weight = default_weight[0];  // only used when reference picture is black
  356.             wf_weight = iClip3(-128, 127, wf_weight);
  357.             wf_offset = 0;
  358.           }
  360.           //    printf("dc_org = %d, dc_ref = %d, weight[%d] = %dn",dc_org, dc_ref[n],n,weight[n][0]);
  362.           weight[clist][n][0] = wf_weight;
  363.           offset[clist][n][0] = wf_offset;
  365.           // UV
  366.           if (params->ChromaWeightSupport == 1)
  367.           {          
  368.             for (k = 0; k < 2; k++)
  369.             {        
  370.               tmpPtr = listX[clist][n]->imgUV[k];
  371.               dc_ref_UV[clist][n][k] = ComputeImgSum(tmpPtr, img->height_cr, img->width_cr);
  373.               if (dc_ref_UV[clist][n][k] != 0.0)
  374.                 wf_weight = (int) (default_weight[k + 1] * dc_org_UV[k] / dc_ref_UV[clist][n][k] + 0.5);
  375.               else
  376.                 wf_weight = default_weight[k + 1];  // only used when reference picture is black
  377.               wf_weight = iClip3(-128, 127, wf_weight);
  378.               wf_offset = 0;
  380.               weight[clist][n][k + 1] = wf_weight;
  381.               offset[clist][n][k + 1] = wf_offset;
  382.             }
  383.           }
  384.           else
  385.           {
  386.             weight[clist][n][1] = default_weight[1];
  387.             weight[clist][n][2] = default_weight[2];        
  388.             offset[clist][n][1] = 0;
  389.             offset[clist][n][2] = 0;
  390.           }
  392.           for (i = 0; i < 3; i++)
  393.           {
  394.             wp_weight[clist][n][i] = weight[clist][n][i];
  395.             wp_offset[clist][n][i] = offset[clist][n][i];
  396. #if DEBUG_WP
  397.             printf("%d %dn",wp_weight[clist][index][comp],wp_offset[clist][index][comp]);
  398. #endif
  399.           }
  400.         }
  401.       }
  402.     }
  404.     if (active_pps->weighted_bipred_idc != 1)
  405.     {
  406.       for (clist=0; clist<2 + list_offset; clist++)
  407.       {
  408.         for (index = 0; index < listXsize[clist]; index++)
  409.         {
  410.           memcpy(wp_weight[clist][index], default_weight, 3 * sizeof(int));
  411.           memset(wp_offset[clist][index], 0, 3 * sizeof(int));
  412.         }
  413.       }
  414.     }
  416.     for (i = 0; i < listXsize[LIST_0]; i++)
  417.     {
  418.       for (j = 0; j < listXsize[LIST_1]; j++)
  419.       {
  420.         for (comp = 0; comp < 3; comp++)
  421.         {
  422.           wbp_weight[0][i][j][comp] = wp_weight[0][i][comp];
  423.           wbp_weight[1][i][j][comp] = wp_weight[1][j][comp];
  424.         }
  425. #if DEBUG_WP
  426.         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],
  427.         enc_picture->poc,listX[LIST_0][i]->poc, listX[LIST_1][j]->poc,
  428.         DistScaleFactor ,tx,tx,tx);
  429. #endif
  430.       }
  431.     }
  432.   }
  433. }
  436. /*!
  437. ************************************************************************
  438. * brief
  439. *    Tests P slice weighting factors to perform or not WP RD decision
  440. ************************************************************************
  441. */
  443. int TestWPPSliceAlg1(ImageParameters *img, InputParameters *params, int select_offset)
  444. {
  445.   int i, j, k, n;
  447.   int index;
  448.   int comp;
  449.   double dc_org = 0.0;
  450.   double dc_org_UV[2] = {0.0};  
  451.   double dc_ref[MAX_REFERENCE_PICTURES] = { 0.0 };
  452.   double dc_ref_UV[MAX_REFERENCE_PICTURES][2] = { {0.0}};
  453.   double norm_org = 0.0;
  454.   double norm_ref[MAX_REFERENCE_PICTURES] = { 0.0 };
  455.   double numer = {0.0};
  456.   double denom[MAX_REFERENCE_PICTURES] = {0.0};
  458.   int default_weight[3];
  460.   int list_offset   = ((img->MbaffFrameFlag)&&(img->mb_data[img->current_mb_nr].mb_field))? (img->current_mb_nr & 0x01) ? 4 : 2 : 0;
  461.   int weight[2][MAX_REFERENCE_PICTURES][3];
  462.   int offset[2][MAX_REFERENCE_PICTURES][3];
  463.   int clist;
  464.   int perform_wp = 0;
  465.   imgpel **tmpPtr;
  467.   luma_log_weight_denom =   5;
  468.   chroma_log_weight_denom = 5;
  469.   wp_luma_round     = 1 << (luma_log_weight_denom - 1);
  470.   wp_chroma_round   = 1 << (chroma_log_weight_denom - 1);
  471.   default_weight[0] = 1 << luma_log_weight_denom;
  472.   default_weight[1] = default_weight[2] = 1 << chroma_log_weight_denom;
  474.   /* set all values to defaults */
  475.   for (i = 0; i < 2 + list_offset; i++)
  476.   {
  477.     for (j = 0; j < listXsize[i]; j++)
  478.     {
  479.       for (n = 0; n < 3; n++)
  480.       {
  481.         weight[i][j][n] = default_weight[n];
  482.         wp_weight[i][j][n] = default_weight[n];
  483.         wp_offset[i][j][n] = 0;
  484.         offset[i][j][n] = 0;
  485.       }
  486.     }
  487.   }
  489.   dc_org = ComputeImgSum(pCurImg, img->height, img->width);
  491.   norm_org = dc_org / ((double) img->size);
  492.   numer = ComputeNormMean(pCurImg, norm_org, img->height, img->width);
  494.   if (params->ChromaWeightSupport == 1)
  495.   {
  496.     for (k = 0; k < 2; k++)
  497.     {
  498.       dc_org_UV[k] = ComputeImgSum(pImgOrg[k + 1], img->height_cr, img->width_cr);
  499.     } 
  500.   }
  502.   for (clist = 0; clist < 2 + list_offset; clist++)
  503.   {
  504.     for (n = 0; n < listXsize[clist]; n++)
  505.     {
  506.       tmpPtr = listX[clist][n]->p_curr_img;
  507.       dc_ref[n] = ComputeImgSum(tmpPtr, img->height, img->width);
  509.       norm_ref[n] = dc_ref[n] / ((double) img->size);
  510.       denom[n] = ComputeNormMean(tmpPtr, norm_ref[n], img->height, img->width);
  512.       if (params->ChromaWeightSupport == 1)
  513.       {
  514.         for (k = 0; k < 2; k++)
  515.         {
  516.           tmpPtr = listX[clist][n]->imgUV[k];
  517.           dc_ref_UV[n][k] = ComputeImgSum(tmpPtr, img->height_cr, img->width_cr);
  518.         }        
  519.       }
  521.       if (select_offset == 0)
  522.       {
  523.         if (denom[n] != 0)
  524.           weight[clist][n][0] = (int) (default_weight[0] * numer / denom[n] + 0.5);
  525.         else
  526.           weight[clist][n][0] = default_weight[0];  // only used when reference picture is black
  527.         weight[clist][n][0] = iClip3(-128, 127, weight[clist][n][0]);
  529.         offset[clist][n][0] = (int) (norm_org - ((double) weight[clist][n][0] * norm_ref[n] / (double) default_weight[0]) + 0.5);
  530.         offset[clist][n][0] = (offset[clist][n][0]+((img->bitdepth_luma-8)>>1))>>(img->bitdepth_luma-8);
  531.         offset[clist][n][0] = iClip3( -128, 127, offset[clist][n][0]);
  532.         offset[clist][n][0] = offset[clist][n][0]<<(img->bitdepth_luma-8);       
  534.         if (params->ChromaWeightSupport == 1)
  535.         {
  536.           if (dc_ref_UV[n][0] != 0)
  537.             weight[clist][n][1] = (int) (default_weight[1] * dc_org_UV[0] / dc_ref_UV[n][0] + 0.5);
  538.           else
  539.             weight[clist][n][1] = default_weight[1];  // only used when reference picture is black
  540.           weight[clist][n][1] = iClip3(-128, 127, weight[clist][n][1]);
  542.           if (dc_ref_UV[n][1] != 0)
  543.             weight[clist][n][2] = (int) (default_weight[2] * dc_org_UV[1] / dc_ref_UV[n][1] + 0.5);
  544.           else
  545.             weight[clist][n][2] = default_weight[2];  // only used when reference picture is black
  546.           weight[clist][n][2] = iClip3(-64, 128, weight[clist][n][2]);
  547.         }
  548.       }
  549.       else
  550.       {
  551.         offset[clist][n][0] = (int) ((dc_org - dc_ref[n])/(img->size)+0.5);
  552.         offset[clist][n][0] = (offset[clist][n][0]+((img->bitdepth_luma-8)>>1))>>(img->bitdepth_luma-8);
  553.         offset[clist][n][0] = iClip3( -128, 127, offset[clist][n][0]);
  554.         offset[clist][n][0] = offset[clist][n][0]<<(img->bitdepth_luma-8);
  555.         weight[clist][n][0] = default_weight[0];
  557.         if (params->ChromaWeightSupport == 1)
  558.         {
  559.             offset[clist][n][1] = (int) ((dc_org_UV[0] - dc_ref_UV[n][0])/(img->size_cr)+0.5);
  560.             offset[clist][n][1] = (offset[clist][n][1] + ((img->bitdepth_chroma - 8)>>1))>>(img->bitdepth_chroma-8);
  561.             offset[clist][n][1] = iClip3( -128, 127, offset[clist][n][1]);
  562.             offset[clist][n][1] = offset[clist][n][1]<<(img->bitdepth_chroma - 8);
  563.             
  564.             weight[clist][n][1] = default_weight[1];
  566.             offset[clist][n][2] = (int) ((dc_org_UV[1] - dc_ref_UV[n][1])/(img->size_cr)+0.5);
  567.             offset[clist][n][2] = (offset[clist][n][2] + ((img->bitdepth_chroma - 8)>>1))>>(img->bitdepth_chroma-8);
  568.             offset[clist][n][2] = iClip3( -128, 127, offset[clist][n][2]);
  569.             offset[clist][n][2] = offset[clist][n][2]<<(img->bitdepth_chroma - 8);
  571.             weight[clist][n][2] = default_weight[2];
  572.         }
  573.       }
  574.     }
  575.   }
  577.   for (clist=0; clist<2 + list_offset; clist++)
  578.   {
  579.     for (index = 0; index < listXsize[clist]; index++)
  580.     {
  581.       for (comp=0; comp < 3; comp ++)
  582.       {
  583.         int offset_test = params->RDPSliceBTest && active_sps->profile_idc != 66
  584.           ? iabs(offset[clist][index][comp]) > 2
  585.           : offset[clist][index][comp] != 0;
  587.         if (weight[clist][index][comp] != default_weight[0] || offset_test)
  588.         {
  589.           perform_wp = 1;
  590.           break;
  591.         }
  592.       }
  593.       if (perform_wp == 1) break;
  594.     }
  595.     if (perform_wp == 1) break;
  596.   }
  598.   return perform_wp;
  599. }
  601. /*!
  602. ************************************************************************
  603. * brief
  604. *    TestWPBSliceAlg1:
  605. *    Tests B slice weighting prediction
  606. ************************************************************************
  607. */
  608. int TestWPBSliceAlg1(ImageParameters *img, InputParameters *params, int select_method)
  609. {
  610.   int i, j, k, n;
  612.   int tx,DistScaleFactor;
  614.   int index;
  615.   int comp;
  616.   double dc_org = 0.0;
  617.   double dc_org_UV[2] = { 0.0 };    
  618.   double dc_ref[6][MAX_REFERENCE_PICTURES] = { {0.0} };  
  619.   double dc_ref_UV[6][MAX_REFERENCE_PICTURES][2] = { {{0.0}} };
  620.   double norm_org = 0.0;
  621.   double norm_ref[MAX_REFERENCE_PICTURES] = { 0.0 };
  622.   double numer = {0.0};
  623.   double denom[MAX_REFERENCE_PICTURES] = {0.0};
  625.   int default_weight[3];
  626.   // this needs to be fixed.
  627.   int list_offset   = ((img->MbaffFrameFlag)&&(img->mb_data[img->current_mb_nr].mb_field))? (img->current_mb_nr & 0x01) ? 4 : 2 : 0;
  628.   int weight[6][MAX_REFERENCE_PICTURES][3];
  629.   int offset[6][MAX_REFERENCE_PICTURES][3];
  630.   int im_weight[6][MAX_REFERENCE_PICTURES][MAX_REFERENCE_PICTURES][3];
  631.   int clist;
  632.   int wf_weight, wf_offset;
  633.   int perform_wp = 0;
  634.   imgpel **tmpPtr;
  636.   if (select_method == 1) //! implicit mode
  637.   {
  638.     luma_log_weight_denom = 5;
  639.     chroma_log_weight_denom = 5;
  640.   }
  641.   else
  642.   {
  643.     luma_log_weight_denom = 5;
  644.     chroma_log_weight_denom = 5;
  645.   }
  647.   wp_luma_round     = 1 << (luma_log_weight_denom - 1);
  648.   wp_chroma_round   = 1 << (chroma_log_weight_denom - 1);
  649.   default_weight[0] = 1 << luma_log_weight_denom;
  650.   default_weight[1] = 1 << chroma_log_weight_denom;
  651.   default_weight[2] = 1 << chroma_log_weight_denom;
  653.   /* set all values to defaults */
  654.   for (i = 0; i < 2 + list_offset; i++)
  655.   {
  656.     for (j = 0; j < listXsize[i]; j++)
  657.     {
  658.       for (n = 0; n < 3; n++)
  659.       {
  660.         wp_weight[i][j][n] = default_weight[n];
  661.         wp_offset[i][j][n] = 0;
  662.         offset   [i][j][n] = 0;
  663.         weight   [i][j][n] = default_weight[n];
  664.       }
  665.     }
  666.   }
  668.   for (i = 0; i < listXsize[LIST_0]; i++)
  669.   {
  670.     for (j = 0; j < listXsize[LIST_1]; j++)
  671.     {
  672.       int td, tb;
  673.       td = iClip3(-128, 127,(listX[LIST_1][j]->poc - listX[LIST_0][i]->poc));
  674.       tb = iClip3(-128, 127,(enc_picture->poc - listX[LIST_0][i]->poc));
  675.       for (comp = 0; comp < 3; comp++)
  676.       {
  677.         // implicit weights
  678.         if (td == 0)
  679.         {
  680.           im_weight[0][i][j][comp] = default_weight[comp];
  681.           im_weight[1][i][j][comp] = default_weight[comp];
  682.         }
  683.         else
  684.         {
  685.           tx = (16384 + iabs(td/2))/td;
  686.           DistScaleFactor = iClip3(-1024, 1023, (tx*tb + 32 )>>6);
  687.           im_weight[1][i][j][comp] = DistScaleFactor >> 2;
  688.           if (im_weight[1][i][j][comp] < -64 || im_weight[1][i][j][comp] >128)
  689.             im_weight[1][i][j][comp] = default_weight[comp];
  690.           im_weight[0][i][j][comp] = 64 - im_weight[1][i][j][comp];
  691.         }
  692.       }
  693.     }
  694.   }
  697.   if (select_method == 1) //! implicit mode
  698.   {
  699.     for (i = 0; i < listXsize[LIST_0]; i++)
  700.     {
  701.       for (j = 0; j < listXsize[LIST_1]; j++)
  702.       {
  703.         for (comp = 0; comp < 3; comp++)
  704.         {
  705.           wbp_weight[1][i][j][comp] = im_weight[1][i][j][comp] ;
  706.           wbp_weight[0][i][j][comp] = im_weight[0][i][j][comp];
  707.         }
  708.       }
  709.     }
  711.     for (clist=0; clist<2 + list_offset; clist++)
  712.     {
  713.       for (index = 0; index < listXsize[clist]; index++)
  714.       {
  715.         for (comp = 0; comp < 3; comp++)
  716.         {
  717.           wp_weight[clist][index][comp] = default_weight[comp];
  718.           wp_offset[clist][index][comp] = 0;
  719.         }
  720.       }
  721.     }
  722.   }
  723.   else
  724.   {
  725.     dc_org = ComputeImgSum(pCurImg, img->height, img->width);
  727.     if (params->EnhancedBWeightSupport)
  728.     {
  729.       norm_org = dc_org / ((double) img->size);
  730.       numer = ComputeNormMean(pCurImg, norm_org, img->height, img->width);
  731.     }
  733.     if (params->ChromaWeightSupport == 1)
  734.     {
  735.       for (k = 0; k < 2; k++)
  736.       {
  737.         dc_org_UV[k] = ComputeImgSum(pImgOrg[k + 1], img->height_cr, img->width_cr);
  738.       } 
  739.     }
  741.     for (clist=0; clist<2 + list_offset; clist++)
  742.     {
  743.       for (n = 0; n < listXsize[clist]; n++)
  744.       {
  745.         // To simplify these computations we may wish to perform these after a reference is 
  746.         // stored in the reference buffer and attach them to the storedimage structure!!!
  747.         // Y
  748.         tmpPtr = listX[clist][n]->p_curr_img;
  749.         dc_ref[clist][n] = ComputeImgSum(tmpPtr, img->height, img->width);
  751.         if (params->EnhancedBWeightSupport)
  752.         {
  753.           norm_ref[n] = dc_ref[clist][n] / ((double) img->size);
  754.           denom[n] = ComputeNormMean(tmpPtr, norm_ref[n], img->height, img->width);
  756.           if (denom[n] != 0)
  757.             wf_weight = (int) (default_weight[0] * numer / denom[n] + 0.5);
  758.           else
  759.             wf_weight = default_weight[0];  // only used when reference picture is black
  760.           wf_weight = iClip3(-128, 127, wf_weight);
  762.           wf_offset = (int) (norm_org - ((double) wf_weight * norm_ref[n] / (double) default_weight[0]) + 0.5);
  763.           wf_offset = (wf_offset  + ((img->bitdepth_luma-8)>>1))>>(img->bitdepth_luma-8);
  764.           wf_offset = iClip3( -128, 127, wf_offset);
  765.           wf_offset = wf_offset <<(img->bitdepth_luma - 8);
  766.         }
  767.         else
  768.         {
  769.           if (dc_ref[clist][n] != 0.0)
  770.             wf_weight = (int) (default_weight[0] * dc_org / dc_ref[clist][n] + 0.5);
  771.           else
  772.             wf_weight = default_weight[0];  // only used when reference picture is black
  773.           wf_weight = iClip3(-128, 127, wf_weight);
  774.           wf_offset = 0;
  775.         }
  777.         weight[clist][n][0] = wf_weight;
  778.         offset[clist][n][0] = wf_offset;
  780.         // UV
  781.         if (params->ChromaWeightSupport == 1)
  782.         {          
  783.           for (k = 0; k < 2; k++)
  784.           {
  785.             tmpPtr = listX[clist][n]->imgUV[k];
  786.             dc_ref_UV[clist][n][k] = ComputeImgSum(tmpPtr, img->height_cr, img->width_cr);
  788.             if (dc_ref_UV[clist][n][k] != 0.0)
  789.               wf_weight = (int) (default_weight[k + 1] * dc_org_UV[k] / dc_ref_UV[clist][n][k] + 0.5);
  790.             else
  791.               wf_weight = default_weight[k + 1];  // only used when reference picture is black
  792.             wf_weight = iClip3(-128, 127, wf_weight);
  793.             wf_offset = 0;
  795.             weight[clist][n][k + 1] = wf_weight;
  796.             offset[clist][n][k + 1] = wf_offset;
  797.           }
  798.         }
  799.         else
  800.         {
  801.           weight[clist][n][1] = default_weight[1];
  802.           weight[clist][n][2] = default_weight[2];        
  803.           offset[clist][n][1] = 0;
  804.           offset[clist][n][2] = 0;
  805.         }
  806.       }
  807.     }
  809.     if (select_method == 0) //! explicit mode
  810.     {
  811.       for (clist=0; clist<2 + list_offset; clist++)
  812.       {
  813.         for (index = 0; index < listXsize[clist]; index++)
  814.         {
  815.           memcpy(wp_weight[clist][index], weight[clist][index], 3 * sizeof(int));
  816.           memcpy(wp_offset[clist][index], offset[clist][index], 3 * sizeof(int));
  817.         }
  818.       }
  819.     }
  820.     else
  821.     {
  822.       for (clist=0; clist<2 + list_offset; clist++)
  823.       {
  824.         for (index = 0; index < listXsize[clist]; index++)
  825.         {
  826.           memcpy(wp_weight[clist][index], default_weight, 3 * sizeof(int));
  827.           memset(wp_offset[clist][index], 0, 3 * sizeof(int));
  828.         }
  829.       }
  830.     }
  832.     for (i = 0; i < listXsize[LIST_0]; i++)
  833.     {
  834.       for (j = 0; j < listXsize[LIST_1]; j++)
  835.       {
  836.         for (comp = 0; comp < 3; comp++)
  837.         {
  838.           wbp_weight[0][i][j][comp] = wp_weight[0][i][comp];
  839.           wbp_weight[1][i][j][comp] = wp_weight[1][j][comp];
  840.         }
  841. #if DEBUG_WP
  842.         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],
  843.         enc_picture->poc,listX[LIST_0][i]->poc, listX[LIST_1][j]->poc,
  844.         DistScaleFactor ,tx,tx,tx);
  845. #endif
  846.       }
  847.     }
  848.   }
  850.   if (select_method == 0) //! implicit mode
  851.   {
  852.     int active_refs[2];
  854.     active_refs[0] = (params->B_List0_refs == 0 ? listXsize[0] : imin(params->B_List0_refs, listXsize[0]));
  855.     active_refs[1] = (params->B_List1_refs == 0 ? listXsize[1] : imin(params->B_List1_refs, listXsize[1]));
  857.     for (clist=0; clist<2 + list_offset; clist++)
  858.     {
  859.       for (index = 0; index < active_refs[clist]; index++)
  860.       {
  861.         for (comp=0; comp < 3; comp ++)
  862.         {
  863.           if (wp_weight[clist][index][comp] != default_weight[comp])
  864.           {
  865.             perform_wp = 1;
  866.             break;
  867.           }
  868.         }
  869.         if (perform_wp == 1) break;
  870.       }
  871.       if (perform_wp == 1) break;
  872.     }
  873.   }
  874.   return perform_wp;
  875. }