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  * - try to align stack (local variable space) into quadword boundary
  79  */
  80
  81
  82
  83
  84 void
  85 x86_mmx_TrueColor_32_to_16(unsigned char *image, // 8
  86                            unsigned short *ximage, // 12
  87                            short *err, // 16
  88                            short *nerr, // 20
  89                            short *rtable, // 24
  90                            short *gtable, // 28
  91                            short *btable, // 32
  92                            int dr, // 36
  93                            int dg, // 40
  94                            int db, // 44
  95                            unsigned int roffs, // 48
  96                            unsigned int goffs, // 52
  97                            unsigned int boffs, // 56
  98                            int width, // 60
  99                            int height, // 64
 100                            int line_offset) // 68
 101 {
 102     /*
 103      int x; //-4
 104      long long rrggbbaa;// -16
 105      long long pixel; //-24
 106      short *tmp_err; //-32
 107      short *tmp_nerr; //-36
 108      */
 109
 110     asm volatile
 111         (
 112          "subl $128, %esp               \n" // alloc some more stack
 113
 114          "pusha                         \n"
 115
 116          // pack dr, dg and db into mm6
 117          "movl  36(%ebp), %eax          \n"
 118          "movl  40(%ebp), %ebx          \n"
 119          "movw  %ax, -16(%ebp)          \n"
 120
 121          "movw  %bx, -14(%ebp)          \n"
 122          "movl  44(%ebp), %eax          \n"
 123          "movw  $0, -10(%ebp)           \n"
 124          "movw  %ax, -12(%ebp)          \n"
 125
 126          "movq  -16(%ebp), %mm6         \n" // dr dg db 0
 127
 128          // pack 4|4|4|4 into mm7, for shifting (/16)
 129          "movl $0x00040004, -16(%ebp)   \n"
 130          "movl $0x00040004, -12(%ebp)   \n"
 131          "movq -16(%ebp), %mm7          \n"
 132
 133          // store constant values for using with mmx when dithering
 134          "movl $0x00070007, -16(%ebp)   \n"
 135          "movl $0x00070007, -12(%ebp)   \n"
 136          "movq -16(%ebp), %mm5          \n"
 137
 138          "movl $0x00050005, -16(%ebp)   \n"
 139          "movl $0x00050005, -12(%ebp)   \n"
 140          "movq -16(%ebp), %mm4          \n"
 141
 142          "movl $0x00030003, -16(%ebp)   \n"
 143          "movl $0x00030003, -12(%ebp)   \n"
 144          "movq -16(%ebp), %mm3          \n"
 145
 146          // process 1 pixel / cycle, each component treated as 16bit
 147          "movl 8(%ebp), %esi            \n" // esi = image->data
 148
 149 ".LoopYa:                               \n"
 150          "movl 60(%ebp), %eax           \n"
 151          "movl %eax, -4(%ebp)           \n" // x = width
 152
 153          "movl 64(%ebp), %eax           \n"
 154          "decl %eax                     \n" // y--
 155          "movl %eax, 64(%ebp)           \n"
 156          "js .Enda                      \n" // if y < 0, goto end
 157          "andl $1, %eax                 \n"
 158          "jz .LoopY_1a                  \n" // if (y&1) goto LoopY_1
 159
 160 ".LoopY_0a:                             \n"
 161
 162          "movl 16(%ebp), %ebx           \n" // ebx = err
 163          "movl %ebx, -36(%ebp)          \n" // [-36] = err
 164          "movl 20(%ebp), %eax           \n" //
 165          "movl %eax, -32(%ebp)          \n" // [-32] = nerr
 166
 167          "jmp .LoopXa                   \n"
 168
 169 ".LoopY_1a:                             \n"
 170
 171          "movl 20(%ebp), %ebx           \n" // ebx = nerr
 172          "movl %ebx, -36(%ebp)          \n" // [-36] = nerr
 173          "movl 16(%ebp), %eax           \n" //
 174          "movl %eax, -32(%ebp)          \n" // [-32] = eerr
 175
 176
 177 ".LoopXa:                               \n"
 178
 179          // calculate errors and pixel components
 180
 181          // depend on ebx, esi, mm6
 182          "movq (%ebx), %mm1             \n" // mm1 = error[0..3]
 183          "punpcklbw (%esi), %mm0        \n" // mm0 = image->data[0..3]
 184          "psrlw $8, %mm0                \n" // fixup mm0
 185          "paddusb %mm1, %mm0            \n" // mm0 = mm0 + mm1 (sat. to 255)
 186          "movq %mm0, -24(%ebp)          \n" // save the pixel
 187
 188          "movzwl -24(%ebp), %ecx        \n" // ecx = pixel.red
 189          "movl 24(%ebp), %edi           \n" // edi = rtable
 190          "leal (%edi, %ecx, 2), %eax    \n" // eax = &rtable[pixel.red]
 191          "movl (%eax), %edx             \n" // edx = rtable[pixel.red]
 192          "movw %dx, -16(%ebp)           \n" // save rr
 193
 194          "movzwl -22(%ebp), %ecx        \n" // ecx = pixel.green
 195          "movl 28(%ebp), %edi           \n" // edi = gtable
 196          "leal (%edi, %ecx, 2), %eax    \n" // eax = &gtable[pixel.green]
 197          "movl (%eax), %edx             \n" // ebx = gtable[pixel.green]
 198          "movw %dx, -14(%ebp)           \n" // save gg
 199
 200          "movzwl -20(%ebp), %ecx        \n" // ecx = pixel.blue
 201          "movl 32(%ebp), %edi           \n" // ebx = btable
 202          "leal (%edi, %ecx, 2), %eax    \n" // eax = &btable[pixel.blue]
 203          "movl (%eax), %edx             \n" // ecx = btable[pixel.blue]
 204          "movw %dx, -12(%ebp)           \n" // save bb
 205
 206          "movw $0, -10(%ebp)            \n" // save dummy aa
 207
 208          "movq -16(%ebp), %mm1          \n" // load mm1 with rrggbbaa
 209          "pmullw %mm6, %mm1             \n" // mm1 = rr*dr|...
 210          "psubsw %mm1, %mm0             \n" // error = pixel - mm1
 211
 212
 213          // distribute the error
 214
 215          // depend on mm0, mm7, mm3, mm4, mm5
 216
 217          "movl -36(%ebp), %ebx          \n"
 218
 219          "movq %mm0, %mm1               \n"
 220          "pmullw %mm5, %mm1             \n" // mm1 = mm1*7
 221          "psrlw %mm7, %mm1              \n" // mm1 = mm1/16
 222          "paddw 8(%ebx), %mm1           \n"
 223          "movq %mm1, 8(%ebx)            \n" // err[x+1,y] = rer*7/16
 224
 225
 226          "movl -32(%ebp), %ebx          \n"
 227
 228          "movq %mm0, %mm1               \n"
 229          "pmullw %mm4, %mm1             \n" // mm1 = mm1*5
 230          "psrlw %mm7, %mm1              \n" // mm1 = mm1/16
 231          "paddw -8(%ebx), %mm1          \n"
 232          "movq %mm1, -8(%ebx)           \n" // err[x-1,y+1] += rer*3/16
 233
 234          "movq %mm0, %mm1               \n"
 235          "pmullw %mm3, %mm1             \n" // mm1 = mm1*3
 236          "psrlw %mm7, %mm1              \n" // mm1 = mm1/16
 237          "paddw 8(%ebx), %mm1           \n"
 238          "movq %mm1, (%ebx)             \n" // err[x,y+1] += rer*5/16
 239
 240          "psrlw %mm7, %mm0              \n" // mm0 = mm0/16
 241          "movq %mm0, 8(%ebx)            \n" // err[x+1,y+1] = rer/16
 242
 243
 244          // calculate final pixel value and store
 245          "movl 48(%ebp), %ecx           \n"
 246          "movw -16(%ebp), %ax           \n"
 247          "shlw %cl, %ax                 \n" //NP* ax = r<<roffs
 248
 249          "movl 52(%ebp), %ecx           \n"
 250          "movw -14(%ebp), %bx           \n"
 251          "shlw %cl, %bx                 \n" //NP*
 252          "orw %bx, %ax                  \n"
 253
 254          "movl 56(%ebp), %ecx           \n"
 255          "movw -12(%ebp), %bx           \n"
 256          "shlw %cl, %bx                 \n" //NP*
 257          "orw %bx, %ax                  \n"
 258
 259          "movl 12(%ebp), %edx           \n"
 260          "movw %ax, (%edx)              \n"
 261          "addl $2, %edx                 \n" // increment ximage
 262          "movl %edx, 12(%ebp)           \n"
 263
 264          // prepare for next iteration on X
 265
 266          "addl $8, -32(%ebp)            \n" // nerr += 8
 267
 268          "movl -36(%ebp), %ebx          \n"
 269          "addl $8, %ebx                 \n"
 270          "movl %ebx, -36(%ebp)          \n" // ebx = err += 8
 271
 272
 273          // Note: in the last pixel, this would cause an invalid memory access
 274          // because, punpcklbw is used (which reads 8 bytes) and the last
 275          // pixel is only 4 bytes. This is no problem because the image data
 276          // was allocated with extra 4 bytes when created.
 277          "addl $4, %esi                 \n" // image->data += 4
 278
 279
 280          "decl -4(%ebp)                 \n" // x--
 281          "jnz .LoopXa                   \n" // if x>0, goto .LoopX
 282
 283
 284          // depend on edx
 285          "addl 68(%ebp), %edx           \n" // add extra offset to ximage
 286          "movl %edx, 12(%ebp)           \n"
 287
 288
 289          "jmp .LoopYa                   \n"
 290
 291 ".Enda:                                 \n" // THE END
 292
 293          "emms                          \n"
 294
 295          "popa                          \n"
 296          );
 297 }
 298
 299
 300 #endif /* ASM_X86_MMX */
 301
 302 #if 0
 303
 304     /* convert and dither the image to XImage */
 305     for (y=0; y<image->height; y++) {
 306         nerr[0] = 0;
 307         nerr[1] = 0;
 308         nerr[2] = 0;
 309         for (x=0; x<image->width*3; x+=3, ptr+=channels) {
 310
 311             /* reduce pixel */
 312             pixel = *ptr + err[x];
 313             if (pixel<0) pixel=0; else if (pixel>0xff) pixel=0xff;
 314             r = rtable[pixel];
 315             /* calc error */
 316             rer = pixel - r*dr;
 317
 318             /* reduce pixel */
 319             pixel = *(ptr+1) + err[x+1];
 320             if (pixel<0) pixel=0; else if (pixel>0xff) pixel=0xff;
 321             g = gtable[pixel];
 322             /* calc error */
 323             ger = pixel - g*dg;
 324
 325             /* reduce pixel */
 326             pixel = *(ptr+2) + err[x+2];
 327             if (pixel<0) pixel=0; else if (pixel>0xff) pixel=0xff;
 328             b = btable[pixel];
 329             /* calc error */
 330             ber = pixel - b*db;
 331
 332             *optr++ = pixels[r*cpcpc + g*cpc + b];
 333
 334             /* distribute error */
 335             r = (rer*3)/8;
 336             g = (ger*3)/8;
 337             b = (ber*3)/8;
 338             /* x+1, y */
 339             err[x+3*1]+=r;
 340             err[x+1+3*1]+=g;
 341             err[x+2+3*1]+=b;
 342             /* x, y+1 */
 343             nerr[x]+=r;
 344             nerr[x+1]+=g;
 345             nerr[x+2]+=b;
 346             /* x+1, y+1 */
 347             nerr[x+3*1]=rer-2*r;
 348             nerr[x+1+3*1]=ger-2*g;
 349             nerr[x+2+3*1]=ber-2*b;
 350         }
 351         /* skip to next line */
 352         terr = err;
 353         err = nerr;
 354         nerr = terr;
 355
 356         optr += ximg->image->bytes_per_line - image->width;
 357     }
 358 }
 359 #endif
 360
 361
 362 void
 363 x86_PseudoColor_32_to_8(unsigned char *image, // 8
 364                         unsigned char *ximage, // 12
 365                         char *err, // 16
 366                         char *nerr, // 20
 367                         short *rtable, // 24
 368                         short *gtable, // 28
 369                         short *btable, // 32
 370                         int dr, // 36
 371                         int dg, // 40
 372                         int db, // 44
 373                         unsigned long *pixels, // 48
 374                         int cpc, // 52
 375                         int width, // 56
 376                         int height, // 60
 377                         int line_offset) // 64
 378 {
 379     asm volatile
 380         (
 381          "andl $-8, %ebp                \n"
 382          "subl $128, %esp               \n" // alloc some stack space
 383          "pusha                         \n"
 384
 385          // process 1 pixel / cycle, each component treated as 16bit
 386          "movl 8(%ebp), %esi            \n" // esi = image->data
 387
 388 ".LoopYb:                               \n"
 389          "movl 56(%ebp), %eax           \n"
 390          "movl %eax, -4(%ebp)           \n" // x = width
 391
 392          "movl 60(%ebp), %eax           \n"
 393          "decl %eax                     \n" // y--
 394          "movl %eax, 64(%ebp)           \n"
 395          "js .Endb                      \n" // if y < 0, goto end
 396          "andl $1, %eax                 \n"
 397          "jz .LoopY_1b                  \n" // if (y&1) goto LoopY_1
 398
 399 ".LoopY_0b:                             \n"
 400
 401          "movl 16(%ebp), %ebx           \n" // ebx = err
 402          "movl %ebx, -36(%ebp)          \n" // [-36] = err
 403          "movl 20(%ebp), %eax           \n" //
 404          "movl %eax, -32(%ebp)          \n" // [-32] = nerr
 405
 406          "movl $0, -32(%ebp)            \n" // init error of nerr[0] to 0
 407
 408          "jmp .LoopXb                   \n"
 409
 410 ".LoopY_1b:                             \n"
 411
 412          "movl 20(%ebp), %ebx           \n" // ebx = nerr
 413          "movl %ebx, -36(%ebp)          \n" // [-36] = nerr
 414          "movl 16(%ebp), %eax           \n" //
 415          "movl %eax, -32(%ebp)          \n" // [-32] = err
 416
 417          "movl $0, -32(%ebp)            \n" // init error of nerr[0] to 0
 418
 419 ".LoopXb:                               \n"
 420
 421          "movl (%esi), %edx             \n" // fetch a pixel
 422
 423 //       "movl                                  \n"
 424
 425
 426
 427 ".Endb:                                 \n"
 428
 429          "popa                          \n"
 430          );
 431
 432
 433 }
 434
 435 #endif /* ASM_X86 */