From 9ad5234612eb45251f32842b59c2cafcec38e9aa Mon Sep 17 00:00:00 2001 From: Pierre Ossman Date: Mon, 9 Mar 2009 13:15:56 +0000 Subject: [PATCH] Framework for supporting SIMD acceleration Designed to impose minimal changes on the "normal" code. git-svn-id: svn://svn.code.sf.net/p/tigervnc/code/trunk@3645 3789f03b-4d11-0410-bbf8-ca57d06f2519 --- common/jpeg/Makefile.am | 5 +- common/jpeg/configure.ac | 8 + common/jpeg/jccolor.c | 10 +- common/jpeg/jcdctmgr.c | 37 +++- common/jpeg/jconfig.h.in | 3 + common/jpeg/jcsample.c | 12 +- common/jpeg/jdcolor.c | 10 +- common/jpeg/jddctmgr.c | 27 ++- common/jpeg/jdmerge.c | 12 +- common/jpeg/jdsample.c | 30 +++- common/jpeg/jsimd.c | 359 +++++++++++++++++++++++++++++++++++++++ common/jpeg/jsimd.h | 89 ++++++++++ common/jpeg/jsimddct.h | 101 +++++++++++ 13 files changed, 674 insertions(+), 29 deletions(-) create mode 100644 common/jpeg/jsimd.c create mode 100644 common/jpeg/jsimd.h create mode 100644 common/jpeg/jsimddct.h diff --git a/common/jpeg/Makefile.am b/common/jpeg/Makefile.am index 7404d10b..114dd7d2 100644 --- a/common/jpeg/Makefile.am +++ b/common/jpeg/Makefile.am @@ -1,7 +1,7 @@ noinst_LTLIBRARIES = libjpeg.la HDRS = jchuff.h jdct.h jdhuff.h jerror.h jinclude.h jmemsys.h jmorecfg.h \ - jpegint.h jpeglib.h jversion.h + jpegint.h jpeglib.h jversion.h jsimd.h jsimddct.h libjpeg_la_SOURCES = $(HDRS) jcapimin.c jcapistd.c jccoefct.c jccolor.c \ jcdctmgr.c jchuff.c jcinit.c jcmainct.c jcmarker.c jcmaster.c \ @@ -10,5 +10,6 @@ libjpeg_la_SOURCES = $(HDRS) jcapimin.c jcapistd.c jccoefct.c jccolor.c \ jddctmgr.c jdhuff.c jdinput.c jdmainct.c jdmarker.c jdmaster.c \ jdmerge.c jdphuff.c jdpostct.c jdsample.c jdtrans.c jerror.c \ jfdctflt.c jfdctfst.c jfdctint.c jidctflt.c jidctfst.c jidctint.c \ - jidctred.c jquant1.c jquant2.c jutils.c jmemmgr.c jmemnobs.c + jidctred.c jquant1.c jquant2.c jutils.c jmemmgr.c jmemnobs.c \ + jsimd.c diff --git a/common/jpeg/configure.ac b/common/jpeg/configure.ac index 79bdb456..c2263f26 100644 --- a/common/jpeg/configure.ac +++ b/common/jpeg/configure.ac @@ -72,6 +72,14 @@ AC_CHECK_FUNCS([memset memcpy], [], [AC_DEFINE([NEED_BSD_STRINGS], 1, [Define if you have BSD-like bzero and bcopy])]) +# SIMD is optional +# todo: detect automatically when it can be enabled +AC_ARG_WITH([simd], + AC_HELP_STRING([--with-simd],[Include accelerated SIMD routines.])) +if test "x${with_simd}" != "xno"; then + AC_DEFINE([WITH_SIMD], [1], [Use accelerated SIMD routines.]) +fi + # jconfig.h is the file we use, but we have another before that to # fool autoheader. the reason is that we include this header in our # API headers, which can screw things up for users of the lib. diff --git a/common/jpeg/jccolor.c b/common/jpeg/jccolor.c index 0a8a4b5d..2407456c 100644 --- a/common/jpeg/jccolor.c +++ b/common/jpeg/jccolor.c @@ -2,6 +2,7 @@ * jccolor.c * * Copyright (C) 1991-1996, Thomas G. Lane. + * Copyright 2009 Pierre Ossman for Cendio AB * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * @@ -11,6 +12,7 @@ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" +#include "jsimd.h" /* Private subobject */ @@ -420,8 +422,12 @@ jinit_color_converter (j_compress_ptr cinfo) if (cinfo->num_components != 3) ERREXIT(cinfo, JERR_BAD_J_COLORSPACE); if (cinfo->in_color_space == JCS_RGB) { - cconvert->pub.start_pass = rgb_ycc_start; - cconvert->pub.color_convert = rgb_ycc_convert; + if (jsimd_can_rgb_ycc()) + cconvert->pub.color_convert = jsimd_rgb_ycc_convert; + else { + cconvert->pub.start_pass = rgb_ycc_start; + cconvert->pub.color_convert = rgb_ycc_convert; + } } else if (cinfo->in_color_space == JCS_YCbCr) cconvert->pub.color_convert = null_convert; else diff --git a/common/jpeg/jcdctmgr.c b/common/jpeg/jcdctmgr.c index 45b9c0dc..75d48e02 100644 --- a/common/jpeg/jcdctmgr.c +++ b/common/jpeg/jcdctmgr.c @@ -2,6 +2,7 @@ * jcdctmgr.c * * Copyright (C) 1994-1996, Thomas G. Lane. + * Copyright 2009 Pierre Ossman for Cendio AB * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * @@ -15,6 +16,7 @@ #include "jinclude.h" #include "jpeglib.h" #include "jdct.h" /* Private declarations for DCT subsystem */ +#include "jsimddct.h" /* Private subobject for this module */ @@ -424,19 +426,28 @@ jinit_forward_dct (j_compress_ptr cinfo) #ifdef DCT_ISLOW_SUPPORTED case JDCT_ISLOW: fdct->pub.forward_DCT = forward_DCT; - fdct->dct = jpeg_fdct_islow; + if (jsimd_can_fdct_islow()) + fdct->dct = jsimd_fdct_islow; + else + fdct->dct = jpeg_fdct_islow; break; #endif #ifdef DCT_IFAST_SUPPORTED case JDCT_IFAST: fdct->pub.forward_DCT = forward_DCT; - fdct->dct = jpeg_fdct_ifast; + if (jsimd_can_fdct_ifast()) + fdct->dct = jsimd_fdct_ifast; + else + fdct->dct = jpeg_fdct_ifast; break; #endif #ifdef DCT_FLOAT_SUPPORTED case JDCT_FLOAT: fdct->pub.forward_DCT = forward_DCT_float; - fdct->float_dct = jpeg_fdct_float; + if (jsimd_can_fdct_float()) + fdct->float_dct = jsimd_fdct_float; + else + fdct->float_dct = jpeg_fdct_float; break; #endif default: @@ -453,14 +464,26 @@ jinit_forward_dct (j_compress_ptr cinfo) case JDCT_IFAST: #endif #if defined(DCT_ISLOW_SUPPORTED) || defined(DCT_IFAST_SUPPORTED) - fdct->convsamp = convsamp; - fdct->quantize = quantize; + if (jsimd_can_convsamp()) + fdct->convsamp = jsimd_convsamp; + else + fdct->convsamp = convsamp; + if (jsimd_can_quantize()) + fdct->quantize = jsimd_quantize; + else + fdct->quantize = quantize; break; #endif #ifdef DCT_FLOAT_SUPPORTED case JDCT_FLOAT: - fdct->float_convsamp = convsamp_float; - fdct->float_quantize = quantize_float; + if (jsimd_can_convsamp_float()) + fdct->float_convsamp = jsimd_convsamp_float; + else + fdct->float_convsamp = convsamp_float; + if (jsimd_can_quantize_float()) + fdct->float_quantize = jsimd_quantize_float; + else + fdct->float_quantize = quantize_float; break; #endif default: diff --git a/common/jpeg/jconfig.h.in b/common/jpeg/jconfig.h.in index 4a106977..4e5e80ed 100644 --- a/common/jpeg/jconfig.h.in +++ b/common/jpeg/jconfig.h.in @@ -28,6 +28,9 @@ /* Define if shift is unsigned */ #undef RIGHT_SHIFT_IS_UNSIGNED +/* Use accelerated SIMD routines. */ +#undef WITH_SIMD + /* Define to 1 if type `char' is unsigned and you are not using gcc. */ #ifndef __CHAR_UNSIGNED__ # undef __CHAR_UNSIGNED__ diff --git a/common/jpeg/jcsample.c b/common/jpeg/jcsample.c index 212ec875..eea376f9 100644 --- a/common/jpeg/jcsample.c +++ b/common/jpeg/jcsample.c @@ -2,6 +2,7 @@ * jcsample.c * * Copyright (C) 1991-1996, Thomas G. Lane. + * Copyright 2009 Pierre Ossman for Cendio AB * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * @@ -48,6 +49,7 @@ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" +#include "jsimd.h" /* Pointer to routine to downsample a single component */ @@ -494,7 +496,10 @@ jinit_downsampler (j_compress_ptr cinfo) } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor && compptr->v_samp_factor == cinfo->max_v_samp_factor) { smoothok = FALSE; - downsample->methods[ci] = h2v1_downsample; + if (jsimd_can_h2v1_downsample()) + downsample->methods[ci] = jsimd_h2v1_downsample; + else + downsample->methods[ci] = h2v1_downsample; } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor && compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) { #ifdef INPUT_SMOOTHING_SUPPORTED @@ -503,7 +508,10 @@ jinit_downsampler (j_compress_ptr cinfo) downsample->pub.need_context_rows = TRUE; } else #endif - downsample->methods[ci] = h2v2_downsample; + if (jsimd_can_h2v2_downsample()) + downsample->methods[ci] = jsimd_h2v2_downsample; + else + downsample->methods[ci] = h2v2_downsample; } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 && (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) { smoothok = FALSE; diff --git a/common/jpeg/jdcolor.c b/common/jpeg/jdcolor.c index 6c04dfe8..d2d1483d 100644 --- a/common/jpeg/jdcolor.c +++ b/common/jpeg/jdcolor.c @@ -2,6 +2,7 @@ * jdcolor.c * * Copyright (C) 1991-1997, Thomas G. Lane. + * Copyright 2009 Pierre Ossman for Cendio AB * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * @@ -11,6 +12,7 @@ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" +#include "jsimd.h" /* Private subobject */ @@ -358,8 +360,12 @@ jinit_color_deconverter (j_decompress_ptr cinfo) case JCS_RGB: cinfo->out_color_components = RGB_PIXELSIZE; if (cinfo->jpeg_color_space == JCS_YCbCr) { - cconvert->pub.color_convert = ycc_rgb_convert; - build_ycc_rgb_table(cinfo); + if (jsimd_can_ycc_rgb()) + cconvert->pub.color_convert = jsimd_ycc_rgb_convert; + else { + cconvert->pub.color_convert = ycc_rgb_convert; + build_ycc_rgb_table(cinfo); + } } else if (cinfo->jpeg_color_space == JCS_GRAYSCALE) { cconvert->pub.color_convert = gray_rgb_convert; } else if (cinfo->jpeg_color_space == JCS_RGB && RGB_PIXELSIZE == 3) { diff --git a/common/jpeg/jddctmgr.c b/common/jpeg/jddctmgr.c index bbf8d0e9..52f50906 100644 --- a/common/jpeg/jddctmgr.c +++ b/common/jpeg/jddctmgr.c @@ -2,6 +2,7 @@ * jddctmgr.c * * Copyright (C) 1994-1996, Thomas G. Lane. + * Copyright 2009 Pierre Ossman for Cendio AB * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * @@ -19,6 +20,7 @@ #include "jinclude.h" #include "jpeglib.h" #include "jdct.h" /* Private declarations for DCT subsystem */ +#include "jsimddct.h" /* @@ -105,11 +107,17 @@ start_pass (j_decompress_ptr cinfo) method = JDCT_ISLOW; /* jidctred uses islow-style table */ break; case 2: - method_ptr = jpeg_idct_2x2; + if (jsimd_can_idct_2x2()) + method_ptr = jsimd_idct_2x2; + else + method_ptr = jpeg_idct_2x2; method = JDCT_ISLOW; /* jidctred uses islow-style table */ break; case 4: - method_ptr = jpeg_idct_4x4; + if (jsimd_can_idct_4x4()) + method_ptr = jsimd_idct_4x4; + else + method_ptr = jpeg_idct_4x4; method = JDCT_ISLOW; /* jidctred uses islow-style table */ break; #endif @@ -117,19 +125,28 @@ start_pass (j_decompress_ptr cinfo) switch (cinfo->dct_method) { #ifdef DCT_ISLOW_SUPPORTED case JDCT_ISLOW: - method_ptr = jpeg_idct_islow; + if (jsimd_can_idct_islow()) + method_ptr = jsimd_idct_islow; + else + method_ptr = jpeg_idct_islow; method = JDCT_ISLOW; break; #endif #ifdef DCT_IFAST_SUPPORTED case JDCT_IFAST: - method_ptr = jpeg_idct_ifast; + if (jsimd_can_idct_ifast()) + method_ptr = jsimd_idct_ifast; + else + method_ptr = jpeg_idct_ifast; method = JDCT_IFAST; break; #endif #ifdef DCT_FLOAT_SUPPORTED case JDCT_FLOAT: - method_ptr = jpeg_idct_float; + if (jsimd_can_idct_float()) + method_ptr = jsimd_idct_float; + else + method_ptr = jpeg_idct_float; method = JDCT_FLOAT; break; #endif diff --git a/common/jpeg/jdmerge.c b/common/jpeg/jdmerge.c index 37444468..77429412 100644 --- a/common/jpeg/jdmerge.c +++ b/common/jpeg/jdmerge.c @@ -2,6 +2,7 @@ * jdmerge.c * * Copyright (C) 1994-1996, Thomas G. Lane. + * Copyright 2009 Pierre Ossman for Cendio AB * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * @@ -35,6 +36,7 @@ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" +#include "jsimd.h" #ifdef UPSAMPLE_MERGING_SUPPORTED @@ -382,14 +384,20 @@ jinit_merged_upsampler (j_decompress_ptr cinfo) if (cinfo->max_v_samp_factor == 2) { upsample->pub.upsample = merged_2v_upsample; - upsample->upmethod = h2v2_merged_upsample; + if (jsimd_can_h2v2_merged_upsample()) + upsample->upmethod = jsimd_h2v2_merged_upsample; + else + upsample->upmethod = h2v2_merged_upsample; /* Allocate a spare row buffer */ upsample->spare_row = (JSAMPROW) (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE, (size_t) (upsample->out_row_width * SIZEOF(JSAMPLE))); } else { upsample->pub.upsample = merged_1v_upsample; - upsample->upmethod = h2v1_merged_upsample; + if (jsimd_can_h2v1_merged_upsample()) + upsample->upmethod = jsimd_h2v1_merged_upsample; + else + upsample->upmethod = h2v1_merged_upsample; /* No spare row needed */ upsample->spare_row = NULL; } diff --git a/common/jpeg/jdsample.c b/common/jpeg/jdsample.c index 80ffefb2..4e0b8b40 100644 --- a/common/jpeg/jdsample.c +++ b/common/jpeg/jdsample.c @@ -2,6 +2,7 @@ * jdsample.c * * Copyright (C) 1991-1996, Thomas G. Lane. + * Copyright 2009 Pierre Ossman for Cendio AB * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * @@ -21,6 +22,7 @@ #define JPEG_INTERNALS #include "jinclude.h" #include "jpeglib.h" +#include "jsimd.h" /* Pointer to routine to upsample a single component */ @@ -447,18 +449,32 @@ jinit_upsampler (j_decompress_ptr cinfo) } else if (h_in_group * 2 == h_out_group && v_in_group == v_out_group) { /* Special cases for 2h1v upsampling */ - if (do_fancy && compptr->downsampled_width > 2) - upsample->methods[ci] = h2v1_fancy_upsample; - else - upsample->methods[ci] = h2v1_upsample; + if (do_fancy && compptr->downsampled_width > 2) { + if (jsimd_can_h2v1_fancy_upsample()) + upsample->methods[ci] = jsimd_h2v1_fancy_upsample; + else + upsample->methods[ci] = h2v1_fancy_upsample; + } else { + if (jsimd_can_h2v1_upsample()) + upsample->methods[ci] = jsimd_h2v1_upsample; + else + upsample->methods[ci] = h2v1_upsample; + } } else if (h_in_group * 2 == h_out_group && v_in_group * 2 == v_out_group) { /* Special cases for 2h2v upsampling */ if (do_fancy && compptr->downsampled_width > 2) { - upsample->methods[ci] = h2v2_fancy_upsample; + if (jsimd_can_h2v2_fancy_upsample()) + upsample->methods[ci] = jsimd_h2v2_fancy_upsample; + else + upsample->methods[ci] = h2v2_fancy_upsample; upsample->pub.need_context_rows = TRUE; - } else - upsample->methods[ci] = h2v2_upsample; + } else { + if (jsimd_can_h2v2_upsample()) + upsample->methods[ci] = jsimd_h2v2_upsample; + else + upsample->methods[ci] = h2v2_upsample; + } } else if ((h_out_group % h_in_group) == 0 && (v_out_group % v_in_group) == 0) { /* Generic integral-factors upsampling method */ diff --git a/common/jpeg/jsimd.c b/common/jpeg/jsimd.c new file mode 100644 index 00000000..c6378e86 --- /dev/null +++ b/common/jpeg/jsimd.c @@ -0,0 +1,359 @@ +/* + * jsimd.c + * + * Copyright 2009 Pierre Ossman for Cendio AB + * + * Based on the x86 SIMD extension for IJG JPEG library, + * Copyright (C) 1999-2006, MIYASAKA Masaru. + * + * This file contains the interface between the "normal" portions + * of the library and the SIMD implementations. + */ + +#define JPEG_INTERNALS +#include "jinclude.h" +#include "jpeglib.h" +#include "jdct.h" + +#define JSIMD_NONE 0x00 + +static unsigned int simd_support = ~0; + +/* + * Check what SIMD accelerations are supported. + * + * FIXME: This code is racy under a multi-threaded environment. + */ +LOCAL(void) +init_simd (void) +{ + if (simd_support != ~0) + return; + + simd_support = JSIMD_NONE; +} + +GLOBAL(int) +jsimd_can_rgb_ycc (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(int) +jsimd_can_ycc_rgb (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(void) +jsimd_rgb_ycc_convert (j_compress_ptr cinfo, + JSAMPARRAY input_buf, JSAMPIMAGE output_buf, + JDIMENSION output_row, int num_rows) +{ +} + +GLOBAL(void) +jsimd_ycc_rgb_convert (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows) +{ +} + +GLOBAL(int) +jsimd_can_h2v2_downsample (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(int) +jsimd_can_h2v1_downsample (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(void) +jsimd_h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY output_data) +{ +} + +GLOBAL(void) +jsimd_h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY output_data) +{ +} + +GLOBAL(int) +jsimd_can_h2v2_upsample (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(int) +jsimd_can_h2v1_upsample (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(void) +jsimd_h2v2_upsample (j_decompress_ptr cinfo, + jpeg_component_info * compptr, + JSAMPARRAY input_data, + JSAMPARRAY * output_data_ptr) +{ +} + +GLOBAL(void) +jsimd_h2v1_upsample (j_decompress_ptr cinfo, + jpeg_component_info * compptr, + JSAMPARRAY input_data, + JSAMPARRAY * output_data_ptr) +{ +} + +GLOBAL(int) +jsimd_can_h2v2_fancy_upsample (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(int) +jsimd_can_h2v1_fancy_upsample (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(void) +jsimd_h2v2_fancy_upsample (j_decompress_ptr cinfo, + jpeg_component_info * compptr, + JSAMPARRAY input_data, + JSAMPARRAY * output_data_ptr) +{ +} + +GLOBAL(void) +jsimd_h2v1_fancy_upsample (j_decompress_ptr cinfo, + jpeg_component_info * compptr, + JSAMPARRAY input_data, + JSAMPARRAY * output_data_ptr) +{ +} + +GLOBAL(int) +jsimd_can_h2v2_merged_upsample (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(int) +jsimd_can_h2v1_merged_upsample (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(void) +jsimd_h2v2_merged_upsample (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, + JDIMENSION in_row_group_ctr, + JSAMPARRAY output_buf) +{ +} + +GLOBAL(void) +jsimd_h2v1_merged_upsample (j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, + JDIMENSION in_row_group_ctr, + JSAMPARRAY output_buf) +{ +} + +GLOBAL(int) +jsimd_can_convsamp (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(int) +jsimd_can_convsamp_float (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(void) +jsimd_convsamp (JSAMPARRAY sample_data, JDIMENSION start_col, + DCTELEM * workspace) +{ +} + +GLOBAL(void) +jsimd_convsamp_float (JSAMPARRAY sample_data, JDIMENSION start_col, + FAST_FLOAT * workspace) +{ +} + +GLOBAL(int) +jsimd_can_fdct_islow (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(int) +jsimd_can_fdct_ifast (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(int) +jsimd_can_fdct_float (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(void) +jsimd_fdct_islow (DCTELEM * data) +{ +} + +GLOBAL(void) +jsimd_fdct_ifast (DCTELEM * data) +{ +} + +GLOBAL(void) +jsimd_fdct_float (FAST_FLOAT * data) +{ +} + +GLOBAL(int) +jsimd_can_quantize (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(int) +jsimd_can_quantize_float (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(void) +jsimd_quantize (JCOEFPTR coef_block, DCTELEM * divisors, + DCTELEM * workspace) +{ +} + +GLOBAL(void) +jsimd_quantize_float (JCOEFPTR coef_block, FAST_FLOAT * divisors, + FAST_FLOAT * workspace) +{ +} + +GLOBAL(int) +jsimd_can_idct_2x2 (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(int) +jsimd_can_idct_4x4 (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(void) +jsimd_idct_2x2 (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, JSAMPARRAY output_buf, + JDIMENSION output_col) +{ +} + +GLOBAL(void) +jsimd_idct_4x4 (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, JSAMPARRAY output_buf, + JDIMENSION output_col) +{ +} + +GLOBAL(int) +jsimd_can_idct_islow (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(int) +jsimd_can_idct_ifast (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(int) +jsimd_can_idct_float (void) +{ + init_simd(); + + return 0; +} + +GLOBAL(void) +jsimd_idct_islow (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, JSAMPARRAY output_buf, + JDIMENSION output_col) +{ +} + +GLOBAL(void) +jsimd_idct_ifast (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, JSAMPARRAY output_buf, + JDIMENSION output_col) +{ +} + +GLOBAL(void) +jsimd_idct_float (j_decompress_ptr cinfo, jpeg_component_info * compptr, + JCOEFPTR coef_block, JSAMPARRAY output_buf, + JDIMENSION output_col) +{ +} + diff --git a/common/jpeg/jsimd.h b/common/jpeg/jsimd.h new file mode 100644 index 00000000..90be19ee --- /dev/null +++ b/common/jpeg/jsimd.h @@ -0,0 +1,89 @@ +/* + * jsimd.h + * + * Copyright 2009 Pierre Ossman for Cendio AB + * + * Based on the x86 SIMD extension for IJG JPEG library, + * Copyright (C) 1999-2006, MIYASAKA Masaru. + * + */ + +/* Short forms of external names for systems with brain-damaged linkers. */ + +#ifdef NEED_SHORT_EXTERNAL_NAMES +#define jsimd_can_rgb_ycc jSCanRgbYcc +#define jsimd_can_ycc_rgb jSCanYccRgb +#define jsimd_rgb_ycc_convert jSRgbYccConv +#define jsimd_ycc_rgb_convert jSYccRgbConv +#define jsimd_can_h2v2_downsample jSCanH2V2Down +#define jsimd_can_h2v1_downsample jSCanH2V1Down +#define jsimd_h2v2_downsample jSH2V2Down +#define jsimd_h2v1_downsample jSH2V1Down +#define jsimd_can_h2v2_upsample jSCanH2V2Up +#define jsimd_can_h2v1_upsample jSCanH2V1Up +#define jsimd_h2v2_upsample jSH2V2Up +#define jsimd_h2v1_upsample jSH2V1Up +#define jsimd_can_h2v2_fancy_upsample jSCanH2V2FUp +#define jsimd_can_h2v1_fancy_upsample jSCanH2V1FUp +#define jsimd_h2v2_fancy_upsample jSH2V2FUp +#define jsimd_h2v1_fancy_upsample jSH2V1FUp +#define jsimd_can_h2v2_merged_upsample jSCanH2V2MUp +#define jsimd_can_h2v1_merged_upsample jSCanH2V1MUp +#define jsimd_h2v2_merged_upsample jSH2V2MUp +#define jsimd_h2v1_merged_upsample jSH2V1MUp +#endif /* NEED_SHORT_EXTERNAL_NAMES */ + +EXTERN(int) jsimd_can_rgb_ycc JPP((void)); +EXTERN(int) jsimd_can_ycc_rgb JPP((void)); + +EXTERN(void) jsimd_rgb_ycc_convert + JPP((j_compress_ptr cinfo, + JSAMPARRAY input_buf, JSAMPIMAGE output_buf, + JDIMENSION output_row, int num_rows)); +EXTERN(void) jsimd_ycc_rgb_convert + JPP((j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION input_row, + JSAMPARRAY output_buf, int num_rows)); + +EXTERN(int) jsimd_can_h2v2_downsample JPP((void)); +EXTERN(int) jsimd_can_h2v1_downsample JPP((void)); + +EXTERN(void) jsimd_h2v2_downsample + JPP((j_compress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY output_data)); +EXTERN(void) jsimd_h2v1_downsample + JPP((j_compress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY output_data)); + +EXTERN(int) jsimd_can_h2v2_upsample JPP((void)); +EXTERN(int) jsimd_can_h2v1_upsample JPP((void)); + +EXTERN(void) jsimd_h2v2_upsample + JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)); +EXTERN(void) jsimd_h2v1_upsample + JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)); + +EXTERN(int) jsimd_can_h2v2_fancy_upsample JPP((void)); +EXTERN(int) jsimd_can_h2v1_fancy_upsample JPP((void)); + +EXTERN(void) jsimd_h2v2_fancy_upsample + JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)); +EXTERN(void) jsimd_h2v1_fancy_upsample + JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr, + JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)); + +EXTERN(int) jsimd_can_h2v2_merged_upsample JPP((void)); +EXTERN(int) jsimd_can_h2v1_merged_upsample JPP((void)); + +EXTERN(void) jsimd_h2v2_merged_upsample + JPP((j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, + JSAMPARRAY output_buf)); +EXTERN(void) jsimd_h2v1_merged_upsample + JPP((j_decompress_ptr cinfo, + JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr, + JSAMPARRAY output_buf)); + diff --git a/common/jpeg/jsimddct.h b/common/jpeg/jsimddct.h new file mode 100644 index 00000000..d73d0c49 --- /dev/null +++ b/common/jpeg/jsimddct.h @@ -0,0 +1,101 @@ +/* + * jsimddct.h + * + * Copyright 2009 Pierre Ossman for Cendio AB + * + * Based on the x86 SIMD extension for IJG JPEG library, + * Copyright (C) 1999-2006, MIYASAKA Masaru. + * + */ + +/* Short forms of external names for systems with brain-damaged linkers. */ + +#ifdef NEED_SHORT_EXTERNAL_NAMES +#define jsimd_can_convsamp jSCanConv +#define jsimd_can_convsamp_float jSCanConvF +#define jsimd_convsamp jSConv +#define jsimd_convsamp_float jSConvF +#define jsimd_can_fdct_islow jSCanFDCTIS +#define jsimd_can_fdct_ifast jSCanFDCTIF +#define jsimd_can_fdct_float jSCanFDCTFl +#define jsimd_fdct_islow jSFDCTIS +#define jsimd_fdct_ifast jSFDCTIF +#define jsimd_fdct_float jSFDCTFl +#define jsimd_can_quantize jSCanQuant +#define jsimd_can_quantize_float jSCanQuantF +#define jsimd_quantize jSQuant +#define jsimd_quantize_float jSQuantF +#define jsimd_can_idct_2x2 jSCanIDCT22 +#define jsimd_can_idct_4x4 jSCanIDCT44 +#define jsimd_idct_2x2 jSIDCT22 +#define jsimd_idct_4x4 jSIDCT44 +#define jsimd_can_idct_islow jSCanIDCTIS +#define jsimd_can_idct_ifast jSCanIDCTIF +#define jsimd_can_idct_float jSCanIDCTFl +#define jsimd_idct_islow jSIDCTIS +#define jsimd_idct_ifast jSIDCTIF +#define jsimd_idct_float jSIDCTFl +#endif /* NEED_SHORT_EXTERNAL_NAMES */ + +EXTERN(int) jsimd_can_convsamp JPP((void)); +EXTERN(int) jsimd_can_convsamp_float JPP((void)); + +EXTERN(void) jsimd_convsamp JPP((JSAMPARRAY sample_data, + JDIMENSION start_col, + DCTELEM * workspace)); +EXTERN(void) jsimd_convsamp_float JPP((JSAMPARRAY sample_data, + JDIMENSION start_col, + FAST_FLOAT * workspace)); + +EXTERN(int) jsimd_can_fdct_islow JPP((void)); +EXTERN(int) jsimd_can_fdct_ifast JPP((void)); +EXTERN(int) jsimd_can_fdct_float JPP((void)); + +EXTERN(void) jsimd_fdct_islow JPP((DCTELEM * data)); +EXTERN(void) jsimd_fdct_ifast JPP((DCTELEM * data)); +EXTERN(void) jsimd_fdct_float JPP((FAST_FLOAT * data)); + +EXTERN(int) jsimd_can_quantize JPP((void)); +EXTERN(int) jsimd_can_quantize_float JPP((void)); + +EXTERN(void) jsimd_quantize JPP((JCOEFPTR coef_block, + DCTELEM * divisors, + DCTELEM * workspace)); +EXTERN(void) jsimd_quantize_float JPP((JCOEFPTR coef_block, + FAST_FLOAT * divisors, + FAST_FLOAT * workspace)); + +EXTERN(int) jsimd_can_idct_2x2 JPP((void)); +EXTERN(int) jsimd_can_idct_4x4 JPP((void)); + +EXTERN(void) jsimd_idct_2x2 JPP((j_decompress_ptr cinfo, + jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, + JDIMENSION output_col)); +EXTERN(void) jsimd_idct_4x4 JPP((j_decompress_ptr cinfo, + jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, + JDIMENSION output_col)); + +EXTERN(int) jsimd_can_idct_islow JPP((void)); +EXTERN(int) jsimd_can_idct_ifast JPP((void)); +EXTERN(int) jsimd_can_idct_float JPP((void)); + +EXTERN(void) jsimd_idct_islow JPP((j_decompress_ptr cinfo, + jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, + JDIMENSION output_col)); +EXTERN(void) jsimd_idct_ifast JPP((j_decompress_ptr cinfo, + jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, + JDIMENSION output_col)); +EXTERN(void) jsimd_idct_float JPP((j_decompress_ptr cinfo, + jpeg_component_info * compptr, + JCOEFPTR coef_block, + JSAMPARRAY output_buf, + JDIMENSION output_col)); + -- 2.39.5