[svn] / branches / dev-api-4 / xvidcore / src / image / image.c Repository:
ViewVC logotype

Diff of /branches/dev-api-4/xvidcore/src/image/image.c

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

revision 1038, Thu May 22 16:36:07 2003 UTC revision 1257, Fri Dec 12 08:19:13 2003 UTC
# Line 1  Line 1 
1  /**************************************************************************  /**************************************************************************
2   *   *
3   *      XVID MPEG-4 VIDEO CODEC   *      XVID MPEG-4 VIDEO CODEC
4   *      image stuff   *  - Image management functions -
5   *   *
6   *      This program is an implementation of a part of one or more MPEG-4   *  Copyright(C) 2001-2003 Peter Ross <pross@xvid.org>
  *      Video tools as specified in ISO/IEC 14496-2 standard.  Those intending  
  *      to use this software module in hardware or software products are  
  *      advised that its use may infringe existing patents or copyrights, and  
  *      any such use would be at such party's own risk.  The original  
  *      developer of this software module and his/her company, and subsequent  
  *      editors and their companies, will have no liability for use of this  
  *      software or modifications or derivatives thereof.  
7   *   *
8   *      This program is free software; you can redistribute it and/or modify   *      This program is free software; you can redistribute it and/or modify
9   *      it under the terms of the GNU General Public License as published by   *      it under the terms of the GNU General Public License as published by
# Line 24  Line 17 
17   *   *
18   *      You should have received a copy of the GNU General Public License   *      You should have received a copy of the GNU General Public License
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., 675 Mass Ave, Cambridge, MA 02139, USA.   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21   *   *
22   *************************************************************************/   * $Id: image.c,v 1.26.2.12 2003-12-12 08:19:13 chl Exp $
   
 /**************************************************************************  
  *  
  *      History:  
23   *   *
24   *  05.10.2002  support for interpolated images in qpel mode - Isibaar   ****************************************************************************/
  *      01.05.2002      BFRAME image-based u,v interpolation  
  *  22.04.2002  added some B-frame support  
  *      14.04.2002      added image_dump_yuvpgm(), added image_mad()  
  *              XVID_CSP_USER input support  
  *  09.04.2002  PSNR calculations - Isibaar  
  *      06.04.2002      removed interlaced edging from U,V blocks (as per spec)  
  *  26.03.2002  interlacing support (field-based edging in set_edges)  
  *      26.01.2002      rgb555, rgb565  
  *      07.01.2001      commented u,v interpolation (not required for uv-block-based)  
  *  23.12.2001  removed #ifdefs, added function pointers + init_common()  
  *      22.12.2001      cpu #ifdefs  
  *  19.12.2001  image_dump(); useful for debugging  
  *       6.12.2001      inital version; (c)2001 peter ross <pross@cs.rmit.edu.au>  
  *  
  *************************************************************************/  
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    
30  #include "../portab.h"  #include "../portab.h"
31  #include "../global.h"                  // XVID_CSP_XXX's  #include "../global.h"                  /* XVID_CSP_XXX's */
32  #include "../xvid.h"                    // XVID_CSP_XXX's  #include "../xvid.h"                    /* XVID_CSP_XXX's */
33  #include "image.h"  #include "image.h"
34  #include "colorspace.h"  #include "colorspace.h"
35  #include "interpolate8x8.h"  #include "interpolate8x8.h"
36  #include "reduced.h"  #include "reduced.h"
37  #include "../utils/mem_align.h"  #include "../utils/mem_align.h"
38    
39  #include "font.h"               // XXX: remove later  #include "font.h"               /* XXX: remove later */
40    
41  #define SAFETY  64  #define SAFETY  64
42  #define EDGE_SIZE2  (EDGE_SIZE/2)  #define EDGE_SIZE2  (EDGE_SIZE/2)
# Line 75  Line 49 
49  {  {
50          const uint32_t edged_width2 = edged_width / 2;          const uint32_t edged_width2 = edged_width / 2;
51          const uint32_t edged_height2 = edged_height / 2;          const uint32_t edged_height2 = edged_height / 2;
         uint32_t i;  
52    
53          image->y =          image->y =
54                  xvid_malloc(edged_width * (edged_height + 1) + SAFETY, CACHE_LINE);                  xvid_malloc(edged_width * (edged_height + 1) + SAFETY, CACHE_LINE);
55          if (image->y == NULL) {          if (image->y == NULL) {
56                  return -1;                  return -1;
57          }          }
58            memset(image->y, 0, edged_width * (edged_height + 1) + SAFETY);
         for (i = 0; i < edged_width * edged_height + SAFETY; i++) {  
                 image->y[i] = 0;  
         }  
59    
60          image->u = xvid_malloc(edged_width2 * edged_height2 + SAFETY, CACHE_LINE);          image->u = xvid_malloc(edged_width2 * edged_height2 + SAFETY, CACHE_LINE);
61          if (image->u == NULL) {          if (image->u == NULL) {
62                  xvid_free(image->y);                  xvid_free(image->y);
63                    image->y = NULL;
64                  return -1;                  return -1;
65          }          }
66            memset(image->u, 0, edged_width2 * edged_height2 + SAFETY);
67    
68          image->v = xvid_malloc(edged_width2 * edged_height2 + SAFETY, CACHE_LINE);          image->v = xvid_malloc(edged_width2 * edged_height2 + SAFETY, CACHE_LINE);
69          if (image->v == NULL) {          if (image->v == NULL) {
70                  xvid_free(image->u);                  xvid_free(image->u);
71                    image->u = NULL;
72                  xvid_free(image->y);                  xvid_free(image->y);
73                    image->y = NULL;
74                  return -1;                  return -1;
75          }          }
76            memset(image->v, 0, edged_width2 * edged_height2 + SAFETY);
77    
78          image->y += EDGE_SIZE * edged_width + EDGE_SIZE;          image->y += EDGE_SIZE * edged_width + EDGE_SIZE;
79          image->u += EDGE_SIZE2 * edged_width2 + EDGE_SIZE2;          image->u += EDGE_SIZE2 * edged_width2 + EDGE_SIZE2;
# Line 117  Line 93 
93    
94          if (image->y) {          if (image->y) {
95                  xvid_free(image->y - (EDGE_SIZE * edged_width + EDGE_SIZE));                  xvid_free(image->y - (EDGE_SIZE * edged_width + EDGE_SIZE));
96                    image->y = NULL;
97          }          }
98          if (image->u) {          if (image->u) {
99                  xvid_free(image->u - (EDGE_SIZE2 * edged_width2 + EDGE_SIZE2));                  xvid_free(image->u - (EDGE_SIZE2 * edged_width2 + EDGE_SIZE2));
100                    image->u = NULL;
101          }          }
102          if (image->v) {          if (image->v) {
103                  xvid_free(image->v - (EDGE_SIZE2 * edged_width2 + EDGE_SIZE2));                  xvid_free(image->v - (EDGE_SIZE2 * edged_width2 + EDGE_SIZE2));
104                    image->v = NULL;
105          }          }
106  }  }
107    
# Line 157  Line 136 
136                             uint32_t height)                             uint32_t height)
137  {  {
138          const uint32_t edged_width2 = edged_width / 2;          const uint32_t edged_width2 = edged_width / 2;
139          const uint32_t width2 = width / 2;          uint32_t width2;
140          uint32_t i;          uint32_t i;
141          uint8_t *dst;          uint8_t *dst;
142          uint8_t *src;          uint8_t *src;
# Line 166  Line 145 
145          dst = image->y - (EDGE_SIZE + EDGE_SIZE * edged_width);          dst = image->y - (EDGE_SIZE + EDGE_SIZE * edged_width);
146          src = image->y;          src = image->y;
147    
148            /* According to the Standard Clause 7.6.4, padding is done starting at 16
149             * pixel width and height multiples */
150            width  = (width+15)&~15;
151            height = (height+15)&~15;
152            width2 = width/2;
153    
154          for (i = 0; i < EDGE_SIZE; i++) {          for (i = 0; i < EDGE_SIZE; i++) {
155                  memset(dst, *src, EDGE_SIZE);                  memset(dst, *src, EDGE_SIZE);
156                  memcpy(dst + EDGE_SIZE, src, width);                  memcpy(dst + EDGE_SIZE, src, width);
# Line 191  Line 176 
176          }          }
177    
178    
179  //U          /* U */
180          dst = image->u - (EDGE_SIZE2 + EDGE_SIZE2 * edged_width2);          dst = image->u - (EDGE_SIZE2 + EDGE_SIZE2 * edged_width2);
181          src = image->u;          src = image->u;
182    
# Line 219  Line 204 
204          }          }
205    
206    
207  // V          /* V */
208          dst = image->v - (EDGE_SIZE2 + EDGE_SIZE2 * edged_width2);          dst = image->v - (EDGE_SIZE2 + EDGE_SIZE2 * edged_width2);
209          src = image->v;          src = image->v;
210    
# Line 247  Line 232 
232          }          }
233  }  }
234    
235  // bframe encoding requires image-based u,v interpolation  /* bframe encoding requires image-based u,v interpolation */
236  void  void
237  image_interpolate(const IMAGE * refn,  image_interpolate(const IMAGE * refn,
238                                    IMAGE * refh,                                    IMAGE * refh,
# Line 258  Line 243 
243                                    uint32_t quarterpel,                                    uint32_t quarterpel,
244                                    uint32_t rounding)                                    uint32_t rounding)
245  {  {
246          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 */
247          const uint32_t stride_add = 7 * edged_width;          const uint32_t stride_add = 7 * edged_width;
248  /*  #if 0
 #ifdef BFRAMES  
249          const uint32_t edged_width2 = edged_width / 2;          const uint32_t edged_width2 = edged_width / 2;
250          const uint32_t edged_height2 = edged_height / 2;          const uint32_t edged_height2 = edged_height / 2;
251          const uint32_t offset2 = EDGE_SIZE2 * (edged_width2 + 1);          const uint32_t offset2 = EDGE_SIZE2 * (edged_width2 + 1);
252          const uint32_t stride_add2 = 7 * edged_width2;          const uint32_t stride_add2 = 7 * edged_width2;
253  #endif  #endif
 */  
254          uint8_t *n_ptr, *h_ptr, *v_ptr, *hv_ptr;          uint8_t *n_ptr, *h_ptr, *v_ptr, *hv_ptr;
255          uint32_t x, y;          uint32_t x, y;
256    
# Line 275  Line 258 
258          n_ptr = refn->y;          n_ptr = refn->y;
259          h_ptr = refh->y;          h_ptr = refh->y;
260          v_ptr = refv->y;          v_ptr = refv->y;
         hv_ptr = refhv->y;  
261    
262          n_ptr -= offset;          n_ptr -= offset;
263          h_ptr -= offset;          h_ptr -= offset;
264          v_ptr -= offset;          v_ptr -= offset;
         hv_ptr -= offset;  
265    
266            /* Note we initialize the hv pointer later, as we can optimize code a bit
267             * doing it down to up in quarterpel and up to down in halfpel */
268          if(quarterpel) {          if(quarterpel) {
269    
270                  for (y = 0; y < (edged_height - EDGE_SIZE); y += 8) {                  for (y = 0; y < (edged_height - EDGE_SIZE); y += 8) {
# Line 303  Line 286 
286                          n_ptr += stride_add;                          n_ptr += stride_add;
287                  }                  }
288    
289                  h_ptr = refh->y;                  h_ptr = refh->y + (edged_height - EDGE_SIZE - EDGE_SIZE2)*edged_width - EDGE_SIZE2;
290                  h_ptr -= offset;                  hv_ptr = refhv->y + (edged_height - EDGE_SIZE - EDGE_SIZE2)*edged_width - EDGE_SIZE2;
291    
292                  for (y = 0; y < (edged_height - EDGE_SIZE); y = y + 8) {                  for (y = 0; y < (edged_height - EDGE_SIZE); y = y + 8) {
293                            hv_ptr -= stride_add;
294                            h_ptr -= stride_add;
295                            hv_ptr -= EDGE_SIZE;
296                            h_ptr -= EDGE_SIZE;
297    
298                          for (x = 0; x < (edged_width - EDGE_SIZE); x = x + 8) {                          for (x = 0; x < (edged_width - EDGE_SIZE); x = x + 8) {
299                                    hv_ptr -= 8;
300                                    h_ptr -= 8;
301                                  interpolate8x8_6tap_lowpass_v(hv_ptr, h_ptr, edged_width, rounding);                                  interpolate8x8_6tap_lowpass_v(hv_ptr, h_ptr, edged_width, rounding);
                                 hv_ptr += 8;  
                                 h_ptr += 8;  
                         }  
   
                         hv_ptr += EDGE_SIZE;  
                         h_ptr += EDGE_SIZE;  
   
                         hv_ptr += stride_add;  
                         h_ptr += stride_add;  
302                  }                  }
303          }          }
304          else {          } else {
305    
306                    hv_ptr = refhv->y;
307                    hv_ptr -= offset;
308    
309                  for (y = 0; y < (edged_height - EDGE_SIZE); y += 8) {                  for (y = 0; y < (edged_height - EDGE_SIZE); y += 8) {
310                          for (x = 0; x < (edged_width - EDGE_SIZE); x += 8) {                          for (x = 0; x < (edged_width - EDGE_SIZE); x += 8) {
# Line 561  Line 545 
545          const int edged_width2 = edged_width/2;          const int edged_width2 = edged_width/2;
546          const int width2 = width/2;          const int width2 = width/2;
547          const int height2 = height/2;          const int height2 = height/2;
548          //const int height_signed = (csp & XVID_CSP_VFLIP) ? -height : height;  #if 0
549            const int height_signed = (csp & XVID_CSP_VFLIP) ? -height : height;
550    #endif
551    
552          switch (csp & ~XVID_CSP_VFLIP) {          switch (csp & ~XVID_CSP_VFLIP) {
553          case XVID_CSP_RGB555:          case XVID_CSP_RGB555:
# Line 637  Line 623 
623                          interlacing?uyvyi_to_yv12_c:uyvy_to_yv12_c, 2);                          interlacing?uyvyi_to_yv12_c:uyvy_to_yv12_c, 2);
624                  break;                  break;
625    
626          case XVID_CSP_I420:          case XVID_CSP_I420: /* YCrCb == internal colorspace for MPEG */
627                  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,
628                          src[0], src[0] + src_stride[0]*height, src[0] + src_stride[0]*height + (src_stride[0]/2)*height2,                          src[0], src[0] + src_stride[0]*height, src[0] + src_stride[0]*height + (src_stride[0]/2)*height2,
629                          src_stride[0], src_stride[0]/2, width, height, (csp & XVID_CSP_VFLIP));                          src_stride[0], src_stride[0]/2, width, height, (csp & XVID_CSP_VFLIP));
630                  break                  break;
631                          ;  
632          case XVID_CSP_YV12:             /* u/v swapped */          case XVID_CSP_YV12:     /* YCbCr == U and V plane swapped */
633                  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,
634                          src[0], src[0] + src_stride[0]*height, src[0] + src_stride[0]*height + (src_stride[0]/2)*height2,                          src[0], src[0] + src_stride[0]*height, src[0] + src_stride[0]*height + (src_stride[0]/2)*height2,
635                          src_stride[0], src_stride[0]/2, width, height, (csp & XVID_CSP_VFLIP));                          src_stride[0], src_stride[0]/2, width, height, (csp & XVID_CSP_VFLIP));
636                  break;                  break;
637    
638          case XVID_CSP_USER:          case XVID_CSP_USER :  /* YCrCb with arbitrary pointers and different strides for Y and UV */
         /*XXX: support for different u & v strides */  
639                  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,
640                          src[0], src[1], src[2], src_stride[0], src_stride[1],                          src[0], src[1], src[2], src_stride[0], src_stride[1],  /* v: dst_stride[2] not yet supported */
641                          width, height, (csp & XVID_CSP_VFLIP));                          width, height, (csp & XVID_CSP_VFLIP));
642                  break;                  break;
643    
# Line 790  Line 775 
775                          interlacing?yv12_to_yuyvi_c:yv12_to_yuyv_c, 2);                          interlacing?yv12_to_yuyvi_c:yv12_to_yuyv_c, 2);
776                  return 0;                  return 0;
777    
778          case XVID_CSP_YVYU:             // u,v swapped          case XVID_CSP_YVYU:             /* u,v swapped */
779                  safe_packed_conv(                  safe_packed_conv(
780                          dst[0], dst_stride[0], image->y, image->v, image->u,                          dst[0], dst_stride[0], image->y, image->v, image->u,
781                          edged_width, edged_width2, width, height, (csp & XVID_CSP_VFLIP),                          edged_width, edged_width2, width, height, (csp & XVID_CSP_VFLIP),
# Line 806  Line 791 
791                          interlacing?yv12_to_uyvyi_c:yv12_to_uyvy_c, 2);                          interlacing?yv12_to_uyvyi_c:yv12_to_uyvy_c, 2);
792                  return 0;                  return 0;
793    
794          case XVID_CSP_I420:          case XVID_CSP_I420: /* YCrCb == internal colorspace for MPEG */
795                  yv12_to_yv12(dst[0], dst[0] + dst_stride[0]*height, dst[0] + dst_stride[0]*height + (dst_stride[0]/2)*height2,                  yv12_to_yv12(dst[0], dst[0] + dst_stride[0]*height, dst[0] + dst_stride[0]*height + (dst_stride[0]/2)*height2,
796                          dst_stride[0], dst_stride[0]/2,                          dst_stride[0], dst_stride[0]/2,
797                          image->y, image->u, image->v, edged_width, edged_width2,                          image->y, image->u, image->v, edged_width, edged_width2,
798                          width, height, (csp & XVID_CSP_VFLIP));                          width, height, (csp & XVID_CSP_VFLIP));
799                  return 0;                  return 0;
800    
801          case XVID_CSP_YV12:             // u,v swapped          case XVID_CSP_YV12:     /* YCbCr == U and V plane swapped */
802                  yv12_to_yv12(dst[0], dst[0] + dst_stride[0]*height, dst[0] + dst_stride[0]*height + (dst_stride[0]/2)*height2,                  yv12_to_yv12(dst[0], dst[0] + dst_stride[0]*height, dst[0] + dst_stride[0]*height + (dst_stride[0]/2)*height2,
803                          dst_stride[0], dst_stride[0]/2,                          dst_stride[0], dst_stride[0]/2,
804                          image->y, image->v, image->u, edged_width, edged_width2,                          image->y, image->v, image->u, edged_width, edged_width2,
805                          width, height, (csp & XVID_CSP_VFLIP));                          width, height, (csp & XVID_CSP_VFLIP));
806                  return 0;                  return 0;
807    
808          case XVID_CSP_USER :            // u,v swapped          case XVID_CSP_USER :  /* YCrCb with arbitrary pointers and different strides for Y and UV */
809                  yv12_to_yv12(dst[0], dst[1], dst[2],                  yv12_to_yv12(dst[0], dst[1], dst[2],
810                          dst_stride[0], dst_stride[1],   /* v: dst_stride[2] */                          dst_stride[0], dst_stride[1],   /* v: dst_stride[2] not yet supported */
811                          image->y, image->v, image->u, edged_width, edged_width2,                          image->y, image->u, image->v, edged_width, edged_width2,
812                          width, height, (csp & XVID_CSP_VFLIP));                          width, height, (csp & XVID_CSP_VFLIP));
813                  return 0;                  return 0;
814    
# Line 883  Line 868 
868          if (sse==0)          if (sse==0)
869                  return 99.99F;                  return 99.99F;
870    
871          return 48.131F - 10*(float)log10((float)sse/(float)(pixels));   // log10(255*255)=4.8131          return 48.131F - 10*(float)log10((float)sse/(float)(pixels));   /* log10(255*255)=4.8131 */
872    
873  }  }
874    
# Line 907  Line 892 
892          return sse;          return sse;
893  }  }
894    
895  /*  #if 0
896    
897  #include <stdio.h>  #include <stdio.h>
898  #include <string.h>  #include <string.h>
# Line 931  Line 916 
916  }  }
917    
918    
919  // dump image+edges to yuv pgm files  /* dump image+edges to yuv pgm files */
920    
921  int image_dump(IMAGE * image, uint32_t edged_width, uint32_t edged_height, char * path, int number)  int image_dump(IMAGE * image, uint32_t edged_width, uint32_t edged_height, char * path, int number)
922  {  {
# Line 954  Line 939 
939    
940          return 0;          return 0;
941  }  }
942  */  #endif
943    
944    
945    
Legend:
Removed from v.1038  
changed lines
  Added in v.1257
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4