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

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

Audio

开发平台：

Visual C++

img_luma.c：源码内容
  1. /*!
  2. *************************************************************************************
  3. * file img_luma.c
  4. *
  5. * brief
  6. *    Luma interpolation functions
  7. *
  8. * author
  9. *    Main contributors (see contributors.h for copyright, address and affiliation details)
  10. *      - Alexis Michael Tourapis <alexis.tourapis@dolby.com>
  11. *      - Athanasios Leontaris    <aleon@dolby.com>
  12. *
  13. *************************************************************************************
  14. */
  16. #include "contributors.h"
  18. #include <limits.h>
  20. #include "global.h"
  21. #include "image.h"
  22. #include "img_luma.h"
  23. #include "memalloc.h"
  25. const int ONE_FOURTH_TAP[2][3] =
  26. {
  27.   {20, -5, 1},  // AVC Interpolation taps
  28.   {20,-4, 0},   // Experimental - not valid
  29. };
  31. /*!
  32.  ************************************************************************
  33.  * brief
  34.  *    Creates the 4x4 = 16 images that contain quarter-pel samples
  35.  *    sub-sampled at different spatial orientations;
  36.  *    enables more efficient implementation
  37.  *
  38.  * param s
  39.  *    pointer to StorablePicture structure
  40.  s************************************************************************
  41.  */
  42. void getSubImagesLuma( StorablePicture *s )
  43. {
  44.   imgpel  **p_curr_img = s->p_curr_img;
  45.   imgpel ****cImgSub   = s->p_curr_img_sub;
  47.   //  0  1  2  3
  48.   //  4  5  6  7
  49.   //  8  9 10 11
  50.   // 12 13 14 15
  52.   //// INTEGER PEL POSITIONS ////
  54.   // sub-image 0 [0][0]
  55.   // simply copy the integer pels
  56.   getSubImageInteger( s, cImgSub[0][0], p_curr_img);
  58.   //// HALF-PEL POSITIONS: SIX-TAP FILTER ////
  60.   // sub-image 2 [0][2]
  61.   // HOR interpolate (six-tap) sub-image [0][0]
  62.   getHorSubImageSixTap( s, cImgSub[0][2], cImgSub[0][0] );
  64.   // sub-image 8 [2][0]
  65.   // VER interpolate (six-tap) sub-image [0][0]
  66.   getVerSubImageSixTap( s, cImgSub[2][0], cImgSub[0][0]);
  68.   // sub-image 10 [2][2]
  69.   // VER interpolate (six-tap) sub-image [0][2]
  70.   getVerSubImageSixTapTmp( s, cImgSub[2][2], cImgSub[0][2]);
  72.   //// QUARTER-PEL POSITIONS: BI-LINEAR INTERPOLATION ////
  74.   // sub-image 1 [0][1]
  75.   getSubImageBiLinear    ( s, cImgSub[0][1], cImgSub[0][0], cImgSub[0][2]);
  76.   // sub-image 4 [1][0]
  77.   getSubImageBiLinear    ( s, cImgSub[1][0], cImgSub[0][0], cImgSub[2][0]);
  78.   // sub-image 5 [1][1]
  79.   getSubImageBiLinear    ( s, cImgSub[1][1], cImgSub[0][2], cImgSub[2][0]);
  80.   // sub-image 6 [1][2]
  81.   getSubImageBiLinear    ( s, cImgSub[1][2], cImgSub[0][2], cImgSub[2][2]);
  82.   // sub-image 9 [2][1]
  83.   getSubImageBiLinear    ( s, cImgSub[2][1], cImgSub[2][0], cImgSub[2][2]);
  85.   // sub-image 3  [0][3]
  86.   getHorSubImageBiLinear ( s, cImgSub[0][3], cImgSub[0][2], cImgSub[0][0]);
  87.   // sub-image 7  [1][3]
  88.   getHorSubImageBiLinear ( s, cImgSub[1][3], cImgSub[0][2], cImgSub[2][0]);
  89.   // sub-image 11 [2][3]
  90.   getHorSubImageBiLinear ( s, cImgSub[2][3], cImgSub[2][2], cImgSub[2][0]);
  92.   // sub-image 12 [3][0]
  93.   getVerSubImageBiLinear ( s, cImgSub[3][0], cImgSub[2][0], cImgSub[0][0]);
  94.   // sub-image 13 [3][1]
  95.   getVerSubImageBiLinear ( s, cImgSub[3][1], cImgSub[2][0], cImgSub[0][2]);
  96.   // sub-image 14 [3][2]
  97.   getVerSubImageBiLinear ( s, cImgSub[3][2], cImgSub[2][2], cImgSub[0][2]);
  99.   // sub-image 15 [3][3]
  100.   getDiagSubImageBiLinear( s, cImgSub[3][3], cImgSub[0][2], cImgSub[2][0]);
  101. }
  104. /*!
  105.  ************************************************************************
  106.  * brief
  107.  *    Copy Integer Samples to image [0][0]
  108.  *
  109.  * param s
  110.  *    pointer to StorablePicture structure
  111.  * param dstImg
  112.  *    destination image
  113.  * param srcImg
  114.  *    source image
  115.  ************************************************************************
  116.  */
  117. void getSubImageInteger( StorablePicture *s, imgpel **dstImg, imgpel **srcImg)
  118. {
  119.   int i, j;
  120.   int size_x_minus1 = s->size_x - 1;
  122.   static imgpel *wBufSrc, *wBufDst;
  124.   // Copy top line
  125.   wBufDst = &( dstImg[0][0] ); 
  126.   wBufSrc = srcImg[0];
  127.   // left IMG_PAD_SIZE
  128.   for (i = 0; i < IMG_PAD_SIZE; i++)
  129.     *(wBufDst++) = wBufSrc[0];
  130.   // center 0-(s->size_x)
  131.   memcpy(wBufDst, wBufSrc, s->size_x * sizeof(imgpel));
  132.   wBufDst += s->size_x;
  133.   // right IMG_PAD_SIZE
  134.   for (i = 0; i < IMG_PAD_SIZE; i++)
  135.     *(wBufDst++) = wBufSrc[size_x_minus1];
  137.   // Now copy remaining pad lines
  138.   for (j = 1; j < IMG_PAD_SIZE + 1; j++)
  139.   {
  140.     memcpy(dstImg[j], dstImg[j - 1], s->size_x_padded * sizeof(imgpel));
  141.   }
  143.   for (j = 1; j < s->size_y; j++)
  144.   {    
  145.     wBufDst = &( dstImg[j + IMG_PAD_SIZE][0] ); // 4:4:4 independent mode
  146.     wBufSrc = srcImg[j];
  147.     // left IMG_PAD_SIZE
  148.     for (i = 0; i < IMG_PAD_SIZE; i++)
  149.       *(wBufDst++) = wBufSrc[0];
  150.     // center 0-(s->size_x)
  151.     memcpy(wBufDst, wBufSrc, s->size_x * sizeof(imgpel));
  152.     wBufDst += s->size_x;
  153.     // right IMG_PAD_SIZE
  154.     for (i = 0; i < IMG_PAD_SIZE; i++)
  155.       *(wBufDst++) = wBufSrc[size_x_minus1];
  156.   }
  158.   // Replicate bottom pad lines
  159.   for (j = s->size_y + IMG_PAD_SIZE; j < s->size_y_padded; j++)
  160.   {    
  161.     memcpy(dstImg[j], dstImg[j - 1], s->size_x_padded * sizeof(imgpel));
  162.   }
  163. }
  165. /*!
  166.  ************************************************************************
  167.  * brief
  168.  *    Does _horizontal_ interpolation using the SIX TAP filters
  169.  *
  170.  * param s
  171.  *    pointer to StorablePicture structure
  172.  * param dstImg
  173.  *    destination image
  174.  * param srcImg
  175.  *    source image
  176.  ************************************************************************
  177.  */
  178. void getHorSubImageSixTap( StorablePicture *s, imgpel **dstImg, imgpel **srcImg)
  179. {
  180.   int is, jpad, ipad;
  181.   int ypadded_size = s->size_y_padded;
  182.   int xpadded_size = s->size_x_padded;
  184.   static imgpel *wBufSrc, *wBufDst;
  185.   static imgpel *srcImgA, *srcImgB, *srcImgC, *srcImgD, *srcImgE, *srcImgF;
  186.   static int *iBufDst;
  187.   const int tap0 = ONE_FOURTH_TAP[0][0];
  188.   const int tap1 = ONE_FOURTH_TAP[0][1];
  189.   const int tap2 = ONE_FOURTH_TAP[0][2];
  191.   for (jpad = 0; jpad < ypadded_size; jpad++)
  192.   {
  193.     wBufSrc = srcImg[jpad];     // 4:4:4 independent mode
  194.     wBufDst = dstImg[jpad];     // 4:4:4 independent mode
  195.     iBufDst = imgY_sub_tmp[jpad];
  197.     srcImgA = &wBufSrc[0];
  198.     srcImgB = &wBufSrc[0];      
  199.     srcImgC = &wBufSrc[0];
  200.     srcImgD = &wBufSrc[1];
  201.     srcImgE = &wBufSrc[2];
  202.     srcImgF = &wBufSrc[3];
  204.     // left padded area
  205.     is =
  206.       (tap0 * (*srcImgA++ + *srcImgD++) +
  207.       tap1 *  (*srcImgB   + *srcImgE++) +
  208.       tap2 *  (*srcImgC   + *srcImgF++));
  210.     *iBufDst++ =  is;
  211.     *wBufDst++ = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );      
  213.     is =
  214.       (tap0 * (*srcImgA++ + *srcImgD++) +
  215.       tap1 *  (*srcImgB++ + *srcImgE++) +
  216.       tap2 *  (*srcImgC   + *srcImgF++));
  218.     *iBufDst++ =  is;
  219.     *wBufDst++ = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );      
  221.     // center
  222.     for (ipad = 2; ipad < xpadded_size - 4; ipad++)
  223.     {
  224.       is =
  225.         (tap0 * (*srcImgA++ + *srcImgD++) +
  226.         tap1 *  (*srcImgB++ + *srcImgE++) +
  227.         tap2 *  (*srcImgC++ + *srcImgF++));
  229.       *iBufDst++ =  is;
  230.       *wBufDst++ = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );      
  231.     }
  233.     is = (
  234.       tap0 * (*srcImgA++ + *srcImgD++) +
  235.       tap1 * (*srcImgB++ + *srcImgE++) +
  236.       tap2 * (*srcImgC++ + *srcImgF  ));
  238.     *iBufDst++ =  is;
  239.     *wBufDst++ = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );      
  241.     // right padded area
  242.     is = (
  243.       tap0 * (*srcImgA++ + *srcImgD++) +
  244.       tap1 * (*srcImgB++ + *srcImgE) +
  245.       tap2 * (*srcImgC++ + *srcImgF));
  247.     *iBufDst++ =  is;
  248.     *wBufDst++ = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );      
  250.     is = (
  251.       tap0 * (*srcImgA++ + *srcImgD) +
  252.       tap1 * (*srcImgB++ + *srcImgE) +
  253.       tap2 * (*srcImgC++ + *srcImgF));
  255.     *iBufDst++ =  is;
  256.     *wBufDst++ = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );      
  258.     is = (
  259.       tap0 * (*srcImgA + *srcImgD) +
  260.       tap1 * (*srcImgB + *srcImgE) +
  261.       tap2 * (*srcImgC + *srcImgF));
  263.     *iBufDst =  is;
  264.     *wBufDst = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );      
  266.   }
  267. }
  270. /*!
  271.  ************************************************************************
  272.  * brief
  273.  *    Does _vertical_ interpolation using the SIX TAP filters
  274.  *
  275.  * param s
  276.  *    pointer to StorablePicture structure
  277.  * param dstImg
  278.  *    pointer to target image
  279.  * param srcImg
  280.  *    pointer to source image
  281.  ************************************************************************
  282.  */
  283. void getVerSubImageSixTap( StorablePicture *s, imgpel **dstImg, imgpel **srcImg)
  284. {
  285.   int is, jpad, ipad;
  286.   int ypadded_size = s->size_y_padded;
  287.   int xpadded_size = s->size_x_padded;
  288.   int maxy = ypadded_size - 1;
  290.   static imgpel *wxLineDst;
  291.   static imgpel *srcImgA, *srcImgB, *srcImgC, *srcImgD, *srcImgE, *srcImgF;
  292.   const int tap0 = ONE_FOURTH_TAP[0][0];
  293.   const int tap1 = ONE_FOURTH_TAP[0][1];
  294.   const int tap2 = ONE_FOURTH_TAP[0][2];
  296.   // branches within the j loop
  297.   // top
  298.   for (jpad = 0; jpad < 2; jpad++)
  299.   {
  300.     wxLineDst = dstImg[jpad];
  301.     srcImgA = srcImg[jpad ];
  302.     srcImgB = srcImg[0];      
  303.     srcImgC = srcImg[0];
  304.     srcImgD = srcImg[jpad + 1];
  305.     srcImgE = srcImg[jpad + 2];
  306.     srcImgF = srcImg[jpad + 3];
  307.     for (ipad = 0; ipad < xpadded_size; ipad++)
  308.     {
  309.       is =
  310.         (tap0 * (*srcImgA++ + *srcImgD++) +
  311.         tap1 *  (*srcImgB++ + *srcImgE++) +
  312.         tap2 *  (*srcImgC++ + *srcImgF++));
  314.       wxLineDst[ipad] = (imgpel) iClip1 (img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );
  315.     }
  316.   }
  317.   // center
  318.   for (jpad = 2; jpad < ypadded_size - 3; jpad++)
  319.   {
  320.     wxLineDst = dstImg[jpad];
  321.     srcImgA = srcImg[jpad ];
  322.     srcImgB = srcImg[jpad - 1];      
  323.     srcImgC = srcImg[jpad - 2];
  324.     srcImgD = srcImg[jpad + 1];
  325.     srcImgE = srcImg[jpad + 2];
  326.     srcImgF = srcImg[jpad + 3];
  327.     for (ipad = 0; ipad < xpadded_size; ipad++)
  328.     {
  329.       is =
  330.         (tap0 * (*srcImgA++ + *srcImgD++) +
  331.         tap1 *  (*srcImgB++ + *srcImgE++) +
  332.         tap2 *  (*srcImgC++ + *srcImgF++));
  334.       wxLineDst[ipad] = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );
  335.     }
  336.   }
  338.   // bottom
  339.   for (jpad = ypadded_size - 3; jpad < ypadded_size; jpad++)
  340.   {
  341.     wxLineDst = dstImg[jpad];
  342.     srcImgA = srcImg[jpad ];
  343.     srcImgB = srcImg[jpad - 1];      
  344.     srcImgC = srcImg[jpad - 2];
  345.     srcImgD = srcImg[imin (maxy, jpad + 1)];
  346.     srcImgE = srcImg[maxy];
  347.     srcImgF = srcImg[maxy];
  348.     for (ipad = 0; ipad < xpadded_size; ipad++)
  349.     {
  350.       is =
  351.         (tap0 * (*srcImgA++ + *srcImgD++) +
  352.         tap1 *  (*srcImgB++ + *srcImgE++) +
  353.         tap2 *  (*srcImgC++ + *srcImgF++));
  355.       wxLineDst[ipad] = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 5 ) );
  356.     }
  357.   }
  358. }
  360. /*!
  361.  ************************************************************************
  362.  * brief
  363.  *    Does _vertical_ interpolation using the SIX TAP filters
  364.  *
  365.  * param s
  366.  *    pointer to StorablePicture structure
  367.  * param dstImg
  368.  *    pointer to target image
  369.  * param srcImg
  370.  *    pointer to source image
  371.  ************************************************************************
  372.  */
  373. void getVerSubImageSixTapTmp( StorablePicture *s, imgpel **dstImg, imgpel **srcImg)
  374. {
  375.   int is, jpad, ipad;
  376.   int ypadded_size = s->size_y_padded;
  377.   int xpadded_size = s->size_x_padded;
  378.   int maxy = ypadded_size - 1;
  380.   static imgpel *wxLineDst;
  381.   static int *srcImgA, *srcImgB, *srcImgC, *srcImgD, *srcImgE, *srcImgF;
  382.   const int tap0 = ONE_FOURTH_TAP[0][0];
  383.   const int tap1 = ONE_FOURTH_TAP[0][1];
  384.   const int tap2 = ONE_FOURTH_TAP[0][2];
  386.   // top
  387.   for (jpad = 0; jpad < 2; jpad++)
  388.   {
  389.     wxLineDst = dstImg[jpad];
  390.     srcImgA = imgY_sub_tmp[jpad ];
  391.     srcImgB = imgY_sub_tmp[0];      
  392.     srcImgC = imgY_sub_tmp[0];
  393.     srcImgD = imgY_sub_tmp[jpad + 1];
  394.     srcImgE = imgY_sub_tmp[jpad + 2];
  395.     srcImgF = imgY_sub_tmp[jpad + 3];
  397.     for (ipad = 0; ipad < xpadded_size; ipad++)
  398.     {
  399.       is =
  400.         (tap0 * (*srcImgA++ + *srcImgD++) +
  401.         tap1 *  (*srcImgB++ + *srcImgE++) +
  402.         tap2 *  (*srcImgC++ + *srcImgF++));
  404.       wxLineDst[ipad] = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 10 ) );
  405.     }
  406.   }
  408.   // center
  409.   for (jpad = 2; jpad < ypadded_size - 3; jpad++)
  410.   {
  411.     wxLineDst = dstImg[jpad];
  412.     srcImgA = imgY_sub_tmp[jpad ];
  413.     srcImgB = imgY_sub_tmp[jpad - 1];      
  414.     srcImgC = imgY_sub_tmp[jpad - 2];
  415.     srcImgD = imgY_sub_tmp[jpad + 1];
  416.     srcImgE = imgY_sub_tmp[jpad + 2];
  417.     srcImgF = imgY_sub_tmp[jpad + 3];
  418.     for (ipad = 0; ipad < xpadded_size; ipad++)
  419.     {
  420.       is =
  421.         (tap0 * (*srcImgA++ + *srcImgD++) +
  422.         tap1 *  (*srcImgB++ + *srcImgE++) +
  423.         tap2 *  (*srcImgC++ + *srcImgF++));
  425.       wxLineDst[ipad] = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 10 ) );
  426.     }
  427.   }
  429.   // bottom
  430.   for (jpad = ypadded_size - 3; jpad < ypadded_size; jpad++)
  431.   {
  432.     wxLineDst = dstImg[jpad];
  433.     srcImgA = imgY_sub_tmp[jpad ];
  434.     srcImgB = imgY_sub_tmp[jpad - 1];      
  435.     srcImgC = imgY_sub_tmp[jpad - 2];
  436.     srcImgD = imgY_sub_tmp[imin (maxy, jpad + 1)];
  437.     srcImgE = imgY_sub_tmp[maxy];
  438.     srcImgF = imgY_sub_tmp[maxy];
  439.     for (ipad = 0; ipad < xpadded_size; ipad++)
  440.     {
  441.       is =
  442.         (tap0 * (*srcImgA++ + *srcImgD++) +
  443.         tap1 *  (*srcImgB++ + *srcImgE++) +
  444.         tap2 *  (*srcImgC++ + *srcImgF++));
  446.       wxLineDst[ipad] = (imgpel) iClip1 ( img->max_imgpel_value, rshift_rnd_sf( is, 10 ) );
  447.     }
  448.   }
  449. }
  451. /*!
  452.  ************************************************************************
  453.  * brief
  454.  *    Does _horizontal_ interpolation using the BiLinear filter
  455.  *
  456.  * param s
  457.  *    pointer to StorablePicture structure
  458.  * param dstImg
  459.  *    destination Image
  460.  * param srcImgL
  461.  *    source left image
  462.  * param srcImgR
  463.  *    source right image 
  464.  ************************************************************************
  465.  */
  466. void getSubImageBiLinear( StorablePicture *s, imgpel **dstImg, imgpel **srcImgL, imgpel **srcImgR)
  467. {
  468.   int jpad, ipad;
  469.   int ypadded_size = s->size_y_padded;
  470.   int xpadded_size = s->size_x_padded;
  472.   static imgpel *wBufSrcL, *wBufSrcR, *wBufDst;
  474.   for (jpad = 0; jpad < ypadded_size; jpad++)
  475.   {
  476.     wBufSrcL = srcImgL[jpad]; // 4:4:4 independent mode
  477.     wBufSrcR = srcImgR[jpad]; // 4:4:4 independent mode
  478.     wBufDst  = dstImg[jpad];  // 4:4:4 independent mode
  480.     for (ipad = 0; ipad < xpadded_size; ipad++)
  481.     {
  482.       *wBufDst++ = (imgpel) rshift_rnd_sf( *wBufSrcL++ + *wBufSrcR++, 1 );
  483.     }
  484.   }
  485. }
  488. /*!
  489.  ************************************************************************
  490.  * brief
  491.  *    Does _horizontal_ interpolation using the BiLinear filter
  492.  *
  493.  * param s
  494.  *    pointer to StorablePicture structure
  495.  * param dstImg
  496.  *    destination Image
  497.  * param srcImgL
  498.  *    source left image
  499.  * param srcImgR
  500.  *    source right image 
  501.  ************************************************************************
  502.  */
  503. void getHorSubImageBiLinear( StorablePicture *s, imgpel **dstImg, imgpel **srcImgL, imgpel **srcImgR)
  504. {
  505.   int jpad, ipad;
  506.   int ypadded_size = s->size_y_padded;
  507.   int xpadded_size = s->size_x_padded - 1;
  509.   static imgpel *wBufSrcL, *wBufSrcR, *wBufDst;
  511.   for (jpad = 0; jpad < ypadded_size; jpad++)
  512.   {
  513.     wBufSrcL = srcImgL[jpad]; // 4:4:4 independent mode
  514.     wBufSrcR = &srcImgR[jpad][1]; // 4:4:4 independent mode
  515.     wBufDst  = dstImg[jpad];     // 4:4:4 independent mode
  517.     // left padded area + center
  518.     for (ipad = 0; ipad < xpadded_size; ipad++)
  519.     {
  520.       *wBufDst++ = (imgpel) rshift_rnd_sf( *wBufSrcL++ + *wBufSrcR++, 1 );
  521.     }
  522.     // right padded area
  523.       *wBufDst++ = (imgpel) rshift_rnd_sf( *wBufSrcL++ + wBufSrcR[-1], 1 );
  524.   }
  525. }
  528. /*!
  529.  ************************************************************************
  530.  * brief
  531.  *    Does _vertical_ interpolation using the BiLinear filter
  532.  *
  533.  * param s
  534.  *    pointer to StorablePicture structure
  535.  * param dstImg
  536.  *    destination Image
  537.  * param srcImgT
  538.  *    source top image
  539.  * param srcImgB
  540.  *    source bottom image 
  541.  ************************************************************************
  542.  */
  543. void getVerSubImageBiLinear( StorablePicture *s, imgpel **dstImg, imgpel **srcImgT, imgpel **srcImgB)
  544. {
  545.   int jpad, ipad;
  546.   int ypadded_size = s->size_y_padded - 1;
  547.   int xpadded_size = s->size_x_padded;  
  549.   static imgpel *wBufSrcT, *wBufSrcB, *wBufDst;
  551.   // top
  552.   for (jpad = 0; jpad < ypadded_size; jpad++)
  553.   {
  554.     wBufSrcT = srcImgT[jpad];           // 4:4:4 independent mode
  555.     wBufDst  = dstImg[jpad];            // 4:4:4 independent mode
  556.     wBufSrcB = srcImgB[jpad + 1];  // 4:4:4 independent mode
  558.     for (ipad = 0; ipad < xpadded_size; ipad++)
  559.     {
  560.       *wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcT++ + *wBufSrcB++, 1);
  561.     }
  562.   }
  563.   // bottom
  564.   wBufSrcT = srcImgT[ypadded_size];           // 4:4:4 independent mode
  565.   wBufDst  = dstImg[ypadded_size];            // 4:4:4 independent mode
  566.   wBufSrcB = srcImgB[ypadded_size];           // 4:4:4 independent mode
  568.   for (ipad = 0; ipad < xpadded_size; ipad++)
  569.   {
  570.     *wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcT++ + *wBufSrcB++, 1);
  571.   }
  572. }
  575. /*!
  576.  ************************************************************************
  577.  * brief
  578.  *    Does _diagonal_ interpolation using the BiLinear filter
  579.  *
  580.  * param s
  581.  *    pointer to StorablePicture structure
  582.  * param dstImg
  583.  *    destination Image
  584.  * param srcImgT
  585.  *    source top/left image
  586.  * param srcImgB
  587.  *    source bottom/right image 
  588.  ************************************************************************
  589.  */
  590. void getDiagSubImageBiLinear( StorablePicture *s, imgpel **dstImg, imgpel **srcImgT, imgpel **srcImgB )
  591. {
  592.   int jpad, ipad;
  593.   int maxx = s->size_x_padded - 1;
  594.   int maxy = s->size_y_padded - 1;
  596.   static imgpel *wBufSrcL, *wBufSrcR, *wBufDst;
  598.   for (jpad = 0; jpad < maxy; jpad++)
  599.   {
  600.     wBufSrcL = srcImgT[jpad + 1]; // 4:4:4 independent mode
  601.     wBufSrcR = &srcImgB[jpad][1]; // 4:4:4 independent mode
  602.     wBufDst  = dstImg[jpad];      // 4:4:4 independent mode
  604.     for (ipad = 0; ipad < maxx; ipad++)
  605.     {
  606.       *wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcL++ + *wBufSrcR++, 1);
  607.     }
  609.     *wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcL++ +  wBufSrcR[-1], 1);
  610.   }
  612.   wBufSrcL = srcImgT[maxy];     // 4:4:4 independent mode
  613.   wBufSrcR = &srcImgB[maxy][1]; // 4:4:4 independent mode
  614.   wBufDst = dstImg[maxy];       // 4:4:4 independent mode
  616.   for (ipad = 0; ipad < maxx; ipad++)
  617.   {
  618.     *wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcL++ + *wBufSrcR++, 1);
  619.   }
  621.     *wBufDst++ = (imgpel) rshift_rnd_sf(*wBufSrcL++ + wBufSrcR[-1], 1);
  622. }