[svn] / branches / release-1_3-branch / xvidcore / src / image / image.c Repository:
ViewVC logotype

Diff of /branches/release-1_3-branch/xvidcore/src/image/image.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1397, Thu Apr 1 11:11:28 2004 UTC revision 1795, Wed Nov 26 01:04:34 2008 UTC
# Line 19  Line 19 
19   *  along with this program ; if not, write to the Free Software   *  along with this program ; if not, write to the Free Software
20   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21   *   *
22   * $Id: image.c,v 1.28 2004-04-01 11:11:28 suxen_drol Exp $   * $Id: image.c,v 1.42 2008-11-26 01:04:34 Isibaar Exp $
23   *   *
24   ****************************************************************************/   ****************************************************************************/
25    
26  #include <stdlib.h>  #include <stdlib.h>
27  #include <string.h>                             /* memcpy, memset */  #include <string.h>                             /* memcpy, memset */
28  #include <math.h>  #include <math.h>
   
29  #include "../portab.h"  #include "../portab.h"
30  #include "../global.h"                  /* XVID_CSP_XXX's */  #include "../global.h"                  /* XVID_CSP_XXX's */
31  #include "../xvid.h"                    /* XVID_CSP_XXX's */  #include "../xvid.h"                    /* XVID_CSP_XXX's */
32  #include "image.h"  #include "image.h"
33  #include "colorspace.h"  #include "colorspace.h"
34  #include "interpolate8x8.h"  #include "interpolate8x8.h"
 #include "reduced.h"  
35  #include "../utils/mem_align.h"  #include "../utils/mem_align.h"
36    #include "../motion/sad.h"
37    #include "../utils/emms.h"
38    
39  #include "font.h"               /* XXX: remove later */  #include "font.h"               /* XXX: remove later */
40    
# Line 237  Line 237 
237          }          }
238  }  }
239    
 /* bframe encoding requires image-based u,v interpolation */  
