am 14d8fa03: Merge "[MIPS] Inverse DCT optimizations"
* commit '14d8fa0373cc75eea1bd8413b7757b918a4ff3c7':
[MIPS] Inverse DCT optimizations
diff --git a/Android.mk b/Android.mk
index f0e7cf1..5bb0657 100644
--- a/Android.mk
+++ b/Android.mk
@@ -36,11 +36,23 @@
LOCAL_CFLAGS += -DANDROID_TILE_BASED_DECODE
ifeq ($(TARGET_ARCH_VARIANT),x86-atom)
-LOCAL_CFLAGS += -DANDROID_INTELSSE2_IDCT
-LOCAL_SRC_FILES += jidctintelsse.c
-else
+ LOCAL_CFLAGS += -DANDROID_INTELSSE2_IDCT
+ LOCAL_SRC_FILES += jidctintelsse.c
+endif
+
# enable armv6 idct assembly
-LOCAL_CFLAGS += -DANDROID_ARMV6_IDCT
+ifeq ($(strip $(TARGET_ARCH)),arm)
+ LOCAL_CFLAGS += -DANDROID_ARMV6_IDCT
+endif
+
+# use mips assembler IDCT implementation if MIPS DSP-ASE is present
+ifeq ($(strip $(TARGET_ARCH)),mips)
+ ifeq ($(strip $(ARCH_MIPS_HAS_DSP)),true)
+ LOCAL_CFLAGS += -DANDROID_MIPS_IDCT
+ LOCAL_SRC_FILES += \
+ mips_jidctfst.c \
+ mips_idct_le.S
+ endif
endif
LOCAL_MODULE := libjpeg_static
@@ -67,3 +79,21 @@
endif
include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_ARM_MODE := arm
+LOCAL_SRC_FILES := \
+ cjpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h rdswitch.c cdjpeg.c rdtarga.c rdppm.c rdgif.c rdbmp.c
+LOCAL_MODULE:= cjpeg
+LOCAL_MODULE_TAGS := eng
+LOCAL_SHARED_LIBRARIES := libc libcutils libjpeg
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_ARM_MODE := arm
+LOCAL_SRC_FILES := \
+ djpeg.c cdjpeg.h jinclude.h jconfig.h jpeglib.h jmorecfg.h jerror.h cderror.h jversion.h cdjpeg.c wrppm.c wrgif.c wrbmp.c rdcolmap.c wrtarga.c
+LOCAL_MODULE:= djpeg
+LOCAL_MODULE_TAGS := eng
+LOCAL_SHARED_LIBRARIES := libc libcutils libjpeg
+include $(BUILD_EXECUTABLE)
diff --git a/jdct.h b/jdct.h
index 04192a2..d5d868f 100644
--- a/jdct.h
+++ b/jdct.h
@@ -27,7 +27,11 @@
*/
#if BITS_IN_JSAMPLE == 8
+#ifdef ANDROID_MIPS_IDCT
+typedef short DCTELEM; /* 16 or 32 bits is fine */
+#else
typedef int DCTELEM; /* 16 or 32 bits is fine */
+#endif
#else
typedef INT32 DCTELEM; /* must have 32 bits */
#endif
diff --git a/jddctmgr.c b/jddctmgr.c
index 97b516a..8bc9668 100644
--- a/jddctmgr.c
+++ b/jddctmgr.c
@@ -57,6 +57,10 @@
JSAMPARRAY output_buf, JDIMENSION output_col);
#endif
+#ifdef ANDROID_MIPS_IDCT
+extern void jpeg_idct_mips(j_decompress_ptr, jpeg_component_info *, JCOEFPTR, JSAMPARRAY, JDIMENSION);
+#endif
+
/*
* The decompressor input side (jdinput.c) saves away the appropriate
* quantization table for each component at the start of the first scan
@@ -164,7 +168,14 @@
method_ptr = jpeg_idct_intelsse;
method = JDCT_ISLOW; /* Use quant table of ISLOW.*/
break;
-#else
+#else /* ANDROID_INTELSSE2_IDCT */
+#ifdef ANDROID_MIPS_IDCT
+ case JDCT_ISLOW:
+ case JDCT_IFAST:
+ method_ptr = jpeg_idct_mips;
+ method = JDCT_IFAST;
+ break;
+#else /* ANDROID_MIPS_IDCT */
#ifdef DCT_ISLOW_SUPPORTED
case JDCT_ISLOW:
method_ptr = jpeg_idct_islow;
@@ -177,6 +188,7 @@
method = JDCT_IFAST;
break;
#endif
+#endif /* ANDROID_MIPS_IDCT */
#endif /* ANDROID_INTELSSE2_IDCT*/
#endif /* ANDROID_ARMV6_IDCT */
#ifdef DCT_FLOAT_SUPPORTED
diff --git a/jmorecfg.h b/jmorecfg.h
index b9d3f7f..b327264 100644
--- a/jmorecfg.h
+++ b/jmorecfg.h
@@ -367,7 +367,11 @@
#ifdef ANDROID_INTELSSE2_IDCT
#define MULTIPLIER short
#else
- #define MULTIPLIER int /* type for fastest integer multiply */
+ #ifdef ANDROID_MIPS_IDCT
+ #define MULTIPLIER short
+ #else
+ #define MULTIPLIER int /* type for fastest integer multiply */
+ #endif
#endif
#endif
diff --git a/mips_idct_le.S b/mips_idct_le.S
new file mode 100644
index 0000000..bdb6ffa
--- /dev/null
+++ b/mips_idct_le.S
@@ -0,0 +1,547 @@
+#
+# Copyright (C) 2011 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# IDCT implementation using the MIPS DSP ASE (little endian version)
+#
+# See MIPS Technologies Inc documents:
+# "JPEG Decoder Optimization for MIPS32(R) Cores" MD00483
+#
+# "MIPS32(R) Architecture for Programmers Volume IV-e: The MIPS(R) DSP
+# Application Specifice Extension to the MIPS32(R) Architecture" MD00374
+#
+
+ .set noreorder
+ .set nomacro
+ .set noat
+
+# This table has been moved to mips_jidctfst.c to avoid having to mess
+# with the global pointer to make this code PIC.
+# .rdata
+#
+# mips_idct_coefs:
+# # Constant table of scaled IDCT coefficients.
+#
+# .word 0x45464546 # FIX( 1.082392200 / 2) = 17734 = 0x4546
+# .word 0x5A825A82 # FIX( 1.414213562 / 2) = 23170 = 0x5A82
+# .word 0x76427642 # FIX( 1.847759065 / 2) = 30274 = 0x7642
+# .word 0xAC61AC61 # FIX(-2.613125930 / 4) = -21407 = 0xAC61
+
+ .text
+
+ .global mips_idct_columns
+ .ent mips_idct_columns
+
+# void mips_idct_columns(JCOEF * inptr, IFAST_MULT_TYPE * quantptr,
+# DCTELEM * wsptr, const int * mips_idct_coefs);
+
+mips_idct_columns:
+
+# $a0 - inptr
+# $a1 - quantptr
+# $a2 - wsptr
+# $a3, $at - mips_idct_coefs
+# $t0:7 - simd data
+# $t8 - coefficients, temp
+# $t9 - loop end address
+# $s0:3 - simd quantization factors
+# $s4:7 - temp results
+# $v0:1 - temp results
+
+ addiu $sp, $sp, -32 # reserve stack space for s0-s7
+
+ sw $s0, 28($sp)
+ sw $s1, 24($sp)
+ sw $s2, 20($sp)
+ sw $s3, 16($sp)
+ sw $s4, 12($sp)
+ sw $s5, 8($sp)
+ sw $s6, 4($sp)
+ sw $s7, 0($sp)
+
+ addiu $t9, $a0, 16 # end address
+
+ #lui $at, %hi(mips_idct_coefs)
+ #ori $at, %lo(mips_idct_coefs)
+ # move mips_idct_coefs address from $a3 into $at where the rest of this code expects it
+ or $at, $a3, $zero
+
+loop_columns:
+
+ lw $s0, 0($a1) # quantptr[DCTSIZE*0]
+
+ lw $t0, 0($a0) # inptr[DCTSIZE*0]
+ lw $t1, 16($a0) # inptr[DCTSIZE*1]
+
+ muleq_s.w.phl $v0, $t0, $s0 # tmp0 ...
+
+ lw $t2, 32($a0) # inptr[DCTSIZE*2]
+ lw $t3, 48($a0) # inptr[DCTSIZE*3]
+ lw $t4, 64($a0) # inptr[DCTSIZE*4]
+ lw $t5, 80($a0) # inptr[DCTSIZE*5]
+
+ muleq_s.w.phr $t0, $t0, $s0 # ... tmp0 ...
+
+ lw $t6, 96($a0) # inptr[DCTSIZE*6]
+ lw $t7, 112($a0) # inptr[DCTSIZE*7]
+
+ or $s4, $t1, $t2
+ or $s5, $t3, $t4
+
+ bnez $s4, full_column
+ ins $t0, $v0, 16, 16 # ... tmp0
+
+ bnez $s5, full_column
+ or $s6, $t5, $t6
+ or $s6, $s6, $t7
+ bnez $s6, full_column
+
+ sw $t0, 0($a2) # wsptr[DCTSIZE*0]
+ sw $t0, 16($a2) # wsptr[DCTSIZE*1]
+ sw $t0, 32($a2) # wsptr[DCTSIZE*2]
+ sw $t0, 48($a2) # wsptr[DCTSIZE*3]
+ sw $t0, 64($a2) # wsptr[DCTSIZE*4]
+ sw $t0, 80($a2) # wsptr[DCTSIZE*5]
+ sw $t0, 96($a2) # wsptr[DCTSIZE*6]
+ sw $t0, 112($a2) # wsptr[DCTSIZE*7]
+
+ addiu $a0, $a0, 4
+
+ b continue_columns
+ addiu $a1, $a1, 4
+
+
+full_column:
+
+ lw $s1, 32($a1) # quantptr[DCTSIZE*2]
+ lw $s2, 64($a1) # quantptr[DCTSIZE*4]
+
+ muleq_s.w.phl $v0, $t2, $s1 # tmp1 ...
+ muleq_s.w.phr $t2, $t2, $s1 # ... tmp1 ...
+
+ lw $s0, 16($a1) # quantptr[DCTSIZE*1]
+ lw $s1, 48($a1) # quantptr[DCTSIZE*3]
+ lw $s3, 96($a1) # quantptr[DCTSIZE*6]
+
+ muleq_s.w.phl $v1, $t4, $s2 # tmp2 ...
+ muleq_s.w.phr $t4, $t4, $s2 # ... tmp2 ...
+
+ lw $s2, 80($a1) # quantptr[DCTSIZE*5]
+ lw $t8, 4($at) # FIX(1.414213562)
+ ins $t2, $v0, 16, 16 # ... tmp1
+
+ muleq_s.w.phl $v0, $t6, $s3 # tmp3 ...
+ muleq_s.w.phr $t6, $t6, $s3 # ... tmp3 ...
+
+ ins $t4, $v1, 16, 16 # ... tmp2
+
+ addq.ph $s4, $t0, $t4 # tmp10
+ subq.ph $s5, $t0, $t4 # tmp11
+
+ ins $t6, $v0, 16, 16 # ... tmp3
+
+ subq.ph $s6, $t2, $t6 # tmp12 ...
+ addq.ph $s7, $t2, $t6 # tmp13
+
+ mulq_rs.ph $s6, $s6, $t8 # ... tmp12 ...
+
+ addq.ph $t0, $s4, $s7 # tmp0
+ subq.ph $t6, $s4, $s7 # tmp3
+
+################
+
+ muleq_s.w.phl $v0, $t1, $s0 # tmp4 ...
+ muleq_s.w.phr $t1, $t1, $s0 # ... tmp4 ...
+
+ shll_s.ph $s6, $s6, 1 # x2
+
+ lw $s3, 112($a1) # quantptr[DCTSIZE*7]
+
+ subq.ph $s6, $s6, $s7 # ... tmp12
+
+ muleq_s.w.phl $v1, $t7, $s3 # tmp7 ...
+ muleq_s.w.phr $t7, $t7, $s3 # ... tmp7 ...
+
+ ins $t1, $v0, 16, 16 # ... tmp4
+
+ addq.ph $t2, $s5, $s6 # tmp1
+ subq.ph $t4, $s5, $s6 # tmp2
+
+ muleq_s.w.phl $v0, $t5, $s2 # tmp6 ...
+ muleq_s.w.phr $t5, $t5, $s2 # ... tmp6 ...
+
+ ins $t7, $v1, 16, 16 # ... tmp7
+
+ addq.ph $s5, $t1, $t7 # z11
+ subq.ph $s6, $t1, $t7 # z12
+
+ muleq_s.w.phl $v1, $t3, $s1 # tmp5 ...
+ muleq_s.w.phr $t3, $t3, $s1 # ... tmp5 ...
+
+ ins $t5, $v0, 16, 16 # ... tmp6
+
+# stalls
+
+ ins $t3, $v1, 16, 16 # ... tmp5
+
+
+ addq.ph $s7, $t5, $t3 # z13
+ subq.ph $v0, $t5, $t3 # z10
+
+ addq.ph $t7, $s5, $s7 # tmp7
+ subq.ph $s5, $s5, $s7 # tmp11 ...
+
+ addq.ph $v1, $v0, $s6 # z5 ...
+
+ mulq_rs.ph $s5, $s5, $t8 # ... tmp11
+
+ lw $t8, 8($at) # FIX(1.847759065)
+ lw $s4, 0($at) # FIX(1.082392200)
+
+ addq.ph $s0, $t0, $t7
+ subq.ph $s1, $t0, $t7
+
+ mulq_rs.ph $v1, $v1, $t8 # ... z5
+
+ shll_s.ph $s5, $s5, 1 # x2
+
+ lw $t8, 12($at) # FIX(-2.613125930)
+ sw $s0, 0($a2) # wsptr[DCTSIZE*0]
+
+ mulq_rs.ph $v0, $v0, $t8 # tmp12 ...
+ mulq_rs.ph $s4, $s6, $s4 # tmp10 ...
+
+ shll_s.ph $v1, $v1, 1 # x2
+
+ addiu $a0, $a0, 4
+ addiu $a1, $a1, 4
+
+ sw $s1, 112($a2) # wsptr[DCTSIZE*7]
+
+ shll_s.ph $s6, $v0, 2 # x4
+ shll_s.ph $s4, $s4, 1 # x2
+ addq.ph $s6, $s6, $v1 # ... tmp12
+
+ subq.ph $t5, $s6, $t7 # tmp6
+ subq.ph $s4, $s4, $v1 # ... tmp10
+ subq.ph $t3, $s5, $t5 # tmp5
+ addq.ph $s2, $t2, $t5
+ addq.ph $t1, $s4, $t3 # tmp4
+ subq.ph $s3, $t2, $t5
+
+ sw $s2, 16($a2) # wsptr[DCTSIZE*1]
+ sw $s3, 96($a2) # wsptr[DCTSIZE*6]
+
+ addq.ph $v0, $t4, $t3
+ subq.ph $v1, $t4, $t3
+
+ sw $v0, 32($a2) # wsptr[DCTSIZE*2]
+ sw $v1, 80($a2) # wsptr[DCTSIZE*5]
+
+ addq.ph $v0, $t6, $t1
+ subq.ph $v1, $t6, $t1
+
+ sw $v0, 64($a2) # wsptr[DCTSIZE*4]
+ sw $v1, 48($a2) # wsptr[DCTSIZE*3]
+
+continue_columns:
+
+ bne $a0, $t9, loop_columns
+ addiu $a2, $a2, 4
+
+
+ lw $s0, 28($sp)
+ lw $s1, 24($sp)
+ lw $s2, 20($sp)
+ lw $s3, 16($sp)
+ lw $s4, 12($sp)
+ lw $s5, 8($sp)
+ lw $s6, 4($sp)
+ lw $s7, 0($sp)
+
+ jr $ra
+ addiu $sp, $sp, 32
+
+
+ .end mips_idct_columns
+
+
+##################################################################
+
+
+ .global mips_idct_rows
+ .ent mips_idct_rows
+
+# void mips_idct_rows(DCTELEM * wsptr, JSAMPARRAY output_buf,
+# JDIMENSION output_col, const int * mips_idct_coefs);
+
+mips_idct_rows:
+
+# $a0 - wsptr
+# $a1 - output_buf
+# $a2 - output_col
+# $a3 - outptr
+# $a3, $at - mips_idct_coefs
+# $t0:7 - simd data
+# $t8 - coefficients, temp
+# $t9 - loop end address
+# $s0:3 - simd quantization factors
+# $s4:7 - temp results
+# s8 - const 0x80808080
+# $v0:1 - temp results
+
+SHIFT = 2
+
+ addiu $sp, $sp, -48 # reserve stack space for s0-s8
+
+ # save $a3 (mips_idct_coefs) because it might get clobbered below
+ sw $a3, 36($sp)
+
+ sw $s0, 32($sp)
+ sw $s1, 28($sp)
+ sw $s2, 24($sp)
+ sw $s3, 20($sp)
+ sw $s4, 16($sp)
+ sw $s5, 12($sp)
+ sw $s6, 8($sp)
+ sw $s7, 4($sp)
+ sw $s8, 0($sp)
+
+ addiu $t9, $a0, 128 # end address
+
+ lui $s8, 0x8080
+ ori $s8, $s8, 0x8080
+
+loop_rows:
+
+ lw $at, 36($sp) # restore saved $a3 (mips_idct_coefs)
+
+ lw $t0, 0+0($a0) # wsptr[DCTSIZE*0+0/1] b a
+ lw $s0, 16+0($a0) # wsptr[DCTSIZE*1+0/1] B A
+ lw $t2, 0+4($a0) # wsptr[DCTSIZE*0+2/3] d c
+ lw $s2, 16+4($a0) # wsptr[DCTSIZE*1+2/3] D C
+ lw $t4, 0+8($a0) # wsptr[DCTSIZE*0+4/5] f e
+ lw $s4, 16+8($a0) # wsptr[DCTSIZE*1+4/5] F E
+ lw $t6, 0+12($a0) # wsptr[DCTSIZE*0+6/7] h g
+ lw $s6, 16+12($a0) # wsptr[DCTSIZE*1+6/7] H G
+
+ precrq.ph.w $t1, $s0, $t0 # B b
+ ins $t0, $s0, 16, 16 # A a
+
+ bnez $t1, full_row
+ or $s0, $t2, $s2
+ bnez $s0, full_row
+ or $s0, $t4, $s4
+ bnez $s0, full_row
+ or $s0, $t6, $s6
+ bnez $s0, full_row
+
+ shll_s.ph $s0, $t0, SHIFT # A a
+
+ lw $a3, 0($a1)
+ lw $at, 4($a1)
+
+ precrq.ph.w $t0, $s0, $s0 # A A
+ ins $s0, $s0, 16, 16 # a a
+
+ addu $a3, $a3, $a2
+ addu $at, $at, $a2
+
+ precrq.qb.ph $t0, $t0, $t0 # A A A A
+ precrq.qb.ph $s0, $s0, $s0 # a a a a
+
+
+ addu.qb $s0, $s0, $s8
+ addu.qb $t0, $t0, $s8
+
+
+ sw $s0, 0($a3)
+ sw $s0, 4($a3)
+
+ sw $t0, 0($at)
+ sw $t0, 4($at)
+
+
+ addiu $a0, $a0, 32
+
+ bne $a0, $t9, loop_rows
+ addiu $a1, $a1, 8
+
+ b exit_rows
+ nop
+
+
+full_row:
+
+ precrq.ph.w $t3, $s2, $t2
+ ins $t2, $s2, 16, 16
+
+ precrq.ph.w $t5, $s4, $t4
+ ins $t4, $s4, 16, 16
+
+ precrq.ph.w $t7, $s6, $t6
+ ins $t6, $s6, 16, 16
+
+
+ lw $t8, 4($at) # FIX(1.414213562)
+
+ addq.ph $s4, $t0, $t4 # tmp10
+ subq.ph $s5, $t0, $t4 # tmp11
+
+ subq.ph $s6, $t2, $t6 # tmp12 ...
+ addq.ph $s7, $t2, $t6 # tmp13
+
+ mulq_rs.ph $s6, $s6, $t8 # ... tmp12 ...
+
+ addq.ph $t0, $s4, $s7 # tmp0
+ subq.ph $t6, $s4, $s7 # tmp3
+
+ shll_s.ph $s6, $s6, 1 # x2
+
+ subq.ph $s6, $s6, $s7 # ... tmp12
+
+ addq.ph $t2, $s5, $s6 # tmp1
+ subq.ph $t4, $s5, $s6 # tmp2
+
+################
+
+ addq.ph $s5, $t1, $t7 # z11
+ subq.ph $s6, $t1, $t7 # z12
+
+ addq.ph $s7, $t5, $t3 # z13
+ subq.ph $v0, $t5, $t3 # z10
+
+ addq.ph $t7, $s5, $s7 # tmp7
+ subq.ph $s5, $s5, $s7 # tmp11 ...
+
+ addq.ph $v1, $v0, $s6 # z5 ...
+
+ mulq_rs.ph $s5, $s5, $t8 # ... tmp11
+
+ lw $t8, 8($at) # FIX(1.847759065)
+ lw $s4, 0($at) # FIX(1.082392200)
+
+ addq.ph $s0, $t0, $t7 # tmp0 + tmp7
+ subq.ph $s7, $t0, $t7 # tmp0 - tmp7
+
+ mulq_rs.ph $v1, $v1, $t8 # ... z5
+
+ lw $a3, 0($a1)
+ lw $t8, 12($at) # FIX(-2.613125930)
+
+ shll_s.ph $s5, $s5, 1 # x2
+
+ addu $a3, $a3, $a2
+
+ mulq_rs.ph $v0, $v0, $t8 # tmp12 ...
+ mulq_rs.ph $s4, $s6, $s4 # tmp10 ...
+
+ shll_s.ph $v1, $v1, 1 # x2
+
+ addiu $a0, $a0, 32
+ addiu $a1, $a1, 8
+
+
+ shll_s.ph $s6, $v0, 2 # x4
+ shll_s.ph $s4, $s4, 1 # x2
+ addq.ph $s6, $s6, $v1 # ... tmp12
+
+ shll_s.ph $s0, $s0, SHIFT
+
+ subq.ph $t5, $s6, $t7 # tmp6
+ subq.ph $s4, $s4, $v1 # ... tmp10
+ subq.ph $t3, $s5, $t5 # tmp5
+
+ shll_s.ph $s7, $s7, SHIFT
+
+ addq.ph $t1, $s4, $t3 # tmp4
+
+
+ addq.ph $s1, $t2, $t5 # tmp1 + tmp6
+ subq.ph $s6, $t2, $t5 # tmp1 - tmp6
+
+ addq.ph $s2, $t4, $t3 # tmp2 + tmp5
+ subq.ph $s5, $t4, $t3 # tmp2 - tmp5
+
+ addq.ph $s4, $t6, $t1 # tmp3 + tmp4
+ subq.ph $s3, $t6, $t1 # tmp3 - tmp4
+
+
+ shll_s.ph $s1, $s1, SHIFT
+ shll_s.ph $s2, $s2, SHIFT
+ shll_s.ph $s3, $s3, SHIFT
+ shll_s.ph $s4, $s4, SHIFT
+ shll_s.ph $s5, $s5, SHIFT
+ shll_s.ph $s6, $s6, SHIFT
+
+
+ precrq.ph.w $t0, $s1, $s0 # B A
+ ins $s0, $s1, 16, 16 # b a
+
+ precrq.ph.w $t2, $s3, $s2 # D C
+ ins $s2, $s3, 16, 16 # d c
+
+ precrq.ph.w $t4, $s5, $s4 # F E
+ ins $s4, $s5, 16, 16 # f e
+
+ precrq.ph.w $t6, $s7, $s6 # H G
+ ins $s6, $s7, 16, 16 # h g
+
+ precrq.qb.ph $t0, $t2, $t0 # D C B A
+ precrq.qb.ph $s0, $s2, $s0 # d c b a
+
+ precrq.qb.ph $t4, $t6, $t4 # H G F E
+ precrq.qb.ph $s4, $s6, $s4 # h g f e
+
+
+ addu.qb $s0, $s0, $s8
+ addu.qb $s4, $s4, $s8
+
+
+ sw $s0, 0($a3) # outptr[0/1/2/3] d c b a
+ sw $s4, 4($a3) # outptr[4/5/6/7] h g f e
+
+ lw $a3, -4($a1)
+
+ addu.qb $t0, $t0, $s8
+
+ addu $a3, $a3, $a2
+
+ addu.qb $t4, $t4, $s8
+
+
+ sw $t0, 0($a3) # outptr[0/1/2/3] D C B A
+
+ bne $a0, $t9, loop_rows
+ sw $t4, 4($a3) # outptr[4/5/6/7] H G F E
+
+
+exit_rows:
+
+ lw $s0, 32($sp)
+ lw $s1, 28($sp)
+ lw $s2, 24($sp)
+ lw $s3, 20($sp)
+ lw $s4, 16($sp)
+ lw $s5, 12($sp)
+ lw $s6, 8($sp)
+ lw $s7, 4($sp)
+ lw $s8, 0($sp)
+
+ jr $ra
+ addiu $sp, $sp, 48
+
+
+ .end mips_idct_rows
diff --git a/mips_jidctfst.c b/mips_jidctfst.c
new file mode 100644
index 0000000..1207575
--- /dev/null
+++ b/mips_jidctfst.c
@@ -0,0 +1,208 @@
+/*
+ * IDCT implementation using the MIPS DSP ASE (little endian version)
+ *
+ * jidctfst.c
+ *
+ * Copyright (C) 1994-1998, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains a fast, not so accurate integer implementation of the
+ * inverse DCT (Discrete Cosine Transform). In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time). Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT. Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README). The following code
+ * is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs. These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries. The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with fixed-point math,
+ * accuracy is lost due to imprecise representation of the scaled
+ * quantization values. The smaller the quantization table entry, the less
+ * precise the scaled value, so this implementation does worse with high-
+ * quality-setting files than with low-quality ones.
+ */
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h" /* Private declarations for DCT subsystem */
+
+#ifdef DCT_IFAST_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+ Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Scaling decisions are generally the same as in the LL&M algorithm;
+ * see jidctint.c for more details. However, we choose to descale
+ * (right shift) multiplication products as soon as they are formed,
+ * rather than carrying additional fractional bits into subsequent additions.
+ * This compromises accuracy slightly, but it lets us save a few shifts.
+ * More importantly, 16-bit arithmetic is then adequate (for 8-bit samples)
+ * everywhere except in the multiplications proper; this saves a good deal
+ * of work on 16-bit-int machines.
+ *
+ * The dequantized coefficients are not integers because the AA&N scaling
+ * factors have been incorporated. We represent them scaled up by PASS1_BITS,
+ * so that the first and second IDCT rounds have the same input scaling.
+ * For 8-bit JSAMPLEs, we choose IFAST_SCALE_BITS = PASS1_BITS so as to
+ * avoid a descaling shift; this compromises accuracy rather drastically
+ * for small quantization table entries, but it saves a lot of shifts.
+ * For 12-bit JSAMPLEs, there's no hope of using 16x16 multiplies anyway,
+ * so we use a much larger scaling factor to preserve accuracy.
+ *
+ * A final compromise is to represent the multiplicative constants to only
+ * 8 fractional bits, rather than 13. This saves some shifting work on some
+ * machines, and may also reduce the cost of multiplication (since there
+ * are fewer one-bits in the constants).
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define CONST_BITS 8
+#define PASS1_BITS 2
+#else
+#define CONST_BITS 8
+#define PASS1_BITS 1 /* lose a little precision to avoid overflow */
+#endif
+
+/* Some C compilers fail to reduce "FIX(constant)" at compile time, thus
+ * causing a lot of useless floating-point operations at run time.
+ * To get around this we use the following pre-calculated constants.
+ * If you change CONST_BITS you may want to add appropriate values.
+ * (With a reasonable C compiler, you can just rely on the FIX() macro...)
+ */
+
+#if CONST_BITS == 8
+#define FIX_1_082392200 ((INT32) 277) /* FIX(1.082392200) */
+#define FIX_1_414213562 ((INT32) 362) /* FIX(1.414213562) */
+#define FIX_1_847759065 ((INT32) 473) /* FIX(1.847759065) */
+#define FIX_2_613125930 ((INT32) 669) /* FIX(2.613125930) */
+#else
+#define FIX_1_082392200 FIX(1.082392200)
+#define FIX_1_414213562 FIX(1.414213562)
+#define FIX_1_847759065 FIX(1.847759065)
+#define FIX_2_613125930 FIX(2.613125930)
+#endif
+
+
+/* We can gain a little more speed, with a further compromise in accuracy,
+ * by omitting the addition in a descaling shift. This yields an incorrectly
+ * rounded result half the time...
+ */
+
+#ifndef USE_ACCURATE_ROUNDING
+#undef DESCALE
+#define DESCALE(x,n) RIGHT_SHIFT(x, n)
+#endif
+
+
+/* Multiply a DCTELEM variable by an INT32 constant, and immediately
+ * descale to yield a DCTELEM result.
+ */
+
+#define MULTIPLY(var,const) ((DCTELEM) DESCALE((var) * (const), CONST_BITS))
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce a DCTELEM result. For 8-bit data a 16x16->16
+ * multiplication will do. For 12-bit data, the multiplier table is
+ * declared INT32, so a 32-bit multiply will be used.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+#define DEQUANTIZE(coef,quantval) (((IFAST_MULT_TYPE) (coef)) * (quantval))
+#else
+#define DEQUANTIZE(coef,quantval) \
+ DESCALE((coef)*(quantval), IFAST_SCALE_BITS-PASS1_BITS)
+#endif
+
+
+/* Like DESCALE, but applies to a DCTELEM and produces an int.
+ * We assume that int right shift is unsigned if INT32 right shift is.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define ISHIFT_TEMPS DCTELEM ishift_temp;
+#if BITS_IN_JSAMPLE == 8
+#define DCTELEMBITS 16 /* DCTELEM may be 16 or 32 bits */
+#else
+#define DCTELEMBITS 32 /* DCTELEM must be 32 bits */
+#endif
+#define IRIGHT_SHIFT(x,shft) \
+ ((ishift_temp = (x)) < 0 ? \
+ (ishift_temp >> (shft)) | ((~((DCTELEM) 0)) << (DCTELEMBITS-(shft))) : \
+ (ishift_temp >> (shft)))
+#else
+#define ISHIFT_TEMPS
+#define IRIGHT_SHIFT(x,shft) ((x) >> (shft))
+#endif
+
+#ifdef USE_ACCURATE_ROUNDING
+#define IDESCALE(x,n) ((int) IRIGHT_SHIFT((x) + (1 << ((n)-1)), n))
+#else
+#define IDESCALE(x,n) ((int) IRIGHT_SHIFT(x, n))
+#endif
+
+
+// this table of constants has been moved from mips_idct_le/_be.s to
+// avoid having to make the assembler code position independent
+static const int mips_idct_coefs[4] = {
+ 0x45464546, // FIX( 1.082392200 / 2) = 17734 = 0x4546
+ 0x5A825A82, // FIX( 1.414213562 / 2) = 23170 = 0x5A82
+ 0x76427642, // FIX( 1.847759065 / 2) = 30274 = 0x7642
+ 0xAC61AC61 // FIX(-2.613125930 / 4) = -21407 = 0xAC61
+};
+
+void mips_idct_columns(JCOEF * inptr, IFAST_MULT_TYPE * quantptr,
+ DCTELEM * wsptr, const int * mips_idct_coefs);
+void mips_idct_rows(DCTELEM * wsptr, JSAMPARRAY output_buf,
+ JDIMENSION output_col, const int * mips_idct_coefs);
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ */
+
+GLOBAL(void)
+jpeg_idct_mips (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+ JCOEFPTR coef_block,
+ JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+ JCOEFPTR inptr;
+ IFAST_MULT_TYPE * quantptr;
+ DCTELEM workspace[DCTSIZE2]; /* buffers data between passes */
+
+ /* Pass 1: process columns from input, store into work array. */
+
+ inptr = coef_block;
+ quantptr = (IFAST_MULT_TYPE *) compptr->dct_table;
+
+ mips_idct_columns(inptr, quantptr, workspace, mips_idct_coefs);
+
+ /* Pass 2: process rows from work array, store into output array. */
+ /* Note that we must descale the results by a factor of 8 == 2**3, */
+ /* and also undo the PASS1_BITS scaling. */
+
+ mips_idct_rows(workspace, output_buf, output_col, mips_idct_coefs);
+
+}
+
+#endif /* DCT_IFAST_SUPPORTED */
