git.sesse.net Git - ffmpeg/blob - libavcodec/imgresample.c

   1 /*
   2  * High quality image resampling with polyphase filters
   3  * Copyright (c) 2001 Fabrice Bellard.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 /**
  21  * @file imgresample.c
  22  * High quality image resampling with polyphase filters .
  23  */
  24
  25 #include "avcodec.h"
  26 #include "dsputil.h"
  27
  28 #ifdef USE_FASTMEMCPY
  29 #include "fastmemcpy.h"
  30 #endif
  31
  32 #define NB_COMPONENTS 3
  33
  34 #define PHASE_BITS 4
  35 #define NB_PHASES  (1 << PHASE_BITS)
  36 #define NB_TAPS    4
  37 #define FCENTER    1  /* index of the center of the filter */
  38 //#define TEST    1  /* Test it */
  39
  40 #define POS_FRAC_BITS 16
  41 #define POS_FRAC      (1 << POS_FRAC_BITS)
  42 /* 6 bits precision is needed for MMX */
  43 #define FILTER_BITS   8
  44
  45 #define LINE_BUF_HEIGHT (NB_TAPS * 4)
  46
  47 struct ImgReSampleContext {
  48     int iwidth, iheight, owidth, oheight;
  49     int topBand, bottomBand, leftBand, rightBand;
  50     int padtop, padbottom, padleft, padright;
  51     int pad_owidth, pad_oheight;
  52     int h_incr, v_incr;
  53     int16_t h_filters[NB_PHASES][NB_TAPS] __align8; /* horizontal filters */
  54     int16_t v_filters[NB_PHASES][NB_TAPS] __align8; /* vertical filters */
  55     uint8_t *line_buf;
  56 };
  57
  58 void av_build_filter(int16_t *filter, double factor, int tap_count, int phase_count, int scale, int type);
  59
  60 static inline int get_phase(int pos)
  61 {
  62     return ((pos) >> (POS_FRAC_BITS - PHASE_BITS)) & ((1 << PHASE_BITS) - 1);
  63 }
  64
  65 /* This function must be optimized */
  66 static void h_resample_fast(uint8_t *dst, int dst_width, const uint8_t *src,
  67                             int src_width, int src_start, int src_incr,
  68                             int16_t *filters)
  69 {
  70     int src_pos, phase, sum, i;
  71     const uint8_t *s;
  72     int16_t *filter;
  73
  74     src_pos = src_start;
  75     for(i=0;i<dst_width;i++) {
  76 #ifdef TEST
  77         /* test */
  78         if ((src_pos >> POS_FRAC_BITS) < 0 ||
  79             (src_pos >> POS_FRAC_BITS) > (src_width - NB_TAPS))
  80             av_abort();
  81 #endif
  82         s = src + (src_pos >> POS_FRAC_BITS);
  83         phase = get_phase(src_pos);
  84         filter = filters + phase * NB_TAPS;
  85 #if NB_TAPS == 4
  86         sum = s[0] * filter[0] +
  87             s[1] * filter[1] +
  88             s[2] * filter[2] +
  89             s[3] * filter[3];
  90 #else
  91         {
  92             int j;
  93             sum = 0;
  94             for(j=0;j<NB_TAPS;j++)
  95                 sum += s[j] * filter[j];
  96         }
  97 #endif
  98         sum = sum >> FILTER_BITS;
  99         if (sum < 0)
 100             sum = 0;
 101         else if (sum > 255)
 102             sum = 255;
 103         dst[0] = sum;
 104         src_pos += src_incr;
 105         dst++;
 106     }
 107 }
 108
 109 /* This function must be optimized */
 110 static void v_resample(uint8_t *dst, int dst_width, const uint8_t *src,
 111                        int wrap, int16_t *filter)
 112 {
 113     int sum, i;
 114     const uint8_t *s;
 115
 116     s = src;
 117     for(i=0;i<dst_width;i++) {
 118 #if NB_TAPS == 4
 119         sum = s[0 * wrap] * filter[0] +
 120             s[1 * wrap] * filter[1] +
 121             s[2 * wrap] * filter[2] +
 122             s[3 * wrap] * filter[3];
 123 #else
 124         {
 125             int j;
 126             uint8_t *s1 = s;
 127
 128             sum = 0;
 129             for(j=0;j<NB_TAPS;j++) {
 130                 sum += s1[0] * filter[j];
 131                 s1 += wrap;
 132             }
 133         }
 134 #endif
 135         sum = sum >> FILTER_BITS;
 136         if (sum < 0)
 137             sum = 0;
 138         else if (sum > 255)
 139             sum = 255;
 140         dst[0] = sum;
 141         dst++;
 142         s++;
 143     }
 144 }
 145
 146 #ifdef HAVE_MMX
 147
 148 #include "i386/mmx.h"
 149
 150 #define FILTER4(reg) \
 151 {\
 152         s = src + (src_pos >> POS_FRAC_BITS);\
 153         phase = get_phase(src_pos);\
 154         filter = filters + phase * NB_TAPS;\
 155         movq_m2r(*s, reg);\
 156         punpcklbw_r2r(mm7, reg);\
 157         movq_m2r(*filter, mm6);\
 158         pmaddwd_r2r(reg, mm6);\
 159         movq_r2r(mm6, reg);\
 160         psrlq_i2r(32, reg);\
 161         paddd_r2r(mm6, reg);\
 162         psrad_i2r(FILTER_BITS, reg);\
 163         src_pos += src_incr;\
 164 }
 165
 166 #define DUMP(reg) movq_r2m(reg, tmp); printf(#reg "=%016Lx\n", tmp.uq);
 167
 168 /* XXX: do four pixels at a time */
 169 static void h_resample_fast4_mmx(uint8_t *dst, int dst_width,
 170                                  const uint8_t *src, int src_width,
 171                                  int src_start, int src_incr, int16_t *filters)
 172 {
 173     int src_pos, phase;
 174     const uint8_t *s;
 175     int16_t *filter;
 176     mmx_t tmp;
 177
 178     src_pos = src_start;
 179     pxor_r2r(mm7, mm7);
 180
 181     while (dst_width >= 4) {
 182
 183         FILTER4(mm0);
 184         FILTER4(mm1);
 185         FILTER4(mm2);
 186         FILTER4(mm3);
 187
 188         packuswb_r2r(mm7, mm0);
 189         packuswb_r2r(mm7, mm1);
 190         packuswb_r2r(mm7, mm3);
 191         packuswb_r2r(mm7, mm2);
 192         movq_r2m(mm0, tmp);
 193         dst[0] = tmp.ub[0];
 194         movq_r2m(mm1, tmp);
 195         dst[1] = tmp.ub[0];
 196         movq_r2m(mm2, tmp);
 197         dst[2] = tmp.ub[0];
 198         movq_r2m(mm3, tmp);
 199         dst[3] = tmp.ub[0];
 200         dst += 4;
 201         dst_width -= 4;
 202     }
 203     while (dst_width > 0) {
 204         FILTER4(mm0);
 205         packuswb_r2r(mm7, mm0);
 206         movq_r2m(mm0, tmp);
 207         dst[0] = tmp.ub[0];
 208         dst++;
 209         dst_width--;
 210     }
 211     emms();
 212 }
 213
 214 static void v_resample4_mmx(uint8_t *dst, int dst_width, const uint8_t *src,
 215                             int wrap, int16_t *filter)
 216 {
 217     int sum, i, v;
 218     const uint8_t *s;
 219     mmx_t tmp;
 220     mmx_t coefs[4];
 221
 222     for(i=0;i<4;i++) {
 223         v = filter[i];
 224         coefs[i].uw[0] = v;
 225         coefs[i].uw[1] = v;
 226         coefs[i].uw[2] = v;
 227         coefs[i].uw[3] = v;
 228     }
 229
 230     pxor_r2r(mm7, mm7);
 231     s = src;
 232     while (dst_width >= 4) {
 233         movq_m2r(s[0 * wrap], mm0);
 234         punpcklbw_r2r(mm7, mm0);
 235         movq_m2r(s[1 * wrap], mm1);
 236         punpcklbw_r2r(mm7, mm1);
 237         movq_m2r(s[2 * wrap], mm2);
 238         punpcklbw_r2r(mm7, mm2);
 239         movq_m2r(s[3 * wrap], mm3);
 240         punpcklbw_r2r(mm7, mm3);
 241
 242         pmullw_m2r(coefs[0], mm0);
 243         pmullw_m2r(coefs[1], mm1);
 244         pmullw_m2r(coefs[2], mm2);
 245         pmullw_m2r(coefs[3], mm3);
 246
 247         paddw_r2r(mm1, mm0);
 248         paddw_r2r(mm3, mm2);
 249         paddw_r2r(mm2, mm0);
 250         psraw_i2r(FILTER_BITS, mm0);
 251
 252         packuswb_r2r(mm7, mm0);
 253         movq_r2m(mm0, tmp);
 254
 255         *(uint32_t *)dst = tmp.ud[0];
 256         dst += 4;
 257         s += 4;
 258         dst_width -= 4;
 259     }
 260     while (dst_width > 0) {
 261         sum = s[0 * wrap] * filter[0] +
 262             s[1 * wrap] * filter[1] +
 263             s[2 * wrap] * filter[2] +
 264             s[3 * wrap] * filter[3];
 265         sum = sum >> FILTER_BITS;
 266         if (sum < 0)
 267             sum = 0;
 268         else if (sum > 255)
 269             sum = 255;
 270         dst[0] = sum;
 271         dst++;
 272         s++;
 273         dst_width--;
 274     }
 275     emms();
 276 }
 277 #endif
 278
 279 #ifdef HAVE_ALTIVEC
 280 typedef union {
 281     vector unsigned char v;
 282     unsigned char c[16];
 283 } vec_uc_t;
 284
 285 typedef union {
 286     vector signed short v;
 287     signed short s[8];
 288 } vec_ss_t;
 289
 290 void v_resample16_altivec(uint8_t *dst, int dst_width, const uint8_t *src,
 291                           int wrap, int16_t *filter)
 292 {
 293     int sum, i;
 294     const uint8_t *s;
 295     vector unsigned char *tv, tmp, dstv, zero;
 296     vec_ss_t srchv[4], srclv[4], fv[4];
 297     vector signed short zeros, sumhv, sumlv;
 298     s = src;
 299
 300     for(i=0;i<4;i++)
 301     {
 302         /*
 303            The vec_madds later on does an implicit >>15 on the result.
 304            Since FILTER_BITS is 8, and we have 15 bits of magnitude in
 305            a signed short, we have just enough bits to pre-shift our
 306            filter constants <<7 to compensate for vec_madds.
 307         */
 308         fv[i].s[0] = filter[i] << (15-FILTER_BITS);
 309         fv[i].v = vec_splat(fv[i].v, 0);
 310     }
 311
 312     zero = vec_splat_u8(0);
 313     zeros = vec_splat_s16(0);
 314
 315
 316     /*
 317        When we're resampling, we'd ideally like both our input buffers,
 318        and output buffers to be 16-byte aligned, so we can do both aligned
 319        reads and writes. Sadly we can't always have this at the moment, so
 320        we opt for aligned writes, as unaligned writes have a huge overhead.
 321        To do this, do enough scalar resamples to get dst 16-byte aligned.
 322     */
 323     i = (-(int)dst) & 0xf;
 324     while(i>0) {
 325         sum = s[0 * wrap] * filter[0] +
 326         s[1 * wrap] * filter[1] +
 327         s[2 * wrap] * filter[2] +
 328         s[3 * wrap] * filter[3];
 329         sum = sum >> FILTER_BITS;
 330         if (sum<0) sum = 0; else if (sum>255) sum=255;
 331         dst[0] = sum;
 332         dst++;
 333         s++;
 334         dst_width--;
 335         i--;
 336     }
 337
 338     /* Do our altivec resampling on 16 pixels at once. */
 339     while(dst_width>=16) {
 340         /*
 341            Read 16 (potentially unaligned) bytes from each of
 342            4 lines into 4 vectors, and split them into shorts.
 343            Interleave the multipy/accumulate for the resample
 344            filter with the loads to hide the 3 cycle latency
 345            the vec_madds have.
 346         */
 347         tv = (vector unsigned char *) &s[0 * wrap];
 348         tmp = vec_perm(tv[0], tv[1], vec_lvsl(0, &s[i * wrap]));
 349         srchv[0].v = (vector signed short) vec_mergeh(zero, tmp);
 350         srclv[0].v = (vector signed short) vec_mergel(zero, tmp);
 351         sumhv = vec_madds(srchv[0].v, fv[0].v, zeros);
 352         sumlv = vec_madds(srclv[0].v, fv[0].v, zeros);
 353
 354         tv = (vector unsigned char *) &s[1 * wrap];
 355         tmp = vec_perm(tv[0], tv[1], vec_lvsl(0, &s[1 * wrap]));
 356         srchv[1].v = (vector signed short) vec_mergeh(zero, tmp);
 357         srclv[1].v = (vector signed short) vec_mergel(zero, tmp);
 358         sumhv = vec_madds(srchv[1].v, fv[1].v, sumhv);
 359         sumlv = vec_madds(srclv[1].v, fv[1].v, sumlv);
 360
 361         tv = (vector unsigned char *) &s[2 * wrap];
 362         tmp = vec_perm(tv[0], tv[1], vec_lvsl(0, &s[2 * wrap]));
 363         srchv[2].v = (vector signed short) vec_mergeh(zero, tmp);
 364         srclv[2].v = (vector signed short) vec_mergel(zero, tmp);
 365         sumhv = vec_madds(srchv[2].v, fv[2].v, sumhv);
 366         sumlv = vec_madds(srclv[2].v, fv[2].v, sumlv);
 367
 368         tv = (vector unsigned char *) &s[3 * wrap];
 369         tmp = vec_perm(tv[0], tv[1], vec_lvsl(0, &s[3 * wrap]));
 370         srchv[3].v = (vector signed short) vec_mergeh(zero, tmp);
 371         srclv[3].v = (vector signed short) vec_mergel(zero, tmp);
 372         sumhv = vec_madds(srchv[3].v, fv[3].v, sumhv);
 373         sumlv = vec_madds(srclv[3].v, fv[3].v, sumlv);
 374
 375         /*
 376            Pack the results into our destination vector,
 377            and do an aligned write of that back to memory.
 378         */
 379         dstv = vec_packsu(sumhv, sumlv) ;
 380         vec_st(dstv, 0, (vector unsigned char *) dst);
 381
 382         dst+=16;
 383         s+=16;
 384         dst_width-=16;
 385     }
 386
 387     /*
 388        If there are any leftover pixels, resample them
 389        with the slow scalar method.
 390     */
 391     while(dst_width>0) {
 392         sum = s[0 * wrap] * filter[0] +
 393         s[1 * wrap] * filter[1] +
 394         s[2 * wrap] * filter[2] +
 395         s[3 * wrap] * filter[3];
 396         sum = sum >> FILTER_BITS;
 397         if (sum<0) sum = 0; else if (sum>255) sum=255;
 398         dst[0] = sum;
 399         dst++;
 400         s++;
 401         dst_width--;
 402     }
 403 }
 404 #endif
 405
 406 /* slow version to handle limit cases. Does not need optimisation */
 407 static void h_resample_slow(uint8_t *dst, int dst_width,
 408                             const uint8_t *src, int src_width,
 409                             int src_start, int src_incr, int16_t *filters)
 410 {
 411     int src_pos, phase, sum, j, v, i;
 412     const uint8_t *s, *src_end;
 413     int16_t *filter;
 414
 415     src_end = src + src_width;
 416     src_pos = src_start;
 417     for(i=0;i<dst_width;i++) {
 418         s = src + (src_pos >> POS_FRAC_BITS);
 419         phase = get_phase(src_pos);
 420         filter = filters + phase * NB_TAPS;
 421         sum = 0;
 422         for(j=0;j<NB_TAPS;j++) {
 423             if (s < src)
 424                 v = src[0];
 425             else if (s >= src_end)
 426                 v = src_end[-1];
 427             else
 428                 v = s[0];
 429             sum += v * filter[j];
 430             s++;
 431         }
 432         sum = sum >> FILTER_BITS;
 433         if (sum < 0)
 434             sum = 0;
 435         else if (sum > 255)
 436             sum = 255;
 437         dst[0] = sum;
 438         src_pos += src_incr;
 439         dst++;
 440     }
 441 }
 442
 443 static void h_resample(uint8_t *dst, int dst_width, const uint8_t *src,
 444                        int src_width, int src_start, int src_incr,
 445                        int16_t *filters)
 446 {
 447     int n, src_end;
 448
 449     if (src_start < 0) {
 450         n = (0 - src_start + src_incr - 1) / src_incr;
 451         h_resample_slow(dst, n, src, src_width, src_start, src_incr, filters);
 452         dst += n;
 453         dst_width -= n;
 454         src_start += n * src_incr;
 455     }
 456     src_end = src_start + dst_width * src_incr;
 457     if (src_end > ((src_width - NB_TAPS) << POS_FRAC_BITS)) {
 458         n = (((src_width - NB_TAPS + 1) << POS_FRAC_BITS) - 1 - src_start) /
 459             src_incr;
 460     } else {
 461         n = dst_width;
 462     }
 463 #ifdef HAVE_MMX
 464     if ((mm_flags & MM_MMX) && NB_TAPS == 4)
 465         h_resample_fast4_mmx(dst, n,
 466                              src, src_width, src_start, src_incr, filters);
 467     else
 468 #endif
 469         h_resample_fast(dst, n,
 470                         src, src_width, src_start, src_incr, filters);
 471     if (n < dst_width) {
 472         dst += n;
 473         dst_width -= n;
 474         src_start += n * src_incr;
 475         h_resample_slow(dst, dst_width,
 476                         src, src_width, src_start, src_incr, filters);
 477     }
 478 }
 479
 480 static void component_resample(ImgReSampleContext *s,
 481                                uint8_t *output, int owrap, int owidth, int oheight,
 482                                uint8_t *input, int iwrap, int iwidth, int iheight)
 483 {
 484     int src_y, src_y1, last_src_y, ring_y, phase_y, y1, y;
 485     uint8_t *new_line, *src_line;
 486
 487     last_src_y = - FCENTER - 1;
 488     /* position of the bottom of the filter in the source image */
 489     src_y = (last_src_y + NB_TAPS) * POS_FRAC;
 490     ring_y = NB_TAPS; /* position in ring buffer */
 491     for(y=0;y<oheight;y++) {
 492         /* apply horizontal filter on new lines from input if needed */
 493         src_y1 = src_y >> POS_FRAC_BITS;
 494         while (last_src_y < src_y1) {
 495             if (++ring_y >= LINE_BUF_HEIGHT + NB_TAPS)
 496                 ring_y = NB_TAPS;
 497             last_src_y++;
 498             /* handle limit conditions : replicate line (slightly
 499                inefficient because we filter multiple times) */
 500             y1 = last_src_y;
 501             if (y1 < 0) {
 502                 y1 = 0;
 503             } else if (y1 >= iheight) {
 504                 y1 = iheight - 1;
 505             }
 506             src_line = input + y1 * iwrap;
 507             new_line = s->line_buf + ring_y * owidth;
 508             /* apply filter and handle limit cases correctly */
 509             h_resample(new_line, owidth,
 510                        src_line, iwidth, - FCENTER * POS_FRAC, s->h_incr,
 511                        &s->h_filters[0][0]);
 512             /* handle ring buffer wraping */
 513             if (ring_y >= LINE_BUF_HEIGHT) {
 514                 memcpy(s->line_buf + (ring_y - LINE_BUF_HEIGHT) * owidth,
 515                        new_line, owidth);
 516             }
 517         }
 518         /* apply vertical filter */
 519         phase_y = get_phase(src_y);
 520 #ifdef HAVE_MMX
 521         /* desactivated MMX because loss of precision */
 522         if ((mm_flags & MM_MMX) && NB_TAPS == 4 && 0)
 523             v_resample4_mmx(output, owidth,
 524                             s->line_buf + (ring_y - NB_TAPS + 1) * owidth, owidth,
 525                             &s->v_filters[phase_y][0]);
 526         else
 527 #endif
 528 #ifdef HAVE_ALTIVEC
 529             if ((mm_flags & MM_ALTIVEC) && NB_TAPS == 4 && FILTER_BITS <= 6)
 530                 v_resample16_altivec(output, owidth,
 531                                 s->line_buf + (ring_y - NB_TAPS + 1) * owidth, owidth,
 532                                 &s->v_filters[phase_y][0]);
 533         else
 534 #endif
 535             v_resample(output, owidth,
 536                        s->line_buf + (ring_y - NB_TAPS + 1) * owidth, owidth,
 537                        &s->v_filters[phase_y][0]);
 538
 539         src_y += s->v_incr;
 540
 541         output += owrap;
 542     }
 543 }
 544
 545 ImgReSampleContext *img_resample_init(int owidth, int oheight,
 546                                       int iwidth, int iheight)
 547 {
 548     return img_resample_full_init(owidth, oheight, iwidth, iheight,
 549             0, 0, 0, 0, 0, 0, 0, 0);
 550 }
 551
 552 ImgReSampleContext *img_resample_full_init(int owidth, int oheight,
 553                                       int iwidth, int iheight,
 554                                       int topBand, int bottomBand,
 555         int leftBand, int rightBand,
 556         int padtop, int padbottom,
 557         int padleft, int padright)
 558 {
 559     ImgReSampleContext *s;
 560
 561     s = av_mallocz(sizeof(ImgReSampleContext));
 562     if (!s)
 563         return NULL;
 564     s->line_buf = av_mallocz(owidth * (LINE_BUF_HEIGHT + NB_TAPS));
 565     if (!s->line_buf)
 566         goto fail;
 567
 568     s->owidth = owidth;
 569     s->oheight = oheight;
 570     s->iwidth = iwidth;
 571     s->iheight = iheight;
 572
 573     s->topBand = topBand;
 574     s->bottomBand = bottomBand;
 575     s->leftBand = leftBand;
 576     s->rightBand = rightBand;
 577
 578     s->padtop = padtop;
 579     s->padbottom = padbottom;
 580     s->padleft = padleft;
 581     s->padright = padright;
 582
 583     s->pad_owidth = owidth - (padleft + padright);
 584     s->pad_oheight = oheight - (padtop + padbottom);
 585
 586     s->h_incr = ((iwidth - leftBand - rightBand) * POS_FRAC) / s->pad_owidth;
 587     s->v_incr = ((iheight - topBand - bottomBand) * POS_FRAC) / s->pad_oheight;
 588
 589     av_build_filter(&s->h_filters[0][0], (float) s->pad_owidth  /
 590             (float) (iwidth - leftBand - rightBand), NB_TAPS, NB_PHASES, 1<<FILTER_BITS, 0);
 591     av_build_filter(&s->v_filters[0][0], (float) s->pad_oheight /
 592             (float) (iheight - topBand - bottomBand), NB_TAPS, NB_PHASES, 1<<FILTER_BITS, 0);
 593
 594     return s;
 595 fail:
 596     av_free(s);
 597     return NULL;
 598 }
 599
 600 void img_resample(ImgReSampleContext *s,
 601                   AVPicture *output, const AVPicture *input)
 602 {
 603     int i, shift;
 604     uint8_t* optr;
 605
 606     for (i=0;i<3;i++) {
 607         shift = (i == 0) ? 0 : 1;
 608
 609         optr = output->data[i] + (((output->linesize[i] *
 610                         s->padtop) + s->padleft) >> shift);
 611
 612         component_resample(s, optr, output->linesize[i],
 613                 s->pad_owidth >> shift, s->pad_oheight >> shift,
 614                 input->data[i] + (input->linesize[i] *
 615                     (s->topBand >> shift)) + (s->leftBand >> shift),
 616                 input->linesize[i], ((s->iwidth - s->leftBand -
 617                         s->rightBand) >> shift),
 618                            (s->iheight - s->topBand - s->bottomBand) >> shift);
 619     }
 620 }
 621
 622 void img_resample_close(ImgReSampleContext *s)
 623 {
 624     av_free(s->line_buf);
 625     av_free(s);
 626 }
 627
 628 #ifdef TEST
 629
 630 void *av_mallocz(int size)
 631 {
 632     void *ptr;
 633     ptr = malloc(size);
 634     memset(ptr, 0, size);
 635     return ptr;
 636 }
 637
 638 void av_free(void *ptr)
 639 {
 640     /* XXX: this test should not be needed on most libcs */
 641     if (ptr)
 642         free(ptr);
 643 }
 644
 645 /* input */
 646 #define XSIZE 256
 647 #define YSIZE 256
 648 uint8_t img[XSIZE * YSIZE];
 649
 650 /* output */
 651 #define XSIZE1 512
 652 #define YSIZE1 512
 653 uint8_t img1[XSIZE1 * YSIZE1];
 654 uint8_t img2[XSIZE1 * YSIZE1];
 655
 656 void save_pgm(const char *filename, uint8_t *img, int xsize, int ysize)
 657 {
 658     FILE *f;
 659     f=fopen(filename,"w");
 660     fprintf(f,"P5\n%d %d\n%d\n", xsize, ysize, 255);
 661     fwrite(img,1, xsize * ysize,f);
 662     fclose(f);
 663 }
 664
 665 static void dump_filter(int16_t *filter)
 666 {
 667     int i, ph;
 668
 669     for(ph=0;ph<NB_PHASES;ph++) {
 670         printf("%2d: ", ph);
 671         for(i=0;i<NB_TAPS;i++) {
 672             printf(" %5.2f", filter[ph * NB_TAPS + i] / 256.0);
 673         }
 674         printf("\n");
 675     }
 676 }
 677
 678 #ifdef HAVE_MMX
 679 int mm_flags;
 680 #endif
 681
 682 int main(int argc, char **argv)
 683 {
 684     int x, y, v, i, xsize, ysize;
 685     ImgReSampleContext *s;
 686     float fact, factors[] = { 1/2.0, 3.0/4.0, 1.0, 4.0/3.0, 16.0/9.0, 2.0 };
 687     char buf[256];
 688
 689     /* build test image */
 690     for(y=0;y<YSIZE;y++) {
 691         for(x=0;x<XSIZE;x++) {
 692             if (x < XSIZE/2 && y < YSIZE/2) {
 693                 if (x < XSIZE/4 && y < YSIZE/4) {
 694                     if ((x % 10) <= 6 &&
 695                         (y % 10) <= 6)
 696                         v = 0xff;
 697                     else
 698                         v = 0x00;
 699                 } else if (x < XSIZE/4) {
 700                     if (x & 1)
 701                         v = 0xff;
 702                     else
 703                         v = 0;
 704                 } else if (y < XSIZE/4) {
 705                     if (y & 1)
 706                         v = 0xff;
 707                     else
 708                         v = 0;
 709                 } else {
 710                     if (y < YSIZE*3/8) {
 711                         if ((y+x) & 1)
 712                             v = 0xff;
 713                         else
 714                             v = 0;
 715                     } else {
 716                         if (((x+3) % 4) <= 1 &&
 717                             ((y+3) % 4) <= 1)
 718                             v = 0xff;
 719                         else
 720                             v = 0x00;
 721                     }
 722                 }
 723             } else if (x < XSIZE/2) {
 724                 v = ((x - (XSIZE/2)) * 255) / (XSIZE/2);
 725             } else if (y < XSIZE/2) {
 726                 v = ((y - (XSIZE/2)) * 255) / (XSIZE/2);
 727             } else {
 728                 v = ((x + y - XSIZE) * 255) / XSIZE;
 729             }
 730             img[(YSIZE - y) * XSIZE + (XSIZE - x)] = v;
 731         }
 732     }
 733     save_pgm("/tmp/in.pgm", img, XSIZE, YSIZE);
 734     for(i=0;i<sizeof(factors)/sizeof(float);i++) {
 735         fact = factors[i];
 736         xsize = (int)(XSIZE * fact);
 737         ysize = (int)((YSIZE - 100) * fact);
 738         s = img_resample_full_init(xsize, ysize, XSIZE, YSIZE, 50 ,50, 0, 0);
 739         printf("Factor=%0.2f\n", fact);
 740         dump_filter(&s->h_filters[0][0]);
 741         component_resample(s, img1, xsize, xsize, ysize,
 742                            img + 50 * XSIZE, XSIZE, XSIZE, YSIZE - 100);
 743         img_resample_close(s);
 744
 745         sprintf(buf, "/tmp/out%d.pgm", i);
 746         save_pgm(buf, img1, xsize, ysize);
 747     }
 748
 749     /* mmx test */
 750 #ifdef HAVE_MMX
 751     printf("MMX test\n");
 752     fact = 0.72;
 753     xsize = (int)(XSIZE * fact);
 754     ysize = (int)(YSIZE * fact);
 755     mm_flags = MM_MMX;
 756     s = img_resample_init(xsize, ysize, XSIZE, YSIZE);
 757     component_resample(s, img1, xsize, xsize, ysize,
 758                        img, XSIZE, XSIZE, YSIZE);
 759
 760     mm_flags = 0;
 761     s = img_resample_init(xsize, ysize, XSIZE, YSIZE);
 762     component_resample(s, img2, xsize, xsize, ysize,
 763                        img, XSIZE, XSIZE, YSIZE);
 764     if (memcmp(img1, img2, xsize * ysize) != 0) {
 765         fprintf(stderr, "mmx error\n");
 766         exit(1);
 767     }
 768     printf("MMX OK\n");
 769 #endif
 770     return 0;
 771 }
 772
 773 #endif