240  void  void
241  image_interpolate(const IMAGE * refn,  image_interpolate(const uint8_t * refn,
242                                    IMAGE * refh,                                    uint8_t * refh,
243                                    IMAGE * refv,                                    uint8_t * refv,
244                                    IMAGE * refhv,                                    uint8_t * refhv,
245                                    uint32_t edged_width,                                    uint32_t edged_width,
246                                    uint32_t edged_height,                                    uint32_t edged_height,
247                                    uint32_t quarterpel,                                    uint32_t quarterpel,
# Line 250  Line 249 
249  {  {
250          const uint32_t offset = EDGE_SIZE2 * (edged_width + 1); /* we only interpolate half of the edge area */          const uint32_t offset = EDGE_SIZE2 * (edged_width + 1); /* we only interpolate half of the edge area */
251          const uint32_t stride_add = 7 * edged_width;          const uint32_t stride_add = 7 * edged_width;
 #if 0  
         const uint32_t edged_width2 = edged_width / 2;  
         const uint32_t edged_height2 = edged_height / 2;  
         const uint32_t offset2 = EDGE_SIZE2 * (edged_width2 + 1);  
         const uint32_t stride_add2 = 7 * edged_width2;  
 #endif  
         uint8_t *n_ptr, *h_ptr, *v_ptr, *hv_ptr;  
         uint32_t x, y;  
252    
253            uint8_t *n_ptr;
254            uint8_t *h_ptr, *v_ptr, *hv_ptr;
255            uint32_t x, y;
256    
257          n_ptr = refn->y;          n_ptr = (uint8_t*)refn;
258          h_ptr = refh->y;          h_ptr = refh;
259          v_ptr = refv->y;          v_ptr = refv;
260    
261          n_ptr -= offset;          n_ptr -= offset;
262          h_ptr -= offset;          h_ptr -= offset;
# Line 291  Line 285 
285                          n_ptr += stride_add;                          n_ptr += stride_add;
286                  }                  }
287    
288                  h_ptr = refh->y + (edged_height - EDGE_SIZE - EDGE_SIZE2)*edged_width - EDGE_SIZE2;                  h_ptr = refh + (edged_height - EDGE_SIZE - EDGE_SIZE2)*edged_width - EDGE_SIZE2;
289                  hv_ptr = refhv->y + (edged_height - EDGE_SIZE - EDGE_SIZE2)*edged_width - EDGE_SIZE2;                  hv_ptr = refhv + (edged_height - EDGE_SIZE - EDGE_SIZE2)*edged_width - EDGE_SIZE2;
290    
291                  for (y = 0; y < (edged_height - EDGE_SIZE); y = y + 8) {                  for (y = 0; y < (edged_height - EDGE_SIZE); y = y + 8) {
292                          hv_ptr -= stride_add;                          hv_ptr -= stride_add;
# Line 308  Line 302 
302                  }                  }
303          } else {          } else {
304    
305                  hv_ptr = refhv->y;                  hv_ptr = refhv;
306                  hv_ptr -= offset;                  hv_ptr -= offset;
307    
308                  for (y = 0; y < (edged_height - EDGE_SIZE); y += 8) {                  for (y = 0; y < (edged_height - EDGE_SIZE); y += 8) {
# Line 334  Line 328 
328                          n_ptr += stride_add;                          n_ptr += stride_add;
329                  }                  }
330          }          }
 /*  
 #ifdef BFRAMES  
         n_ptr = refn->u;  
         h_ptr = refh->u;  
         v_ptr = refv->u;  
         hv_ptr = refhv->u;  
   
         n_ptr -= offset2;  
         h_ptr -= offset2;  
         v_ptr -= offset2;  
         hv_ptr -= offset2;  
   
         for (y = 0; y < edged_height2; y += 8) {  
                 for (x = 0; x < edged_width2; x += 8) {  
                         interpolate8x8_halfpel_h(h_ptr, n_ptr, edged_width2, rounding);  
                         interpolate8x8_halfpel_v(v_ptr, n_ptr, edged_width2, rounding);  
                         interpolate8x8_halfpel_hv(hv_ptr, n_ptr, edged_width2, rounding);  
   
                         n_ptr += 8;  
                         h_ptr += 8;  
                         v_ptr += 8;  
                         hv_ptr += 8;  
                 }  
                 h_ptr += stride_add2;  
                 v_ptr += stride_add2;  
                 hv_ptr += stride_add2;  
                 n_ptr += stride_add2;  
         }  
   
         n_ptr = refn->v;  
         h_ptr = refh->v;  
         v_ptr = refv->v;  
         hv_ptr = refhv->v;  
   
         n_ptr -= offset2;  
         h_ptr -= offset2;  
         v_ptr -= offset2;  
         hv_ptr -= offset2;  
   
         for (y = 0; y < edged_height2; y = y + 8) {  
                 for (x = 0; x < edged_width2; x = x + 8) {  
                         interpolate8x8_halfpel_h(h_ptr, n_ptr, edged_width2, rounding);  
                         interpolate8x8_halfpel_v(v_ptr, n_ptr, edged_width2, rounding);  
                         interpolate8x8_halfpel_hv(hv_ptr, n_ptr, edged_width2, rounding);  
   
                         n_ptr += 8;  
                         h_ptr += 8;  
                         v_ptr += 8;  
                         hv_ptr += 8;  
                 }  
                 h_ptr += stride_add2;  
                 v_ptr += stride_add2;  
                 hv_ptr += stride_add2;  
                 n_ptr += stride_add2;  
         }  
 #endif  
 */  
         /*  
            interpolate_halfpel_h(  
            refh->y - offset,  
            refn->y - offset,  
            edged_width, edged_height,  
            rounding);  
   
            interpolate_halfpel_v(  
            refv->y - offset,  
            refn->y - offset,  
            edged_width, edged_height,  
            rounding);  
   
            interpolate_halfpel_hv(  
            refhv->y - offset,  
            refn->y - offset,  
            edged_width, edged_height,  
            rounding);  
          */  
   
         /* uv-image-based compensation  
            offset = EDGE_SIZE2 * (edged_width / 2 + 1);  
   
            interpolate_halfpel_h(  
            refh->u - offset,  
            refn->u - offset,  
            edged_width / 2, edged_height / 2,  
            rounding);  
   
            interpolate_halfpel_v(  
            refv->u - offset,  
            refn->u - offset,  
            edged_width / 2, edged_height / 2,  
            rounding);  
   
            interpolate_halfpel_hv(  
            refhv->u - offset,  
            refn->u - offset,  
            edged_width / 2, edged_height / 2,  
            rounding);  
   
   
            interpolate_halfpel_h(  
            refh->v - offset,  
            refn->v - offset,  
            edged_width / 2, edged_height / 2,  
            rounding);  
   
            interpolate_halfpel_v(  
            refv->v - offset,  
            refn->v - offset,  
            edged_width / 2, edged_height / 2,  
            rounding);  
   
            interpolate_halfpel_hv(  
            refhv->v - offset,  
            refn->v - offset,  
            edged_width / 2, edged_height / 2,  
            rounding);  
          */  
