wrlib/x86_specific.c

   1 /* x86_convert.c - convert RImage to XImage with x86 optimizations
   2  *
   3  *  Raster graphics library
   4  *
   5  *  Copyright (c) 2000 Alfredo K. Kojima
   6  *
   7  *  This library is free software; you can redistribute it and/or
   8  *  modify it under the terms of the GNU Library General Public
   9  *  License as published by the Free Software Foundation; either
  10  *  version 2 of the License, or (at your option) any later version.
  11  *
  12  *  This library is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  Library General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU Library General Public
  18  *  License along with this library; if not, write to the Free
  19  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <config.h>
  23
  24 #ifdef ASM_X86
  25
  26
  27 #ifdef ASM_X86_MMX
  28
  29 int
  30 x86_check_mmx()
  31 {
  32     static int result = -1;
  33
  34     return 1;
  35
  36     if (result >= 0)
  37         return result;
  38
  39     result = 0;
  40
  41     asm volatile
  42         ("pushfl                \n" // check whether cpuid supported
  43          "pop %%eax             \n"
  44          "movl %%eax, %%ebx     \n"
  45          "xorl 1<<21, %%eax     \n"
  46          "pushl %%eax           \n"
  47          "popfl                 \n"
  48          "pushfl                \n"
  49          "popl %%eax            \n"
  50          "xorl %%eax, %%ebx     \n"
  51          "andl 1<<21, %%eax     \n"
  52          "jz .NotPentium        \n"
  53          "xorl %%eax, %%eax     \n"
  54
  55          "movl $1, %%eax        \n"
  56          "cpuid                 \n"
  57          "test 1<<23, %%edx     \n"
  58          "jz .NotMMX            \n"
  59          "movl $1, %0           \n"
  60
  61          ".NotMMX:              \n"
  62          ".Bye:                 \n"
  63          ".NotPentium:          \n"
  64
  65          : "=rm" (result));
  66
  67     return result;
  68 }
  69
  70
  71 /*
  72  * TODO:
  73  *              32/8    24/8    32/16   24/16   32/24   24/24
  74  * PPlain       YES     YES
  75  * MMX                          DONE
  76  *
  77  */
  78
  79
  80
  81
  82 void
  83 x86_mmx_TrueColor_32_to_16(unsigned char *image, // 8
  84                            unsigned short *ximage, // 12
  85                            short *err, // 16
  86                            short *nerr, // 20
  87                            short *rtable, // 24
  88                            short *gtable, // 28
  89                            short *btable, // 32
  90                            int dr, // 36
  91                            int dg, // 40
  92                            int db, // 44
  93                            unsigned int roffs, // 48
  94                            unsigned int goffs, // 52
  95                            unsigned int boffs, // 56
  96                            int width, // 60
  97                            int height, // 64
  98                            int line_offset) // 68
  99 {
 100     /*
 101      int x; //-4
 102      long long rrggbbaa;// -16
 103      long long pixel; //-24
 104      short *tmp_err; //-32
 105      short *tmp_nerr; //-36
 106      */
 107
 108     asm volatile
 109         (
 110          "andl $-8, %ebp                \n" // make it align
 111          "subl $128, %esp               \n" // alloc some more stack
 112
 113          "pusha                         \n"
 114
 115          // pack dr, dg and db into mm6
 116          "movl  36(%ebp), %eax          \n"
 117          "movl  40(%ebp), %ebx          \n"
 118          "movw  %ax, -16(%ebp)          \n"
 119
 120          "movw  %bx, -14(%ebp)          \n"
 121          "movl  44(%ebp), %eax          \n"
 122          "movw  $0, -10(%ebp)           \n"
 123          "movw  %ax, -12(%ebp)          \n"
 124
 125          "movq  -16(%ebp), %mm6         \n" // dr dg db 0
 126
 127          // pack 4|4|4|4 into mm7, for shifting (/16)
 128          "movl $0x00040004, -16(%ebp)   \n"
 129          "movl $0x00040004, -12(%ebp)   \n"
 130          "movq -16(%ebp), %mm7          \n"
 131
 132          // store constant values for using with mmx when dithering
 133          "movl $0x00070007, -16(%ebp)   \n"
 134          "movl $0x00070007, -12(%ebp)   \n"
 135          "movq -16(%ebp), %mm5          \n"
 136
 137          "movl $0x00050005, -16(%ebp)   \n"
 138          "movl $0x00050005, -12(%ebp)   \n"
 139          "movq -16(%ebp), %mm4          \n"
 140
 141          "movl $0x00030003, -16(%ebp)   \n"
 142          "movl $0x00030003, -12(%ebp)   \n"
 143          "movq -16(%ebp), %mm3          \n"
 144
 145          // process 1 pixel / cycle, each component treated as 16bit
 146          "movl 8(%ebp), %esi            \n" // esi = image->data
 147
 148 ".LoopYa:                               \n"
 149          "movl 60(%ebp), %eax           \n"
 150          "movl %eax, -4(%ebp)           \n" // x = width
 151
 152          "movl 64(%ebp), %eax           \n"
 153          "decl %eax                     \n" // y--
 154          "movl %eax, 64(%ebp)           \n"
 155          "js .Enda                      \n" // if y < 0, goto end
 156          "andl $1, %eax                 \n"
 157          "jz .LoopY_1a                  \n" // if (y&1) goto LoopY_1
 158
 159 ".LoopY_0a:                             \n"
 160
 161          "movl 16(%ebp), %ebx           \n" // ebx = err
 162          "movl %ebx, -36(%ebp)          \n" // [-36] = err
 163          "movl 20(%ebp), %eax           \n" //
 164          "movl %eax, -32(%ebp)          \n" // [-32] = nerr
 165
 166          "jmp .LoopXa                   \n"
 167
 168 ".LoopY_1a:                             \n"
 169
 170          "movl 20(%ebp), %ebx           \n" // ebx = nerr
 171          "movl %ebx, -36(%ebp)          \n" // [-36] = nerr
 172          "movl 16(%ebp), %eax           \n" //
 173          "movl %eax, -32(%ebp)          \n" // [-32] = eerr
 174
 175
 176 ".LoopXa:                               \n"
 177
 178          // calculate errors and pixel components
 179
 180          // depend on ebx, esi, mm6
 181          "movq (%ebx), %mm1             \n" // mm1 = error[0..3]
 182          "punpcklbw (%esi), %mm0        \n" // mm0 = image->data[0..3]
 183          "psrlw $8, %mm0                \n" // fixup mm0
 184          "paddusb %mm1, %mm0            \n" // mm0 = mm0 + mm1 (sat. to 255)
 185          "movq %mm0, -24(%ebp)          \n" // save the pixel
 186
 187          "movzwl -24(%ebp), %ecx        \n" // ecx = pixel.red
 188          "movl 24(%ebp), %edi           \n" // edi = rtable
 189          "leal (%edi, %ecx, 2), %eax    \n" // eax = &rtable[pixel.red]
 190          "movl (%eax), %edx             \n" // edx = rtable[pixel.red]
 191          "movw %dx, -16(%ebp)           \n" // save rr
 192
 193          "movzwl -22(%ebp), %ecx        \n" // ecx = pixel.green
 194          "movl 28(%ebp), %edi           \n" // edi = gtable
 195          "leal (%edi, %ecx, 2), %eax    \n" // eax = &gtable[pixel.green]
 196          "movl (%eax), %edx             \n" // ebx = gtable[pixel.green]
 197          "movw %dx, -14(%ebp)           \n" // save gg
 198
 199          "movzwl -20(%ebp), %ecx        \n" // ecx = pixel.blue
 200          "movl 32(%ebp), %edi           \n" // ebx = btable
 201          "leal (%edi, %ecx, 2), %eax    \n" // eax = &btable[pixel.blue]
 202          "movl (%eax), %edx             \n" // ecx = btable[pixel.blue]
 203          "movw %dx, -12(%ebp)           \n" // save bb
 204
 205          "movw $0, -10(%ebp)            \n" // save dummy aa
 206
 207          "movq -16(%ebp), %mm1          \n" // load mm1 with rrggbbaa
 208          "pmullw %mm6, %mm1             \n" // mm1 = rr*dr|...
 209          "psubsw %mm1, %mm0             \n" // error = pixel - mm1
 210
 211
 212          // distribute the error
 213
 214          // depend on mm0, mm7, mm3, mm4, mm5
 215
 216          "movl -36(%ebp), %ebx          \n"
 217
 218          "movq %mm0, %mm1               \n"
 219          "pmullw %mm5, %mm1             \n" // mm1 = mm1*7
 220          "psrlw %mm7, %mm1              \n" // mm1 = mm1/16
 221          "paddw 8(%ebx), %mm1           \n"
 222          "movq %mm1, 8(%ebx)            \n" // err[x+1,y] = rer*7/16
 223
 224
 225          "movl -32(%ebp), %ebx          \n"
 226
 227          "movq %mm0, %mm1               \n"
 228          "pmullw %mm4, %mm1             \n" // mm1 = mm1*5
 229          "psrlw %mm7, %mm1              \n" // mm1 = mm1/16
 230          "paddw -8(%ebx), %mm1          \n"
 231          "movq %mm1, -8(%ebx)           \n" // err[x-1,y+1] += rer*3/16
 232
 233          "movq %mm0, %mm1               \n"
 234          "pmullw %mm3, %mm1             \n" // mm1 = mm1*3
 235          "psrlw %mm7, %mm1              \n" // mm1 = mm1/16
 236          "paddw 8(%ebx), %mm1           \n"
 237          "movq %mm1, (%ebx)             \n" // err[x,y+1] += rer*5/16
 238
 239          "psrlw %mm7, %mm0              \n" // mm0 = mm0/16
 240          "movq %mm0, 8(%ebx)            \n" // err[x+1,y+1] = rer/16
 241
 242
 243          // calculate final pixel value and store
 244          "movl 48(%ebp), %ecx           \n"
 245          "movw -16(%ebp), %ax           \n"
 246          "shlw %cl, %ax                 \n" //NP* ax = r<<roffs
 247
 248          "movl 52(%ebp), %ecx           \n"
 249          "movw -14(%ebp), %bx           \n"
 250          "shlw %cl, %bx                 \n" //NP*
 251          "orw %bx, %ax                  \n"
 252
 253          "movl 56(%ebp), %ecx           \n"
 254          "movw -12(%ebp), %bx           \n"
 255          "shlw %cl, %bx                 \n" //NP*
 256          "orw %bx, %ax                  \n"
 257
 258          "movl 12(%ebp), %edx           \n"
 259          "movw %ax, (%edx)              \n"
 260          "addl $2, %edx                 \n" // increment ximage
 261          "movl %edx, 12(%ebp)           \n"
 262
 263          // prepare for next iteration on X
 264
 265          "addl $8, -32(%ebp)            \n" // nerr += 8
 266
 267          "movl -36(%ebp), %ebx          \n"
 268          "addl $8, %ebx                 \n"
 269          "movl %ebx, -36(%ebp)          \n" // ebx = err += 8
 270
 271
 272          // Note: in the last pixel, this would cause an invalid memory access
 273          // because, punpcklbw is used (which reads 8 bytes) and the last
 274          // pixel is only 4 bytes. This is no problem because the image data
 275          // was allocated with extra 4 bytes when created.
 276          "addl $4, %esi                 \n" // image->data += 4
 277
 278
 279          "decl -4(%ebp)                 \n" // x--
 280          "jnz .LoopXa                   \n" // if x>0, goto .LoopX
 281
 282
 283          // depend on edx
 284          "addl 68(%ebp), %edx           \n" // add extra offset to ximage
 285          "movl %edx, 12(%ebp)           \n"
 286
 287
 288          "jmp .LoopYa                   \n"
 289
 290 ".Enda:                                 \n" // THE END
 291
 292          "emms                          \n"
 293
 294          "popa                          \n"
 295          );
 296 }
 297
 298
 299 #endif /* ASM_X86_MMX */
 300
 301 #if 0
 302
 303     /* convert and dither the image to XImage */
 304     for (y=0; y<image->height; y++) {
 305         nerr[0] = 0;
 306         nerr[1] = 0;
 307         nerr[2] = 0;
 308         for (x=0; x<image->width*3; x+=3, ptr+=channels) {
 309
 310             /* reduce pixel */
 311             pixel = *ptr + err[x];
 312             if (pixel<0) pixel=0; else if (pixel>0xff) pixel=0xff;
 313             r = rtable[pixel];
 314             /* calc error */
 315             rer = pixel - r*dr;
 316
 317             /* reduce pixel */
 318             pixel = *(ptr+1) + err[x+1];
 319             if (pixel<0) pixel=0; else if (pixel>0xff) pixel=0xff;
 320             g = gtable[pixel];
 321             /* calc error */
 322             ger = pixel - g*dg;
 323
 324             /* reduce pixel */
 325             pixel = *(ptr+2) + err[x+2];
 326             if (pixel<0) pixel=0; else if (pixel>0xff) pixel=0xff;
 327             b = btable[pixel];
 328             /* calc error */
 329             ber = pixel - b*db;
 330
 331             *optr++ = pixels[r*cpcpc + g*cpc + b];
 332
 333             /* distribute error */
 334             r = (rer*3)/8;
 335             g = (ger*3)/8;
 336             b = (ber*3)/8;
 337             /* x+1, y */
 338             err[x+3*1]+=r;
 339             err[x+1+3*1]+=g;
 340             err[x+2+3*1]+=b;
 341             /* x, y+1 */
 342             nerr[x]+=r;
 343             nerr[x+1]+=g;
 344             nerr[x+2]+=b;
 345             /* x+1, y+1 */
 346             nerr[x+3*1]=rer-2*r;
 347             nerr[x+1+3*1]=ger-2*g;
 348             nerr[x+2+3*1]=ber-2*b;
 349         }
 350         /* skip to next line */
 351         terr = err;
 352         err = nerr;
 353         nerr = terr;
 354
 355         optr += ximg->image->bytes_per_line - image->width;
 356     }
 357 }
 358 #endif
 359
 360
 361 void
 362 x86_PseudoColor_32_to_8(unsigned char *image, // 8
 363                         unsigned char *ximage, // 12
 364                         char *err, // 16
 365                         char *nerr, // 20
 366                         short *rtable, // 24
 367                         short *gtable, // 28
 368                         short *btable, // 32
 369                         int dr, // 36
 370                         int dg, // 40
 371                         int db, // 44
 372                         unsigned long *pixels, // 48
 373                         int cpc, // 52
 374                         int width, // 56
 375                         int height, // 60
 376                         int line_offset) // 64
 377 {
 378     asm volatile
 379         (
 380          "andl $-8, %ebp                \n"
 381          "subl $128, %esp               \n" // alloc some stack space
 382          "pusha                         \n"
 383
 384          // process 1 pixel / cycle, each component treated as 16bit
 385          "movl 8(%ebp), %esi            \n" // esi = image->data
 386
 387 ".LoopYb:                               \n"
 388          "movl 56(%ebp), %eax           \n"
 389          "movl %eax, -4(%ebp)           \n" // x = width
 390
 391          "movl 60(%ebp), %eax           \n"
 392          "decl %eax                     \n" // y--
 393          "movl %eax, 64(%ebp)           \n"
 394          "js .Endb                      \n" // if y < 0, goto end
 395          "andl $1, %eax                 \n"
 396          "jz .LoopY_1b                  \n" // if (y&1) goto LoopY_1
 397
 398 ".LoopY_0b:                             \n"
 399
 400          "movl 16(%ebp), %ebx           \n" // ebx = err
 401          "movl %ebx, -36(%ebp)          \n" // [-36] = err
 402          "movl 20(%ebp), %eax           \n" //
 403          "movl %eax, -32(%ebp)          \n" // [-32] = nerr
 404
 405          "movl $0, -32(%ebp)            \n" // init error of nerr[0] to 0
 406
 407          "jmp .LoopXb                   \n"
 408
 409 ".LoopY_1b:                             \n"
 410
 411          "movl 20(%ebp), %ebx           \n" // ebx = nerr
 412          "movl %ebx, -36(%ebp)          \n" // [-36] = nerr
 413          "movl 16(%ebp), %eax           \n" //
 414          "movl %eax, -32(%ebp)          \n" // [-32] = err
 415
 416          "movl $0, -32(%ebp)            \n" // init error of nerr[0] to 0
 417
 418 ".LoopXb:                               \n"
 419
 420          "movl (%esi), %edx             \n" // fetch a pixel
 421
 422 //       "movl                                  \n"
 423
 424
 425
 426 ".Endb:                                 \n"
 427
 428          "popa                          \n"
 429          );
 430
 431
 432 }
 433
 434 #endif /* ASM_X86 */