kc3-lang/libjpeg-turbo/simd/jquant-mmx.asm

• Show log

  Commit

• Hash : bd49803f
  Author :
  Date : 2016-02-19T08:53:33
  

  Use consistent/modern code formatting for pointers
  
  The convention used by libjpeg:
  
      type * variable;
  
  is not very common anymore, because it looks too much like
  multiplication.  Some (particularly C++ programmers) prefer to tuck the
  pointer symbol against the type:
  
      type* variable;
  
  to emphasize that a pointer to a type is effectively a new type.
  However, this can also be confusing, since defining multiple variables
  on the same line would not work properly:
  
      type* variable1, variable2;  /* Only variable1 is actually a
                                      pointer. */
  
  This commit reformats the entirety of the libjpeg-turbo code base so
  that it uses the same code formatting convention for pointers that the
  TurboJPEG API code uses:
  
      type *variable1, *variable2;
  
  This seems to be the most common convention among C programmers, and
  it is the convention used by other codec libraries, such as libpng and
  libtiff.
  

Download

• simd/jquant-mmx.asm

• ;
  ; jquant.asm - sample data conversion and quantization (MMX)
  ;
  ; Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
  ;
  ; Based on
  ; x86 SIMD extension for IJG JPEG library
  ; Copyright (C) 1999-2006, MIYASAKA Masaru.
  ; For conditions of distribution and use, see copyright notice in jsimdext.inc
  ;
  ; This file should be assembled with NASM (Netwide Assembler),
  ; can *not* be assembled with Microsoft's MASM or any compatible
  ; assembler (including Borland's Turbo Assembler).
  ; NASM is available from http://nasm.sourceforge.net/ or
  ; http://sourceforge.net/project/showfiles.php?group_id=6208
  ;
  ; [TAB8]
  
  %include "jsimdext.inc"
  %include "jdct.inc"
  
  ; --------------------------------------------------------------------------
          SECTION SEG_TEXT
          BITS    32
  ;
  ; Load data into workspace, applying unsigned->signed conversion
  ;
  ; GLOBAL(void)
  ; jsimd_convsamp_mmx (JSAMPARRAY sample_data, JDIMENSION start_col,
  ;                     DCTELEM *workspace);
  ;
  
  %define sample_data     ebp+8           ; JSAMPARRAY sample_data
  %define start_col       ebp+12          ; JDIMENSION start_col
  %define workspace       ebp+16          ; DCTELEM *workspace
  
          align   16
          global  EXTN(jsimd_convsamp_mmx)
  
  EXTN(jsimd_convsamp_mmx):
          push    ebp
          mov     ebp,esp
          push    ebx
  ;       push    ecx             ; need not be preserved
  ;       push    edx             ; need not be preserved
          push    esi
          push    edi
  
          pxor    mm6,mm6                 ; mm6=(all 0's)
          pcmpeqw mm7,mm7
          psllw   mm7,7                   ; mm7={0xFF80 0xFF80 0xFF80 0xFF80}
  
          mov     esi, JSAMPARRAY [sample_data]   ; (JSAMPROW *)
          mov     eax, JDIMENSION [start_col]
          mov     edi, POINTER [workspace]        ; (DCTELEM *)
          mov     ecx, DCTSIZE/4
          alignx  16,7
  .convloop:
          mov     ebx, JSAMPROW [esi+0*SIZEOF_JSAMPROW]   ; (JSAMPLE *)
          mov     edx, JSAMPROW [esi+1*SIZEOF_JSAMPROW]   ; (JSAMPLE *)
  
          movq    mm0, MMWORD [ebx+eax*SIZEOF_JSAMPLE]    ; mm0=(01234567)
          movq    mm1, MMWORD [edx+eax*SIZEOF_JSAMPLE]    ; mm1=(89ABCDEF)
  
          mov     ebx, JSAMPROW [esi+2*SIZEOF_JSAMPROW]   ; (JSAMPLE *)
          mov     edx, JSAMPROW [esi+3*SIZEOF_JSAMPROW]   ; (JSAMPLE *)
  
          movq    mm2, MMWORD [ebx+eax*SIZEOF_JSAMPLE]    ; mm2=(GHIJKLMN)
          movq    mm3, MMWORD [edx+eax*SIZEOF_JSAMPLE]    ; mm3=(OPQRSTUV)
  
          movq      mm4,mm0
          punpcklbw mm0,mm6               ; mm0=(0123)
          punpckhbw mm4,mm6               ; mm4=(4567)
          movq      mm5,mm1
          punpcklbw mm1,mm6               ; mm1=(89AB)
          punpckhbw mm5,mm6               ; mm5=(CDEF)
  
          paddw   mm0,mm7
          paddw   mm4,mm7
          paddw   mm1,mm7
          paddw   mm5,mm7
  
          movq    MMWORD [MMBLOCK(0,0,edi,SIZEOF_DCTELEM)], mm0
          movq    MMWORD [MMBLOCK(0,1,edi,SIZEOF_DCTELEM)], mm4
          movq    MMWORD [MMBLOCK(1,0,edi,SIZEOF_DCTELEM)], mm1
          movq    MMWORD [MMBLOCK(1,1,edi,SIZEOF_DCTELEM)], mm5
  
          movq      mm0,mm2
          punpcklbw mm2,mm6               ; mm2=(GHIJ)
          punpckhbw mm0,mm6               ; mm0=(KLMN)
          movq      mm4,mm3
          punpcklbw mm3,mm6               ; mm3=(OPQR)
          punpckhbw mm4,mm6               ; mm4=(STUV)
  
          paddw   mm2,mm7
          paddw   mm0,mm7
          paddw   mm3,mm7
          paddw   mm4,mm7
  
          movq    MMWORD [MMBLOCK(2,0,edi,SIZEOF_DCTELEM)], mm2
          movq    MMWORD [MMBLOCK(2,1,edi,SIZEOF_DCTELEM)], mm0
          movq    MMWORD [MMBLOCK(3,0,edi,SIZEOF_DCTELEM)], mm3
          movq    MMWORD [MMBLOCK(3,1,edi,SIZEOF_DCTELEM)], mm4
  
          add     esi, byte 4*SIZEOF_JSAMPROW
          add     edi, byte 4*DCTSIZE*SIZEOF_DCTELEM
          dec     ecx
          jnz     short .convloop
  
          emms            ; empty MMX state
  
          pop     edi
          pop     esi
  ;       pop     edx             ; need not be preserved
  ;       pop     ecx             ; need not be preserved
          pop     ebx
          pop     ebp
          ret
  
  ; --------------------------------------------------------------------------
  ;
  ; Quantize/descale the coefficients, and store into coef_block
  ;
  ; This implementation is based on an algorithm described in
  ;   "How to optimize for the Pentium family of microprocessors"
  ;   (http://www.agner.org/assem/).
  ;
  ; GLOBAL(void)
  ; jsimd_quantize_mmx (JCOEFPTR coef_block, DCTELEM *divisors,
  ;                     DCTELEM *workspace);
  ;
  
  %define RECIPROCAL(m,n,b) MMBLOCK(DCTSIZE*0+(m),(n),(b),SIZEOF_DCTELEM)
  %define CORRECTION(m,n,b) MMBLOCK(DCTSIZE*1+(m),(n),(b),SIZEOF_DCTELEM)
  %define SCALE(m,n,b)      MMBLOCK(DCTSIZE*2+(m),(n),(b),SIZEOF_DCTELEM)
  %define SHIFT(m,n,b)      MMBLOCK(DCTSIZE*3+(m),(n),(b),SIZEOF_DCTELEM)
  
  %define coef_block      ebp+8           ; JCOEFPTR coef_block
  %define divisors        ebp+12          ; DCTELEM *divisors
  %define workspace       ebp+16          ; DCTELEM *workspace
  
          align   16
          global  EXTN(jsimd_quantize_mmx)
  
  EXTN(jsimd_quantize_mmx):
          push    ebp
          mov     ebp,esp
  ;       push    ebx             ; unused
  ;       push    ecx             ; unused
  ;       push    edx             ; need not be preserved
          push    esi
          push    edi
  
          mov     esi, POINTER [workspace]
          mov     edx, POINTER [divisors]
          mov     edi, JCOEFPTR [coef_block]
          mov     ah, 2
          alignx  16,7
  .quantloop1:
          mov     al, DCTSIZE2/8/2
          alignx  16,7
  .quantloop2:
          movq    mm2, MMWORD [MMBLOCK(0,0,esi,SIZEOF_DCTELEM)]
          movq    mm3, MMWORD [MMBLOCK(0,1,esi,SIZEOF_DCTELEM)]
  
          movq    mm0,mm2
          movq    mm1,mm3
  
          psraw   mm2,(WORD_BIT-1)  ; -1 if value < 0, 0 otherwise
          psraw   mm3,(WORD_BIT-1)
  
          pxor    mm0,mm2   ; val = -val
          pxor    mm1,mm3
          psubw   mm0,mm2
          psubw   mm1,mm3
  
          ;
          ; MMX is an annoyingly crappy instruction set. It has two
          ; misfeatures that are causing problems here:
          ;
          ; - All multiplications are signed.
          ;
          ; - The second operand for the shifts is not treated as packed.
          ;
          ;
          ; We work around the first problem by implementing this algorithm:
          ;
          ; unsigned long unsigned_multiply(unsigned short x, unsigned short y)
          ; {
          ;   enum { SHORT_BIT = 16 };
          ;   signed short sx = (signed short) x;
          ;   signed short sy = (signed short) y;
          ;   signed long sz;
          ;
          ;   sz = (long) sx * (long) sy;     /* signed multiply */
          ;
          ;   if (sx < 0) sz += (long) sy << SHORT_BIT;
          ;   if (sy < 0) sz += (long) sx << SHORT_BIT;
          ;
          ;   return (unsigned long) sz;
          ; }
          ;
          ; (note that a negative sx adds _sy_ and vice versa)
          ;
          ; For the second problem, we replace the shift by a multiplication.
          ; Unfortunately that means we have to deal with the signed issue again.
          ;
  
          paddw   mm0, MMWORD [CORRECTION(0,0,edx)]   ; correction + roundfactor
          paddw   mm1, MMWORD [CORRECTION(0,1,edx)]
  
          movq    mm4,mm0   ; store current value for later
          movq    mm5,mm1
          pmulhw  mm0, MMWORD [RECIPROCAL(0,0,edx)]   ; reciprocal
          pmulhw  mm1, MMWORD [RECIPROCAL(0,1,edx)]
          paddw   mm0,mm4         ; reciprocal is always negative (MSB=1),
          paddw   mm1,mm5   ; so we always need to add the initial value
                          ; (input value is never negative as we
                          ; inverted it at the start of this routine)
  
          ; here it gets a bit tricky as both scale
          ; and mm0/mm1 can be negative
          movq    mm6, MMWORD [SCALE(0,0,edx)]    ; scale
          movq    mm7, MMWORD [SCALE(0,1,edx)]
          movq    mm4,mm0
          movq    mm5,mm1
          pmulhw  mm0,mm6
          pmulhw  mm1,mm7
  
          psraw   mm6,(WORD_BIT-1)    ; determine if scale is negative
          psraw   mm7,(WORD_BIT-1)
  
          pand    mm6,mm4             ; and add input if it is
          pand    mm7,mm5
          paddw   mm0,mm6
          paddw   mm1,mm7
  
          psraw   mm4,(WORD_BIT-1)    ; then check if negative input
          psraw   mm5,(WORD_BIT-1)
  
          pand    mm4, MMWORD [SCALE(0,0,edx)]    ; and add scale if it is
          pand    mm5, MMWORD [SCALE(0,1,edx)]
          paddw   mm0,mm4
          paddw   mm1,mm5
  
          pxor    mm0,mm2   ; val = -val
          pxor    mm1,mm3
          psubw   mm0,mm2
          psubw   mm1,mm3
  
          movq    MMWORD [MMBLOCK(0,0,edi,SIZEOF_DCTELEM)], mm0
          movq    MMWORD [MMBLOCK(0,1,edi,SIZEOF_DCTELEM)], mm1
  
          add     esi, byte 8*SIZEOF_DCTELEM
          add     edx, byte 8*SIZEOF_DCTELEM
          add     edi, byte 8*SIZEOF_JCOEF
          dec     al
          jnz     near .quantloop2
          dec     ah
          jnz     near .quantloop1        ; to avoid branch misprediction
  
          emms            ; empty MMX state
  
          pop     edi
          pop     esi
  ;       pop     edx             ; need not be preserved
  ;       pop     ecx             ; unused
  ;       pop     ebx             ; unused
          pop     ebp
          ret
  
  ; For some reason, the OS X linker does not honor the request to align the
  ; segment unless we do this.
          align   16
  

Download