331  }  }
332    
333    
# Line 596  Line 473 
473                          interlacing?abgri_to_yv12_c:abgr_to_yv12_c, 4);                          interlacing?abgri_to_yv12_c:abgr_to_yv12_c, 4);
474                  break;                  break;
475    
476            case XVID_CSP_RGB:
477                    safe_packed_conv(
478                            src[0], src_stride[0], image->y, image->u, image->v,
479                            edged_width, edged_width2, width, height, (csp & XVID_CSP_VFLIP),
480                            interlacing?rgbi_to_yv12  :rgb_to_yv12,
481                            interlacing?rgbi_to_yv12_c:rgb_to_yv12_c, 3);
482                    break;
483    
484          case XVID_CSP_RGBA :          case XVID_CSP_RGBA :
485                  safe_packed_conv(                  safe_packed_conv(
486                          src[0], src_stride[0], image->y, image->u, image->v,                          src[0], src_stride[0], image->y, image->u, image->v,
# Line 718  Line 603 
603                           int height,                           int height,
604                           uint32_t edged_width,                           uint32_t edged_width,
605                           uint8_t * dst[4],                           uint8_t * dst[4],
606                           uint32_t dst_stride[4],                           int dst_stride[4],
607                           int csp,                           int csp,
608                           int interlacing)                           int interlacing)
609  {  {
# Line 772  Line 657 
657                          interlacing?yv12_to_abgri_c:yv12_to_abgr_c, 4);                          interlacing?yv12_to_abgri_c:yv12_to_abgr_c, 4);
658                  return 0;                  return 0;
659    
660            case XVID_CSP_RGB:
661                    safe_packed_conv(
662                            dst[0], dst_stride[0], image->y, image->u, image->v,
663                            edged_width, edged_width2, width, height, (csp & XVID_CSP_VFLIP),
664                            interlacing?yv12_to_rgbi  :yv12_to_rgb,
665                            interlacing?yv12_to_rgbi_c:yv12_to_rgb_c, 3);
666                    return 0;
667    
668          case XVID_CSP_RGBA:          case XVID_CSP_RGBA:
669                  safe_packed_conv(                  safe_packed_conv(
670                          dst[0], dst_stride[0], image->y, image->u, image->v,                          dst[0], dst_stride[0], image->y, image->u, image->v,
# Line 899  Line 792 
792                     uint16_t width,                     uint16_t width,
793                     uint16_t height)                     uint16_t height)
794  {  {
795          int diff, x, y;          int y, bwidth, bheight;
796          long sse=0;          long sse=0;
797    
798          for (y = 0; y < height; y++) {          bwidth  = width  & (~0x07);
799            bheight = height & (~0x07);
800    
801            /* Compute the 8x8 integer part */
802            for (y = 0; y<bheight; y += 8) {
803                    int x;
804    
805                    /* Compute sse for the band */
806                    for (x = 0; x<bwidth; x += 8)
807                            sse += sse8_8bit(orig  + x, recon + x, stride);
808    
809                    /* remaining pixels of the 8 pixels high band */
810                    for (x = bwidth; x < width; x++) {
811                            int diff;
812                            diff = *(orig + 0*stride + x) - *(recon + 0*stride + x);
813                            sse += diff * diff;
814                            diff = *(orig + 1*stride + x) - *(recon + 1*stride + x);
815                            sse += diff * diff;
816                            diff = *(orig + 2*stride + x) - *(recon + 2*stride + x);
817                            sse += diff * diff;
818                            diff = *(orig + 3*stride + x) - *(recon + 3*stride + x);
819                            sse += diff * diff;
820                            diff = *(orig + 4*stride + x) - *(recon + 4*stride + x);
821                            sse += diff * diff;
822                            diff = *(orig + 5*stride + x) - *(recon + 5*stride + x);
823                            sse += diff * diff;
824                            diff = *(orig + 6*stride + x) - *(recon + 6*stride + x);
825                            sse += diff * diff;
826                            diff = *(orig + 7*stride + x) - *(recon + 7*stride + x);
827                            sse += diff * diff;
828                    }
829    
830                    orig  += 8*stride;
831                    recon += 8*stride;
832            }
833    
834            /* Compute the down rectangle sse */
835            for (y = bheight; y < height; y++) {
836                    int x;
837                  for (x = 0; x < width; x++) {                  for (x = 0; x < width; x++) {
838                            int diff;
839                          diff = *(orig + x) - *(recon + x);                          diff = *(orig + x) - *(recon + x);
840                          sse += diff * diff;                          sse += diff * diff;
841                  }                  }
842                  orig += stride;                  orig += stride;
843                  recon += stride;                  recon += stride;
844          }          }
845          return sse;  
846            return (sse);
847  }  }
848    
849  #if 0  #if 0
# Line 1039  Line 972 
972  }  }
973    
974  void  void
975  output_slice(IMAGE * cur, int std, int width, xvid_image_t* out_frm, int mbx, int mby,int mbl) {  output_slice(IMAGE * cur, int stride, int width, xvid_image_t* out_frm, int mbx, int mby,int mbl) {
976    uint8_t *dY,*dU,*dV,*sY,*sU,*sV;    uint8_t *dY,*dU,*dV,*sY,*sU,*sV;
977    int std2 = std >> 1;    int stride2 = stride >> 1;
978    int w = mbl << 4, w2,i;    int w = mbl << 4, w2,i;
979    
980    if(w > width)    if(w > width)
# Line 1051  Line 984 
984    dY = (uint8_t*)out_frm->plane[0] + (mby << 4) * out_frm->stride[0] + (mbx << 4);    dY = (uint8_t*)out_frm->plane[0] + (mby << 4) * out_frm->stride[0] + (mbx << 4);
985    dU = (uint8_t*)out_frm->plane[1] + (mby << 3) * out_frm->stride[1] + (mbx << 3);    dU = (uint8_t*)out_frm->plane[1] + (mby << 3) * out_frm->stride[1] + (mbx << 3);
986    dV = (uint8_t*)out_frm->plane[2] + (mby << 3) * out_frm->stride[2] + (mbx << 3);    dV = (uint8_t*)out_frm->plane[2] + (mby << 3) * out_frm->stride[2] + (mbx << 3);
987    sY = cur->y + (mby << 4) * std + (mbx << 4);    sY = cur->y + (mby << 4) * stride + (mbx << 4);
988    sU = cur->u + (mby << 3) * std2 + (mbx << 3);    sU = cur->u + (mby << 3) * stride2 + (mbx << 3);
989    sV = cur->v + (mby << 3) * std2 + (mbx << 3);    sV = cur->v + (mby << 3) * stride2 + (mbx << 3);
990    
991    for(i = 0 ; i < 16 ; i++) {    for(i = 0 ; i < 16 ; i++) {
992      memcpy(dY,sY,w);      memcpy(dY,sY,w);
993      dY += out_frm->stride[0];      dY += out_frm->stride[0];
994      sY += std;      sY += stride;
995    }    }
996    for(i = 0 ; i < 8 ; i++) {    for(i = 0 ; i < 8 ; i++) {
997      memcpy(dU,sU,w2);      memcpy(dU,sU,w2);
998      dU += out_frm->stride[1];      dU += out_frm->stride[1];
999      sU += std2;      sU += stride2;
1000    }    }
1001    for(i = 0 ; i < 8 ; i++) {    for(i = 0 ; i < 8 ; i++) {
1002      memcpy(dV,sV,w2);      memcpy(dV,sV,w2);
1003      dV += out_frm->stride[2];      dV += out_frm->stride[2];
1004      sV += std2;      sV += stride2;
1005    }    }
1006  }  }
1007    
# Line 1099  Line 1032 
1032          }          }
1033  }  }
1034    
1035    /****************************************************************************/
1036    
1037  /* reduced resolution deblocking filter  static void (*deintl_core)(uint8_t *, int width, int height, const int stride) = 0;
1038          block = block size (16=rrv, 8=full resolution)  extern void xvid_deinterlace_sse(uint8_t *, int width, int height, const int stride);
         flags = XVID_DEC_YDEBLOCK|XVID_DEC_UVDEBLOCK  
 */  
 void  
 image_deblock_rrv(IMAGE * img, int edged_width,  
                                 const MACROBLOCK * mbs, int mb_width, int mb_height, int mb_stride,  
                                 int block, int flags)  
 {  
         const int edged_width2 = edged_width /2;  
         const int nblocks = block / 8;  /* skals code uses 8pixel block uints */  
         int i,j;  
1039    
1040          /* luma: j,i in block units */  #define CLIP_255(x)   ( ((x)&~255) ? ((-(x)) >> (8*sizeof((x))-1))&0xff : (x) )
1041    
1042                  for (j = 1; j < mb_height*2; j++)               /* horizontal deblocking */  static void deinterlace_c(uint8_t *pix, int width, int height, const int bps)
                 for (i = 0; i < mb_width*2; i++)  
1043                  {                  {
1044                          if (mbs[(j-1)/2*mb_stride + (i/2)].mode != MODE_NOT_CODED ||    pix += bps;
1045                                  mbs[(j+0)/2*mb_stride + (i/2)].mode != MODE_NOT_CODED)    while(width-->0)
1046                          {                          {
1047                                  hfilter_31(img->y + (j*block - 1)*edged_width + i*block,      int p1 = pix[-bps];
1048                                                                    img->y + (j*block + 0)*edged_width + i*block, nblocks);      int p2 = pix[0];
1049                          }      int p0 = p2;
1050                  }      int j = (height>>1) - 1;
1051        int V;
1052                  for (j = 0; j < mb_height*2; j++)               /* vertical deblocking */      unsigned char *P = pix++;
1053                  for (i = 1; i < mb_width*2; i++)      while(j-->0)
1054                  {                  {
1055                          if (mbs[(j/2)*mb_stride + (i-1)/2].mode != MODE_NOT_CODED ||        const int  p3 = P[  bps];
1056                                  mbs[(j/2)*mb_stride + (i+0)/2].mode != MODE_NOT_CODED)        const int  p4 = P[2*bps];
1057                          {        V =  ((p1+p3+1)>>1) + ((p2 - ((p0+p4+1)>>1)) >> 2);
1058                                  vfilter_31(img->y + (j*block)*edged_width + i*block - 1,        P[0] = CLIP_255( V );
1059                                                     img->y + (j*block)*edged_width + i*block + 0,        p0 = p2;
1060                                                     edged_width, nblocks);        p1 = p3;
1061                          }        p2 = p4;
1062          P += 2*bps;
1063                  }                  }
1064        V =  ((p1+p1+1)>>1) + ((p2 - ((p0+p2+1)>>1)) >> 2);
1065        P[0] = CLIP_255( V );
   
         /* chroma */  
   
                 for (j = 1; j < mb_height; j++)         /* horizontal deblocking */  
                 for (i = 0; i < mb_width; i++)  
                 {  
                         if (mbs[(j-1)*mb_stride + i].mode != MODE_NOT_CODED ||  
                                 mbs[(j+0)*mb_stride + i].mode != MODE_NOT_CODED)  
                         {  
                                 hfilter_31(img->u + (j*block - 1)*edged_width2 + i*block,  
                                                    img->u + (j*block + 0)*edged_width2 + i*block, nblocks);  
                                 hfilter_31(img->v + (j*block - 1)*edged_width2 + i*block,  
                                                    img->v + (j*block + 0)*edged_width2 + i*block, nblocks);  
1066                          }                          }
1067                  }                  }
1068    #undef CLIP_255
1069    
1070                  for (j = 0; j < mb_height; j++)         /* vertical deblocking */  int xvid_image_deinterlace(xvid_image_t* img, int width, int height, int bottom_first)
                 for (i = 1; i < mb_width; i++)  
                 {  
                         if (mbs[j*mb_stride + i - 1].mode != MODE_NOT_CODED ||  
                                 mbs[j*mb_stride + i + 0].mode != MODE_NOT_CODED)  
1071                          {                          {
1072                                  vfilter_31(img->u + (j*block)*edged_width2 + i*block - 1,          if (height&1)
1073                                                     img->u + (j*block)*edged_width2 + i*block + 0,                  return 0;
1074                                                     edged_width2, nblocks);          if (img->csp!=XVID_CSP_PLANAR && img->csp!=XVID_CSP_I420 && img->csp!=XVID_CSP_YV12)
1075                                  vfilter_31(img->v + (j*block)*edged_width2 + i*block - 1,                  return 0;       /* not yet supported */
1076                                                     img->v + (j*block)*edged_width2 + i*block + 0,          if (deintl_core==0) {
1077                                                     edged_width2, nblocks);                  deintl_core = deinterlace_c;
1078    #if defined(ARCH_IS_IA32) || defined(ARCH_IS_X86_64)
1079                    {
1080                            int cpu_flags = check_cpu_features();
1081                            if (cpu_flags & XVID_CPU_MMX)
1082                                    deintl_core = xvid_deinterlace_sse;
1083                    }
1084    #endif
1085                          }                          }
1086            if (!bottom_first) {
1087                    deintl_core(img->plane[0], width,    height,    img->stride[0]);
1088                    deintl_core(img->plane[1], width>>1, height>>1, img->stride[1]);
1089                    deintl_core(img->plane[2], width>>1, height>>1, img->stride[2]);
1090            }
1091            else {
1092                    deintl_core((uint8_t *)img->plane[0] + ( height    -1)*img->stride[0], width,    height,    -img->stride[0]);
1093                    deintl_core((uint8_t *)img->plane[1] + ((height>>1)-1)*img->stride[1], width>>1, height>>1, -img->stride[1]);
1094                    deintl_core((uint8_t *)img->plane[2] + ((height>>1)-1)*img->stride[2], width>>1, height>>1, -img->stride[2]);
1095                  }                  }
1096            emms();
1097    
1098            return 1;
1099  }  }
1100    

Legend:
Removed from v.1397  
changed lines
  Added in v.1795

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4