simd/mips64/jsimd.c

   1 /*
   2  * jsimd_mips64.c
   3  *
   4  * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
   5  * Copyright (C) 2009-2011, 2014, 2016, 2018, 2022, D. R. Commander.
   6  * Copyright (C) 2013-2014, MIPS Technologies, Inc., California.
   7  * Copyright (C) 2015, 2018, 2022, Matthieu Darbois.
   8  * Copyright (C) 2016-2018, Loongson Technology Corporation Limited, BeiJing.
   9  *
  10  * Based on the x86 SIMD extension for IJG JPEG library,
  11  * Copyright (C) 1999-2006, MIYASAKA Masaru.
  12  * For conditions of distribution and use, see copyright notice in jsimdext.inc
  13  *
  14  * This file contains the interface between the "normal" portions
  15  * of the library and the SIMD implementations when running on a
  16  * 64-bit MIPS architecture.
  17  */
  18
  19 #define JPEG_INTERNALS
  20 #include "../../jinclude.h"
  21 #include "../../jpeglib.h"
  22 #include "../../jsimd.h"
  23 #include "../../jdct.h"
  24 #include "../../jsimddct.h"
  25 #include "../jsimd.h"
  26
  27 #include <ctype.h>
  28
  29 static THREAD_LOCAL unsigned int simd_support = ~0;
  30
  31 #if defined(__linux__)
  32
  33 #define SOMEWHAT_SANE_PROC_CPUINFO_SIZE_LIMIT  (1024 * 1024)
  34
  35 LOCAL(int)
  36 check_feature(char *buffer, char *feature)
  37 {
  38   char *p;
  39
  40   if (*feature == 0)
  41     return 0;
  42   if (strncmp(buffer, "ASEs implemented", 16) != 0)
  43     return 0;
  44   buffer += 16;
  45   while (isspace(*buffer))
  46     buffer++;
  47
  48   /* Check if 'feature' is present in the buffer as a separate word */
  49   while ((p = strstr(buffer, feature))) {
  50     if (p > buffer && !isspace(*(p - 1))) {
  51       buffer++;
  52       continue;
  53     }
  54     p += strlen(feature);
  55     if (*p != 0 && !isspace(*p)) {
  56       buffer++;
  57       continue;
  58     }
  59     return 1;
  60   }
  61   return 0;
  62 }
  63
  64 LOCAL(int)
  65 parse_proc_cpuinfo(int bufsize)
  66 {
  67   char *buffer = (char *)malloc(bufsize);
  68   FILE *fd;
  69
  70   simd_support = 0;
  71
  72   if (!buffer)
  73     return 0;
  74
  75   fd = fopen("/proc/cpuinfo", "r");
  76   if (fd) {
  77     while (fgets(buffer, bufsize, fd)) {
  78       if (!strchr(buffer, '\n') && !feof(fd)) {
  79         /* "impossible" happened - insufficient size of the buffer! */
  80         fclose(fd);
  81         free(buffer);
  82         return 0;
  83       }
  84       if (check_feature(buffer, "loongson-mmi"))
  85         simd_support |= JSIMD_MMI;
  86     }
  87     fclose(fd);
  88   }
  89   free(buffer);
  90   return 1;
  91 }
  92
  93 #endif
  94
  95 /*
  96  * Check what SIMD accelerations are supported.
  97  */
  98 LOCAL(void)
  99 init_simd(void)
 100 {
 101 #ifndef NO_GETENV
 102   char *env = NULL;
 103 #endif
 104 #if defined(__linux__)
 105   int bufsize = 1024; /* an initial guess for the line buffer size limit */
 106 #endif
 107
 108   if (simd_support != ~0U)
 109     return;
 110
 111   simd_support = 0;
 112
 113 #if defined(__linux__)
 114   while (!parse_proc_cpuinfo(bufsize)) {
 115     bufsize *= 2;
 116     if (bufsize > SOMEWHAT_SANE_PROC_CPUINFO_SIZE_LIMIT)
 117       break;
 118   }
 119 #elif defined(__mips_loongson_vector_rev)
 120   /* Only enable MMI by default on non-Linux platforms when the compiler flags
 121    * support it. */
 122   simd_support |= JSIMD_MMI;
 123 #endif
 124
 125 #ifndef NO_GETENV
 126   /* Force different settings through environment variables */
 127   env = getenv("JSIMD_FORCEMMI");
 128   if ((env != NULL) && (strcmp(env, "1") == 0))
 129     simd_support = JSIMD_MMI;
 130   env = getenv("JSIMD_FORCENONE");
 131   if ((env != NULL) && (strcmp(env, "1") == 0))
 132     simd_support = 0;
 133 #endif
 134 }
 135
 136 GLOBAL(int)
 137 jsimd_can_rgb_ycc(void)
 138 {
 139   init_simd();
 140
 141   /* The code is optimised for these values only */
 142   if (BITS_IN_JSAMPLE != 8)
 143     return 0;
 144   if (sizeof(JDIMENSION) != 4)
 145     return 0;
 146   if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
 147     return 0;
 148
 149   if (simd_support & JSIMD_MMI)
 150     return 1;
 151
 152   return 0;
 153 }
 154
 155 GLOBAL(int)
 156 jsimd_can_rgb_gray(void)
 157 {
 158   init_simd();
 159
 160   /* The code is optimised for these values only */
 161   if (BITS_IN_JSAMPLE != 8)
 162     return 0;
 163   if (sizeof(JDIMENSION) != 4)
 164     return 0;
 165   if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
 166     return 0;
 167
 168   if (simd_support & JSIMD_MMI)
 169     return 1;
 170
 171   return 0;
 172 }
 173
 174 GLOBAL(int)
 175 jsimd_can_ycc_rgb(void)
 176 {
 177   init_simd();
 178
 179   /* The code is optimised for these values only */
 180   if (BITS_IN_JSAMPLE != 8)
 181     return 0;
 182   if (sizeof(JDIMENSION) != 4)
 183     return 0;
 184   if ((RGB_PIXELSIZE != 3) && (RGB_PIXELSIZE != 4))
 185     return 0;
 186
 187   if (simd_support & JSIMD_MMI)
 188     return 1;
 189
 190   return 0;
 191 }
 192
 193 GLOBAL(int)
 194 jsimd_can_ycc_rgb565(void)
 195 {
 196   return 0;
 197 }
 198
 199 GLOBAL(int)
 200 jsimd_c_can_null_convert(void)
 201 {
 202   return 0;
 203 }
 204
 205 GLOBAL(void)
 206 jsimd_rgb_ycc_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
 207                       JSAMPIMAGE output_buf, JDIMENSION output_row,
 208                       int num_rows)
 209 {
 210   void (*mmifct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
 211
 212   switch (cinfo->in_color_space) {
 213   case JCS_EXT_RGB:
 214     mmifct = jsimd_extrgb_ycc_convert_mmi;
 215     break;
 216   case JCS_EXT_RGBX:
 217   case JCS_EXT_RGBA:
 218     mmifct = jsimd_extrgbx_ycc_convert_mmi;
 219     break;
 220   case JCS_EXT_BGR:
 221     mmifct = jsimd_extbgr_ycc_convert_mmi;
 222     break;
 223   case JCS_EXT_BGRX:
 224   case JCS_EXT_BGRA:
 225     mmifct = jsimd_extbgrx_ycc_convert_mmi;
 226     break;
 227   case JCS_EXT_XBGR:
 228   case JCS_EXT_ABGR:
 229     mmifct = jsimd_extxbgr_ycc_convert_mmi;
 230     break;
 231   case JCS_EXT_XRGB:
 232   case JCS_EXT_ARGB:
 233     mmifct = jsimd_extxrgb_ycc_convert_mmi;
 234     break;
 235   default:
 236     mmifct = jsimd_rgb_ycc_convert_mmi;
 237     break;
 238   }
 239
 240   mmifct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
 241 }
 242
 243 GLOBAL(void)
 244 jsimd_rgb_gray_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
 245                        JSAMPIMAGE output_buf, JDIMENSION output_row,
 246                        int num_rows)
 247 {
 248   void (*mmifct) (JDIMENSION, JSAMPARRAY, JSAMPIMAGE, JDIMENSION, int);
 249
 250   switch (cinfo->in_color_space) {
 251   case JCS_EXT_RGB:
 252     mmifct = jsimd_extrgb_gray_convert_mmi;
 253     break;
 254   case JCS_EXT_RGBX:
 255   case JCS_EXT_RGBA:
 256     mmifct = jsimd_extrgbx_gray_convert_mmi;
 257     break;
 258   case JCS_EXT_BGR:
 259     mmifct = jsimd_extbgr_gray_convert_mmi;
 260     break;
 261   case JCS_EXT_BGRX:
 262   case JCS_EXT_BGRA:
 263     mmifct = jsimd_extbgrx_gray_convert_mmi;
 264     break;
 265   case JCS_EXT_XBGR:
 266   case JCS_EXT_ABGR:
 267     mmifct = jsimd_extxbgr_gray_convert_mmi;
 268     break;
 269   case JCS_EXT_XRGB:
 270   case JCS_EXT_ARGB:
 271     mmifct = jsimd_extxrgb_gray_convert_mmi;
 272     break;
 273   default:
 274     mmifct = jsimd_rgb_gray_convert_mmi;
 275     break;
 276   }
 277
 278   mmifct(cinfo->image_width, input_buf, output_buf, output_row, num_rows);
 279 }
 280
 281 GLOBAL(void)
 282 jsimd_ycc_rgb_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 283                       JDIMENSION input_row, JSAMPARRAY output_buf,
 284                       int num_rows)
 285 {
 286   void (*mmifct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY, int);
 287
 288   switch (cinfo->out_color_space) {
 289   case JCS_EXT_RGB:
 290     mmifct = jsimd_ycc_extrgb_convert_mmi;
 291     break;
 292   case JCS_EXT_RGBX:
 293   case JCS_EXT_RGBA:
 294     mmifct = jsimd_ycc_extrgbx_convert_mmi;
 295     break;
 296   case JCS_EXT_BGR:
 297     mmifct = jsimd_ycc_extbgr_convert_mmi;
 298     break;
 299   case JCS_EXT_BGRX:
 300   case JCS_EXT_BGRA:
 301     mmifct = jsimd_ycc_extbgrx_convert_mmi;
 302     break;
 303   case JCS_EXT_XBGR:
 304   case JCS_EXT_ABGR:
 305     mmifct = jsimd_ycc_extxbgr_convert_mmi;
 306     break;
 307   case JCS_EXT_XRGB:
 308   case JCS_EXT_ARGB:
 309     mmifct = jsimd_ycc_extxrgb_convert_mmi;
 310     break;
 311   default:
 312     mmifct = jsimd_ycc_rgb_convert_mmi;
 313     break;
 314   }
 315
 316   mmifct(cinfo->output_width, input_buf, input_row, output_buf, num_rows);
 317 }
 318
 319 GLOBAL(void)
 320 jsimd_ycc_rgb565_convert(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 321                          JDIMENSION input_row, JSAMPARRAY output_buf,
 322                          int num_rows)
 323 {
 324 }
 325
 326 GLOBAL(void)
 327 jsimd_c_null_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
 328                      JSAMPIMAGE output_buf, JDIMENSION output_row,
 329                      int num_rows)
 330 {
 331 }
 332
 333 GLOBAL(int)
 334 jsimd_can_h2v2_downsample(void)
 335 {
 336   init_simd();
 337
 338   /* The code is optimised for these values only */
 339   if (BITS_IN_JSAMPLE != 8)
 340     return 0;
 341   if (sizeof(JDIMENSION) != 4)
 342     return 0;
 343
 344   if (simd_support & JSIMD_MMI)
 345     return 1;
 346
 347   return 0;
 348 }
 349
 350 GLOBAL(int)
 351 jsimd_can_h2v2_smooth_downsample(void)
 352 {
 353   return 0;
 354 }
 355
 356 GLOBAL(int)
 357 jsimd_can_h2v1_downsample(void)
 358 {
 359   return 0;
 360 }
 361
 362 GLOBAL(void)
 363 jsimd_h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
 364                       JSAMPARRAY input_data, JSAMPARRAY output_data)
 365 {
 366   jsimd_h2v2_downsample_mmi(cinfo->image_width, cinfo->max_v_samp_factor,
 367                             compptr->v_samp_factor, compptr->width_in_blocks,
 368                             input_data, output_data);
 369 }
 370
 371 GLOBAL(void)
 372 jsimd_h2v2_smooth_downsample(j_compress_ptr cinfo,
 373                              jpeg_component_info *compptr,
 374                              JSAMPARRAY input_data, JSAMPARRAY output_data)
 375 {
 376 }
 377
 378 GLOBAL(void)
 379 jsimd_h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr,
 380                       JSAMPARRAY input_data, JSAMPARRAY output_data)
 381 {
 382 }
 383
 384 GLOBAL(int)
 385 jsimd_can_h2v2_upsample(void)
 386 {
 387   return 0;
 388 }
 389
 390 GLOBAL(int)
 391 jsimd_can_h2v1_upsample(void)
 392 {
 393   return 0;
 394 }
 395
 396 GLOBAL(int)
 397 jsimd_can_int_upsample(void)
 398 {
 399   return 0;
 400 }
 401
 402 GLOBAL(void)
 403 jsimd_h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 404                     JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
 405 {
 406 }
 407
 408 GLOBAL(void)
 409 jsimd_h2v1_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 410                     JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
 411 {
 412 }
 413
 414 GLOBAL(void)
 415 jsimd_int_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 416                    JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
 417 {
 418 }
 419
 420 GLOBAL(int)
 421 jsimd_can_h2v2_fancy_upsample(void)
 422 {
 423   init_simd();
 424
 425   /* The code is optimised for these values only */
 426   if (BITS_IN_JSAMPLE != 8)
 427     return 0;
 428   if (sizeof(JDIMENSION) != 4)
 429     return 0;
 430
 431   if (simd_support & JSIMD_MMI)
 432     return 1;
 433
 434   return 0;
 435 }
 436
 437 GLOBAL(int)
 438 jsimd_can_h2v1_fancy_upsample(void)
 439 {
 440   init_simd();
 441
 442   /* The code is optimised for these values only */
 443   if (BITS_IN_JSAMPLE != 8)
 444     return 0;
 445   if (sizeof(JDIMENSION) != 4)
 446     return 0;
 447
 448   if (simd_support & JSIMD_MMI)
 449     return 1;
 450
 451   return 0;
 452 }
 453
 454 GLOBAL(void)
 455 jsimd_h2v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 456                           JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
 457 {
 458   jsimd_h2v2_fancy_upsample_mmi(cinfo->max_v_samp_factor,
 459                                 compptr->downsampled_width, input_data,
 460                                 output_data_ptr);
 461 }
 462
 463 GLOBAL(void)
 464 jsimd_h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 465                           JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
 466 {
 467   jsimd_h2v1_fancy_upsample_mmi(cinfo->max_v_samp_factor,
 468                                 compptr->downsampled_width, input_data,
 469                                 output_data_ptr);
 470 }
 471
 472 GLOBAL(int)
 473 jsimd_can_h2v2_merged_upsample(void)
 474 {
 475   init_simd();
 476
 477   /* The code is optimised for these values only */
 478   if (BITS_IN_JSAMPLE != 8)
 479     return 0;
 480   if (sizeof(JDIMENSION) != 4)
 481     return 0;
 482
 483   if (simd_support & JSIMD_MMI)
 484     return 1;
 485
 486   return 0;
 487 }
 488
 489 GLOBAL(int)
 490 jsimd_can_h2v1_merged_upsample(void)
 491 {
 492   init_simd();
 493
 494   /* The code is optimised for these values only */
 495   if (BITS_IN_JSAMPLE != 8)
 496     return 0;
 497   if (sizeof(JDIMENSION) != 4)
 498     return 0;
 499
 500   if (simd_support & JSIMD_MMI)
 501     return 1;
 502
 503   return 0;
 504 }
 505
 506 GLOBAL(void)
 507 jsimd_h2v2_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 508                            JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
 509 {
 510   void (*mmifct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
 511
 512   switch (cinfo->out_color_space) {
 513   case JCS_EXT_RGB:
 514     mmifct = jsimd_h2v2_extrgb_merged_upsample_mmi;
 515     break;
 516   case JCS_EXT_RGBX:
 517   case JCS_EXT_RGBA:
 518     mmifct = jsimd_h2v2_extrgbx_merged_upsample_mmi;
 519     break;
 520   case JCS_EXT_BGR:
 521     mmifct = jsimd_h2v2_extbgr_merged_upsample_mmi;
 522     break;
 523   case JCS_EXT_BGRX:
 524   case JCS_EXT_BGRA:
 525     mmifct = jsimd_h2v2_extbgrx_merged_upsample_mmi;
 526     break;
 527   case JCS_EXT_XBGR:
 528   case JCS_EXT_ABGR:
 529     mmifct = jsimd_h2v2_extxbgr_merged_upsample_mmi;
 530     break;
 531   case JCS_EXT_XRGB:
 532   case JCS_EXT_ARGB:
 533     mmifct = jsimd_h2v2_extxrgb_merged_upsample_mmi;
 534     break;
 535   default:
 536     mmifct = jsimd_h2v2_merged_upsample_mmi;
 537     break;
 538   }
 539
 540   mmifct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
 541 }
 542
 543 GLOBAL(void)
 544 jsimd_h2v1_merged_upsample(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
 545                            JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf)
 546 {
 547   void (*mmifct) (JDIMENSION, JSAMPIMAGE, JDIMENSION, JSAMPARRAY);
 548
 549   switch (cinfo->out_color_space) {
 550   case JCS_EXT_RGB:
 551     mmifct = jsimd_h2v1_extrgb_merged_upsample_mmi;
 552     break;
 553   case JCS_EXT_RGBX:
 554   case JCS_EXT_RGBA:
 555     mmifct = jsimd_h2v1_extrgbx_merged_upsample_mmi;
 556     break;
 557   case JCS_EXT_BGR:
 558     mmifct = jsimd_h2v1_extbgr_merged_upsample_mmi;
 559     break;
 560   case JCS_EXT_BGRX:
 561   case JCS_EXT_BGRA:
 562     mmifct = jsimd_h2v1_extbgrx_merged_upsample_mmi;
 563     break;
 564   case JCS_EXT_XBGR:
 565   case JCS_EXT_ABGR:
 566     mmifct = jsimd_h2v1_extxbgr_merged_upsample_mmi;
 567     break;
 568   case JCS_EXT_XRGB:
 569   case JCS_EXT_ARGB:
 570     mmifct = jsimd_h2v1_extxrgb_merged_upsample_mmi;
 571     break;
 572   default:
 573     mmifct = jsimd_h2v1_merged_upsample_mmi;
 574     break;
 575   }
 576
 577   mmifct(cinfo->output_width, input_buf, in_row_group_ctr, output_buf);
 578 }
 579
 580 GLOBAL(int)
 581 jsimd_can_convsamp(void)
 582 {
 583   return 0;
 584 }
 585
 586 GLOBAL(int)
 587 jsimd_can_convsamp_float(void)
 588 {
 589   return 0;
 590 }
 591
 592 GLOBAL(void)
 593 jsimd_convsamp(JSAMPARRAY sample_data, JDIMENSION start_col,
 594                DCTELEM *workspace)
 595 {
 596 }
 597
 598 GLOBAL(void)
 599 jsimd_convsamp_float(JSAMPARRAY sample_data, JDIMENSION start_col,
 600                      FAST_FLOAT *workspace)
 601 {
 602 }
 603
 604 GLOBAL(int)
 605 jsimd_can_fdct_islow(void)
 606 {
 607   init_simd();
 608
 609   /* The code is optimised for these values only */
 610   if (DCTSIZE != 8)
 611     return 0;
 612   if (sizeof(DCTELEM) != 2)
 613     return 0;
 614
 615   if (simd_support & JSIMD_MMI)
 616     return 1;
 617
 618   return 0;
 619 }
 620
 621 GLOBAL(int)
 622 jsimd_can_fdct_ifast(void)
 623 {
 624   init_simd();
 625
 626   /* The code is optimised for these values only */
 627   if (DCTSIZE != 8)
 628     return 0;
 629   if (sizeof(DCTELEM) != 2)
 630     return 0;
 631
 632   if (simd_support & JSIMD_MMI)
 633     return 1;
 634
 635   return 0;
 636 }
 637
 638 GLOBAL(int)
 639 jsimd_can_fdct_float(void)
 640 {
 641   return 0;
 642 }
 643
 644 GLOBAL(void)
 645 jsimd_fdct_islow(DCTELEM *data)
 646 {
 647   jsimd_fdct_islow_mmi(data);
 648 }
 649
 650 GLOBAL(void)
 651 jsimd_fdct_ifast(DCTELEM *data)
 652 {
 653   jsimd_fdct_ifast_mmi(data);
 654 }
 655
 656 GLOBAL(void)
 657 jsimd_fdct_float(FAST_FLOAT *data)
 658 {
 659 }
 660
 661 GLOBAL(int)
 662 jsimd_can_quantize(void)
 663 {
 664   init_simd();
 665
 666   /* The code is optimised for these values only */
 667   if (DCTSIZE != 8)
 668     return 0;
 669   if (sizeof(JCOEF) != 2)
 670     return 0;
 671   if (sizeof(DCTELEM) != 2)
 672     return 0;
 673
 674   if (simd_support & JSIMD_MMI)
 675     return 1;
 676
 677   return 0;
 678 }
 679
 680 GLOBAL(int)
 681 jsimd_can_quantize_float(void)
 682 {
 683   return 0;
 684 }
 685
 686 GLOBAL(void)
 687 jsimd_quantize(JCOEFPTR coef_block, DCTELEM *divisors, DCTELEM *workspace)
 688 {
 689   jsimd_quantize_mmi(coef_block, divisors, workspace);
 690 }
 691
 692 GLOBAL(void)
 693 jsimd_quantize_float(JCOEFPTR coef_block, FAST_FLOAT *divisors,
 694                      FAST_FLOAT *workspace)
 695 {
 696 }
 697
 698 GLOBAL(int)
 699 jsimd_can_idct_2x2(void)
 700 {
 701   return 0;
 702 }
 703
 704 GLOBAL(int)
 705 jsimd_can_idct_4x4(void)
 706 {
 707   return 0;
 708 }
 709
 710 GLOBAL(int)
 711 jsimd_can_idct_6x6(void)
 712 {
 713   return 0;
 714 }
 715
 716 GLOBAL(int)
 717 jsimd_can_idct_12x12(void)
 718 {
 719   return 0;
 720 }
 721
 722 GLOBAL(void)
 723 jsimd_idct_2x2(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 724                JCOEFPTR coef_block, JSAMPARRAY output_buf,
 725                JDIMENSION output_col)
 726 {
 727 }
 728
 729 GLOBAL(void)
 730 jsimd_idct_4x4(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 731                JCOEFPTR coef_block, JSAMPARRAY output_buf,
 732                JDIMENSION output_col)
 733 {
 734 }
 735
 736 GLOBAL(void)
 737 jsimd_idct_6x6(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 738                JCOEFPTR coef_block, JSAMPARRAY output_buf,
 739                JDIMENSION output_col)
 740 {
 741 }
 742
 743 GLOBAL(void)
 744 jsimd_idct_12x12(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 745                  JCOEFPTR coef_block, JSAMPARRAY output_buf,
 746                  JDIMENSION output_col)
 747 {
 748 }
 749
 750 GLOBAL(int)
 751 jsimd_can_idct_islow(void)
 752 {
 753   init_simd();
 754
 755   /* The code is optimised for these values only */
 756   if (DCTSIZE != 8)
 757     return 0;
 758   if (sizeof(JCOEF) != 2)
 759     return 0;
 760   if (BITS_IN_JSAMPLE != 8)
 761     return 0;
 762   if (sizeof(JDIMENSION) != 4)
 763     return 0;
 764   if (sizeof(ISLOW_MULT_TYPE) != 2)
 765     return 0;
 766
 767   if (simd_support & JSIMD_MMI)
 768     return 1;
 769
 770   return 0;
 771 }
 772
 773 GLOBAL(int)
 774 jsimd_can_idct_ifast(void)
 775 {
 776   init_simd();
 777
 778   /* The code is optimised for these values only */
 779   if (DCTSIZE != 8)
 780     return 0;
 781   if (sizeof(JCOEF) != 2)
 782     return 0;
 783   if (BITS_IN_JSAMPLE != 8)
 784     return 0;
 785   if (sizeof(JDIMENSION) != 4)
 786     return 0;
 787   if (sizeof(IFAST_MULT_TYPE) != 2)
 788     return 0;
 789   if (IFAST_SCALE_BITS != 2)
 790     return 0;
 791
 792   if (simd_support & JSIMD_MMI)
 793     return 1;
 794
 795   return 0;
 796 }
 797
 798 GLOBAL(int)
 799 jsimd_can_idct_float(void)
 800 {
 801   return 0;
 802 }
 803
 804 GLOBAL(void)
 805 jsimd_idct_islow(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 806                  JCOEFPTR coef_block, JSAMPARRAY output_buf,
 807                  JDIMENSION output_col)
 808 {
 809   jsimd_idct_islow_mmi(compptr->dct_table, coef_block, output_buf, output_col);
 810 }
 811
 812 GLOBAL(void)
 813 jsimd_idct_ifast(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 814                  JCOEFPTR coef_block, JSAMPARRAY output_buf,
 815                  JDIMENSION output_col)
 816 {
 817   jsimd_idct_ifast_mmi(compptr->dct_table, coef_block, output_buf, output_col);
 818 }
 819
 820 GLOBAL(void)
 821 jsimd_idct_float(j_decompress_ptr cinfo, jpeg_component_info *compptr,
 822                  JCOEFPTR coef_block, JSAMPARRAY output_buf,
 823                  JDIMENSION output_col)
 824 {
 825 }
 826
 827 GLOBAL(int)
 828 jsimd_can_huff_encode_one_block(void)
 829 {
 830   return 0;
 831 }
 832
 833 GLOBAL(JOCTET *)
 834 jsimd_huff_encode_one_block(void *state, JOCTET *buffer, JCOEFPTR block,
 835                             int last_dc_val, c_derived_tbl *dctbl,
 836                             c_derived_tbl *actbl)
 837 {
 838   return NULL;
 839 }
 840
 841 GLOBAL(int)
 842 jsimd_can_encode_mcu_AC_first_prepare(void)
 843 {
 844   return 0;
 845 }
 846
 847 GLOBAL(void)
 848 jsimd_encode_mcu_AC_first_prepare(const JCOEF *block,
 849                                   const int *jpeg_natural_order_start, int Sl,
 850                                   int Al, UJCOEF *values, size_t *zerobits)
 851 {
 852 }
 853
 854 GLOBAL(int)
 855 jsimd_can_encode_mcu_AC_refine_prepare(void)
 856 {
 857   return 0;
 858 }
 859
 860 GLOBAL(int)
 861 jsimd_encode_mcu_AC_refine_prepare(const JCOEF *block,
 862                                    const int *jpeg_natural_order_start, int Sl,
 863                                    int Al, UJCOEF *absvalues, size_t *bits)
 864 {
 865   return 0;
 866 }