[cvs] / xvidcore / src / image / image.c Repository:
ViewVC logotype

Diff of /xvidcore/src/image/image.c

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

revision 1.20.2.7, Thu Nov 7 10:28:15 2002 UTC revision 1.20.2.16, Sat Jan 25 22:44:50 2003 UTC
# Line 59  Line 59 
59  #include "image.h"  #include "image.h"
60  #include "colorspace.h"  #include "colorspace.h"
61  #include "interpolate8x8.h"  #include "interpolate8x8.h"
62    #include "reduced.h"
63  #include "../divx4.h"  #include "../divx4.h"
64  #include "../utils/mem_align.h"  #include "../utils/mem_align.h"
65    
# Line 323  Line 324 
324                                  h_ptr += 8;                                  h_ptr += 8;
325                          }                          }
326    
327                          hv_ptr += EDGE_SIZE2;                          hv_ptr += EDGE_SIZE;
328                          h_ptr += EDGE_SIZE2;                          h_ptr += EDGE_SIZE;
329    
330                          hv_ptr += stride_add;                          hv_ptr += stride_add;
331                          h_ptr += stride_add;                          h_ptr += stride_add;
# Line 475  Line 476 
476  }  }
477    
478    
479    /*
480    chroma optimize filter, invented by mf
481    a chroma pixel is average from the surrounding pixels, when the
482    correpsonding luma pixels are pure black or white.
483    */
484    
485    void
486    image_chroma_optimize(IMAGE * img, int width, int height, int edged_width)
487    {
488            int x,y;
489            int pixels = 0;
490    
491            for (y = 1; y < height/2 - 1; y++)
492            for (x = 1; x < width/2 - 1; x++)
493            {
494    #define IS_PURE(a)  ((a)<=16||(a)>=235)
495    #define IMG_Y(Y,X)      img->y[(Y)*edged_width + (X)]
496    #define IMG_U(Y,X)      img->u[(Y)*edged_width/2 + (X)]
497    #define IMG_V(Y,X)      img->v[(Y)*edged_width/2 + (X)]
498    
499                    if (IS_PURE(IMG_Y(y*2  ,x*2  )) &&
500                            IS_PURE(IMG_Y(y*2  ,x*2+1)) &&
501                            IS_PURE(IMG_Y(y*2+1,x*2  )) &&
502                            IS_PURE(IMG_Y(y*2+1,x*2+1)))
503                    {
504                            IMG_U(y,x) = (IMG_U(y,x-1) + IMG_U(y-1, x) + IMG_U(y, x+1) + IMG_U(y+1, x)) / 4;
505                            IMG_V(y,x) = (IMG_V(y,x-1) + IMG_V(y-1, x) + IMG_V(y, x+1) + IMG_V(y+1, x)) / 4;
506                            pixels++;
507                    }
508    
509    #undef IS_PURE
510    #undef IMG_Y
511    #undef IMG_U
512    #undef IMG_V
513            }
514    
515            DPRINTF(DPRINTF_DEBUG,"chroma_optimized_pixels = %i/%i", pixels, width*height/4);
516    }
517    
518    
519    
520    
521    
522  /*  /*
523    perform safe packed colorspace conversion, by splitting    perform safe packed colorspace conversion, by splitting
# Line 634  Line 677 
677    
678          case XVID_CSP_I420:          case XVID_CSP_I420:
679                  yv12_to_yv12(image->y, image->u, image->v, edged_width, edged_width2,                  yv12_to_yv12(image->y, image->u, image->v, edged_width, edged_width2,
680                          src, src + width*height, src + width*height + width2*height2,                          src, src + src_stride*height, src + src_stride*height + (src_stride/2)*height2,
681                          width, width2, width, height, (csp & XVID_CSP_VFLIP));                          src_stride, src_stride/2, width, height, (csp & XVID_CSP_VFLIP));
682                  break                  break
683                          ;                          ;
684          case XVID_CSP_YV12:             /* u/v swapped */          case XVID_CSP_YV12:             /* u/v swapped */
685                  yv12_to_yv12(image->y, image->v, image->u, edged_width, edged_width2,                  yv12_to_yv12(image->y, image->v, image->u, edged_width, edged_width2,
686                          src, src + width*height, src + width*height + width2*height2,                          src, src + src_stride*height, src + src_stride*height + (src_stride/2)*height2,
687                          width, width2, width, height, (csp & XVID_CSP_VFLIP));                          src_stride, src_stride/2, width, height, (csp & XVID_CSP_VFLIP));
688                  break;                  break;
689    
690          case XVID_CSP_USER:          case XVID_CSP_USER:
# Line 722  Line 765 
765                           int interlacing)                           int interlacing)
766  {  {
767          const int edged_width2 = edged_width/2;          const int edged_width2 = edged_width/2;
         int width2 = width/2;  
768          int height2 = height/2;          int height2 = height/2;
769    
770  /*  /*
# Line 831  Line 873 
873                  return 0;                  return 0;
874    
875          case XVID_CSP_I420:          case XVID_CSP_I420:
876                  yv12_to_yv12(dst, dst + width*height, dst + width*height + width2*height2,                  yv12_to_yv12(dst, dst + dst_stride*height, dst + dst_stride*height + (dst_stride/2)*height2,
877                          width, width2,                          dst_stride, dst_stride/2,
878                          image->y, image->u, image->v, edged_width, edged_width2,                          image->y, image->u, image->v, edged_width, edged_width2,
879                          width, height, (csp & XVID_CSP_VFLIP));                          width, height, (csp & XVID_CSP_VFLIP));
880                  return 0;                  return 0;
881    
882          case XVID_CSP_YV12:             // u,v swapped          case XVID_CSP_YV12:             // u,v swapped
883                  yv12_to_yv12(dst, dst + width*height, dst + width*height + width2*height2,                  yv12_to_yv12(dst, dst + dst_stride*height, dst + dst_stride*height + (dst_stride/2)*height2,
884                          width, width2,                          dst_stride, dst_stride/2,
885                          image->y, image->v, image->u, edged_width, edged_width2,                          image->y, image->v, image->u, edged_width, edged_width2,
886                          width, height, (csp & XVID_CSP_VFLIP));                          width, height, (csp & XVID_CSP_VFLIP));
887                  return 0;                  return 0;
# Line 896  Line 938 
938          return psnr_y;          return psnr_y;
939  }  }
940    
941    long plane_sse(uint8_t * orig,
942                       uint8_t * recon,
943                       uint16_t stride,
944                       uint16_t width,
945                       uint16_t height)
946    {
947            int diff, x, y;
948            long sse=0;
949    
950            for (y = 0; y < height; y++) {
951                    for (x = 0; x < width; x++) {
952                            diff = *(orig + x) - *(recon + x);
953                            sse += diff * diff;
954                    }
955                    orig += stride;
956                    recon += stride;
957            }
958            return sse;
959    }
960    
961  /*  /*
962    
963  #include <stdio.h>  #include <stdio.h>
# Line 992  Line 1054 
1054  }  }
1055    
1056    
 #define ABS(X)    (((X)>0)?(X):-(X))  
1057  float  float
1058  image_mad(const IMAGE * img1,  image_mad(const IMAGE * img1,
1059                    const IMAGE * img2,                    const IMAGE * img2,
# Line 1055  Line 1116 
1116      sV += std2;      sV += std2;
1117    }    }
1118  }  }
1119    
1120    
1121    void
1122    image_clear(IMAGE * img, int width, int height, int edged_width,
1123                                            int y, int u, int v)
1124    {
1125            uint8_t * p;
1126            int i;
1127    
1128            p = img->y;
1129            for (i = 0; i < height; i++) {
1130                    memset(p, y, width);
1131                    p += edged_width;
1132            }
1133    
1134            p = img->u;
1135            for (i = 0; i < height/2; i++) {
1136                    memset(p, u, width/2);
1137                    p += edged_width/2;
1138            }
1139    
1140            p = img->v;
1141            for (i = 0; i < height/2; i++) {
1142                    memset(p, v, width/2);
1143                    p += edged_width/2;
1144            }
1145    }
1146    
1147    
1148    /* reduced resolution deblocking filter
1149            block = block size (16=rrv, 8=full resolution)
1150            flags = XVID_DEC_YDEBLOCK|XVID_DEC_UVDEBLOCK
1151    */
1152    void
1153    image_deblock_rrv(IMAGE * img, int edged_width,
1154                                    const MACROBLOCK * mbs, int mb_width, int mb_height, int mb_stride,
1155                                    int block, int flags)
1156    {
1157            const int edged_width2 = edged_width /2;
1158            const int nblocks = block / 8;  /* skals code uses 8pixel block uints */
1159            int i,j;
1160    
1161            /* luma: j,i in block units */
1162            if ((flags & XVID_DEC_DEBLOCKY))
1163            {
1164                    for (j = 1; j < mb_height*2; j++)               /* horizontal deblocking */
1165                    for (i = 0; i < mb_width*2; i++)
1166                    {
1167                            if (mbs[(j-1)/2*mb_stride + (i/2)].mode != MODE_NOT_CODED ||
1168                                    mbs[(j+0)/2*mb_stride + (i/2)].mode != MODE_NOT_CODED)
1169                            {
1170                                    hfilter_31(img->y + (j*block - 1)*edged_width + i*block,
1171                                                                      img->y + (j*block + 0)*edged_width + i*block, nblocks);
1172                            }
1173                    }
1174    
1175                    for (j = 0; j < mb_height*2; j++)               /* vertical deblocking */
1176                    for (i = 1; i < mb_width*2; i++)
1177                    {
1178                            if (mbs[(j/2)*mb_stride + (i-1)/2].mode != MODE_NOT_CODED ||
1179                                    mbs[(j/2)*mb_stride + (i+0)/2].mode != MODE_NOT_CODED)
1180                            {
1181                                    vfilter_31(img->y + (j*block)*edged_width + i*block - 1,
1182                                                       img->y + (j*block)*edged_width + i*block + 0,
1183                                                       edged_width, nblocks);
1184                            }
1185                    }
1186            }
1187    
1188    
1189            /* chroma */
1190            if ((flags & XVID_DEC_DEBLOCKUV))
1191            {
1192                    for (j = 1; j < mb_height; j++)         /* horizontal deblocking */
1193                    for (i = 0; i < mb_width; i++)
1194                    {
1195                            if (mbs[(j-1)*mb_stride + i].mode != MODE_NOT_CODED ||
1196                                    mbs[(j+0)*mb_stride + i].mode != MODE_NOT_CODED)
1197                            {
1198                                    hfilter_31(img->u + (j*block - 1)*edged_width2 + i*block,
1199                                                       img->u + (j*block + 0)*edged_width2 + i*block, nblocks);
1200                                    hfilter_31(img->v + (j*block - 1)*edged_width2 + i*block,
1201                                                       img->v + (j*block + 0)*edged_width2 + i*block, nblocks);
1202                            }
1203                    }
1204    
1205                    for (j = 0; j < mb_height; j++)         /* vertical deblocking */
1206                    for (i = 1; i < mb_width; i++)
1207                    {
1208                            if (mbs[j*mb_stride + i - 1].mode != MODE_NOT_CODED ||
1209                                    mbs[j*mb_stride + i + 0].mode != MODE_NOT_CODED)
1210                            {
1211                                    vfilter_31(img->u + (j*block)*edged_width2 + i*block - 1,
1212                                                       img->u + (j*block)*edged_width2 + i*block + 0,
1213                                                       edged_width2, nblocks);
1214                                    vfilter_31(img->v + (j*block)*edged_width2 + i*block - 1,
1215                                                       img->v + (j*block)*edged_width2 + i*block + 0,
1216                                                       edged_width2, nblocks);
1217                            }
1218                    }
1219            }
1220    
1221    }
1222    
Legend:
Removed from v.1.20.2.7  
changed lines
  Added in v.1.20.2.16
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4