simd/jchuff-sse2.asm

   1 ;
   2 ; jchuff-sse2.asm - Huffman entropy encoding (SSE2)
   3 ;
   4 ; Copyright (C) 2009-2011, 2014-2017, D. R. Commander.
   5 ; Copyright (C) 2015, Matthieu Darbois.
   6 ;
   7 ; Based on the x86 SIMD extension for IJG JPEG library
   8 ; Copyright (C) 1999-2006, MIYASAKA Masaru.
   9 ; For conditions of distribution and use, see copyright notice in jsimdext.inc
  10 ;
  11 ; This file should be assembled with NASM (Netwide Assembler),
  12 ; can *not* be assembled with Microsoft's MASM or any compatible
  13 ; assembler (including Borland's Turbo Assembler).
  14 ; NASM is available from http://nasm.sourceforge.net/ or
  15 ; http://sourceforge.net/project/showfiles.php?group_id=6208
  16 ;
  17 ; This file contains an SSE2 implementation for Huffman coding of one block.
  18 ; The following code is based directly on jchuff.c; see jchuff.c for more
  19 ; details.
  20 ;
  21 ; [TAB8]
  22
  23 %include "jsimdext.inc"
  24
  25 ; --------------------------------------------------------------------------
  26         SECTION SEG_CONST
  27
  28         alignz  16
  29         global  EXTN(jconst_huff_encode_one_block)
  30
  31 EXTN(jconst_huff_encode_one_block):
  32
  33 %include "jpeg_nbits_table.inc"
  34
  35         alignz  16
  36
  37 ; --------------------------------------------------------------------------
  38         SECTION SEG_TEXT
  39         BITS    32
  40
  41 ; These macros perform the same task as the emit_bits() function in the
  42 ; original libjpeg code.  In addition to reducing overhead by explicitly
  43 ; inlining the code, additional performance is achieved by taking into
  44 ; account the size of the bit buffer and waiting until it is almost full
  45 ; before emptying it.  This mostly benefits 64-bit platforms, since 6
  46 ; bytes can be stored in a 64-bit bit buffer before it has to be emptied.
  47
  48 %macro EMIT_BYTE 0
  49         sub put_bits, 8  ; put_bits -= 8;
  50         mov edx, put_buffer
  51         mov ecx, put_bits
  52         shr edx, cl  ; c = (JOCTET)GETJOCTET(put_buffer >> put_bits);
  53         mov byte [eax], dl  ; *buffer++ = c;
  54         add eax, 1
  55         cmp dl, 0xFF  ; need to stuff a zero byte?
  56         jne %%.EMIT_BYTE_END
  57         mov byte [eax], 0  ; *buffer++ = 0;
  58         add eax, 1
  59 %%.EMIT_BYTE_END:
  60 %endmacro
  61
  62 %macro PUT_BITS 1
  63         add put_bits, ecx  ; put_bits += size;
  64         shl put_buffer, cl  ; put_buffer = (put_buffer << size);
  65         or  put_buffer, %1
  66 %endmacro
  67
  68 %macro CHECKBUF15 0
  69         cmp put_bits, 16  ; if (put_bits > 31) {
  70         jl %%.CHECKBUF15_END
  71         mov eax, POINTER [esp+buffer]
  72         EMIT_BYTE
  73         EMIT_BYTE
  74         mov POINTER [esp+buffer], eax
  75 %%.CHECKBUF15_END:
  76 %endmacro
  77
  78 %macro EMIT_BITS 1
  79         PUT_BITS %1
  80         CHECKBUF15
  81 %endmacro
  82
  83 %macro kloop_prepare 37  ;(ko, jno0, ..., jno31, xmm0, xmm1, xmm2, xmm3)
  84     pxor xmm4, xmm4  ; __m128i neg = _mm_setzero_si128();
  85     pxor xmm5, xmm5  ; __m128i neg = _mm_setzero_si128();
  86     pxor xmm6, xmm6  ; __m128i neg = _mm_setzero_si128();
  87     pxor xmm7, xmm7  ; __m128i neg = _mm_setzero_si128();
  88     pinsrw %34, word [esi + %2  * SIZEOF_WORD], 0  ; xmm_shadow[0] = block[jno0];
  89     pinsrw %35, word [esi + %10 * SIZEOF_WORD], 0  ; xmm_shadow[8] = block[jno8];
  90     pinsrw %36, word [esi + %18 * SIZEOF_WORD], 0  ; xmm_shadow[16] = block[jno16];
  91     pinsrw %37, word [esi + %26 * SIZEOF_WORD], 0  ; xmm_shadow[24] = block[jno24];
  92     pinsrw %34, word [esi + %3  * SIZEOF_WORD], 1  ; xmm_shadow[1] = block[jno1];
  93     pinsrw %35, word [esi + %11 * SIZEOF_WORD], 1  ; xmm_shadow[9] = block[jno9];
  94     pinsrw %36, word [esi + %19 * SIZEOF_WORD], 1  ; xmm_shadow[17] = block[jno17];
  95     pinsrw %37, word [esi + %27 * SIZEOF_WORD], 1  ; xmm_shadow[25] = block[jno25];
  96     pinsrw %34, word [esi + %4  * SIZEOF_WORD], 2  ; xmm_shadow[2] = block[jno2];
  97     pinsrw %35, word [esi + %12 * SIZEOF_WORD], 2  ; xmm_shadow[10] = block[jno10];
  98     pinsrw %36, word [esi + %20 * SIZEOF_WORD], 2  ; xmm_shadow[18] = block[jno18];
  99     pinsrw %37, word [esi + %28 * SIZEOF_WORD], 2  ; xmm_shadow[26] = block[jno26];
 100     pinsrw %34, word [esi + %5  * SIZEOF_WORD], 3  ; xmm_shadow[3] = block[jno3];
 101     pinsrw %35, word [esi + %13 * SIZEOF_WORD], 3  ; xmm_shadow[11] = block[jno11];
 102     pinsrw %36, word [esi + %21 * SIZEOF_WORD], 3  ; xmm_shadow[19] = block[jno19];
 103     pinsrw %37, word [esi + %29 * SIZEOF_WORD], 3  ; xmm_shadow[27] = block[jno27];
 104     pinsrw %34, word [esi + %6  * SIZEOF_WORD], 4  ; xmm_shadow[4] = block[jno4];
 105     pinsrw %35, word [esi + %14 * SIZEOF_WORD], 4  ; xmm_shadow[12] = block[jno12];
 106     pinsrw %36, word [esi + %22 * SIZEOF_WORD], 4  ; xmm_shadow[20] = block[jno20];
 107     pinsrw %37, word [esi + %30 * SIZEOF_WORD], 4  ; xmm_shadow[28] = block[jno28];
 108     pinsrw %34, word [esi + %7  * SIZEOF_WORD], 5  ; xmm_shadow[5] = block[jno5];
 109     pinsrw %35, word [esi + %15 * SIZEOF_WORD], 5  ; xmm_shadow[13] = block[jno13];
 110     pinsrw %36, word [esi + %23 * SIZEOF_WORD], 5  ; xmm_shadow[21] = block[jno21];
 111     pinsrw %37, word [esi + %31 * SIZEOF_WORD], 5  ; xmm_shadow[29] = block[jno29];
 112     pinsrw %34, word [esi + %8  * SIZEOF_WORD], 6  ; xmm_shadow[6] = block[jno6];
 113     pinsrw %35, word [esi + %16 * SIZEOF_WORD], 6  ; xmm_shadow[14] = block[jno14];
 114     pinsrw %36, word [esi + %24 * SIZEOF_WORD], 6  ; xmm_shadow[22] = block[jno22];
 115     pinsrw %37, word [esi + %32 * SIZEOF_WORD], 6  ; xmm_shadow[30] = block[jno30];
 116     pinsrw %34, word [esi + %9  * SIZEOF_WORD], 7  ; xmm_shadow[7] = block[jno7];
 117     pinsrw %35, word [esi + %17 * SIZEOF_WORD], 7  ; xmm_shadow[15] = block[jno15];
 118     pinsrw %36, word [esi + %25 * SIZEOF_WORD], 7  ; xmm_shadow[23] = block[jno23];
 119 %if %1 != 32
 120     pinsrw %37, word [esi + %33 * SIZEOF_WORD], 7  ; xmm_shadow[31] = block[jno31];
 121 %else
 122     pinsrw %37, ecx, 7  ; xmm_shadow[31] = block[jno31];
 123 %endif
 124     pcmpgtw xmm4, %34  ; neg = _mm_cmpgt_epi16(neg, x1);
 125     pcmpgtw xmm5, %35  ; neg = _mm_cmpgt_epi16(neg, x1);
 126     pcmpgtw xmm6, %36  ; neg = _mm_cmpgt_epi16(neg, x1);
 127     pcmpgtw xmm7, %37  ; neg = _mm_cmpgt_epi16(neg, x1);
 128     paddw %34, xmm4   ; x1 = _mm_add_epi16(x1, neg);
 129     paddw %35, xmm5   ; x1 = _mm_add_epi16(x1, neg);
 130     paddw %36, xmm6  ; x1 = _mm_add_epi16(x1, neg);
 131     paddw %37, xmm7  ; x1 = _mm_add_epi16(x1, neg);
 132     pxor %34, xmm4    ; x1 = _mm_xor_si128(x1, neg);
 133     pxor %35, xmm5    ; x1 = _mm_xor_si128(x1, neg);
 134     pxor %36, xmm6   ; x1 = _mm_xor_si128(x1, neg);
 135     pxor %37, xmm7   ; x1 = _mm_xor_si128(x1, neg);
 136     pxor xmm4, %34    ; neg = _mm_xor_si128(neg, x1);
 137     pxor xmm5, %35    ; neg = _mm_xor_si128(neg, x1);
 138     pxor xmm6, %36   ; neg = _mm_xor_si128(neg, x1);
 139     pxor xmm7, %37   ; neg = _mm_xor_si128(neg, x1);
 140     movdqa XMMWORD [esp + t1 + %1 * SIZEOF_WORD], %34  ; _mm_storeu_si128((__m128i *)(t1 + ko), x1);
 141     movdqa XMMWORD [esp + t1 + (%1 + 8) * SIZEOF_WORD], %35  ; _mm_storeu_si128((__m128i *)(t1 + ko + 8), x1);
 142     movdqa XMMWORD [esp + t1 + (%1 + 16) * SIZEOF_WORD], %36  ; _mm_storeu_si128((__m128i *)(t1 + ko + 16), x1);
 143     movdqa XMMWORD [esp + t1 + (%1 + 24) * SIZEOF_WORD], %37  ; _mm_storeu_si128((__m128i *)(t1 + ko + 24), x1);
 144     movdqa XMMWORD [esp + t2 + %1 * SIZEOF_WORD], xmm4  ; _mm_storeu_si128((__m128i *)(t2 + ko), neg);
 145     movdqa XMMWORD [esp + t2 + (%1 + 8) * SIZEOF_WORD], xmm5  ; _mm_storeu_si128((__m128i *)(t2 + ko + 8), neg);
 146     movdqa XMMWORD [esp + t2 + (%1 + 16) * SIZEOF_WORD], xmm6  ; _mm_storeu_si128((__m128i *)(t2 + ko + 16), neg);
 147     movdqa XMMWORD [esp + t2 + (%1 + 24) * SIZEOF_WORD], xmm7  ; _mm_storeu_si128((__m128i *)(t2 + ko + 24), neg);
 148 %endmacro
 149
 150 ;
 151 ; Encode a single block's worth of coefficients.
 152 ;
 153 ; GLOBAL(JOCTET*)
 154 ; jsimd_huff_encode_one_block_sse2 (working_state *state, JOCTET *buffer,
 155 ;                                   JCOEFPTR block, int last_dc_val,
 156 ;                                   c_derived_tbl *dctbl, c_derived_tbl *actbl)
 157 ;
 158
 159 ; eax + 8 = working_state *state
 160 ; eax + 12 = JOCTET *buffer
 161 ; eax + 16 = JCOEFPTR block
 162 ; eax + 20 = int last_dc_val
 163 ; eax + 24 = c_derived_tbl *dctbl
 164 ; eax + 28 = c_derived_tbl *actbl
 165
 166 %define pad             6*SIZEOF_DWORD  ; Align to 16 bytes
 167 %define t1              pad
 168 %define t2              t1+(DCTSIZE2*SIZEOF_WORD)
 169 %define block           t2+(DCTSIZE2*SIZEOF_WORD)
 170 %define actbl           block+SIZEOF_DWORD
 171 %define buffer          actbl+SIZEOF_DWORD
 172 %define temp            buffer+SIZEOF_DWORD
 173 %define temp2           temp+SIZEOF_DWORD
 174 %define temp3           temp2+SIZEOF_DWORD
 175 %define temp4           temp3+SIZEOF_DWORD
 176 %define temp5           temp4+SIZEOF_DWORD
 177 %define gotptr          temp5+SIZEOF_DWORD  ; void *gotptr
 178 %define put_buffer      ebx
 179 %define put_bits        edi
 180
 181         align   16
 182         global  EXTN(jsimd_huff_encode_one_block_sse2)
 183
 184 EXTN(jsimd_huff_encode_one_block_sse2):
 185         push    ebp
 186         mov     eax,esp                         ; eax = original ebp
 187         sub     esp, byte 4
 188         and     esp, byte (-SIZEOF_XMMWORD)     ; align to 128 bits
 189         mov     [esp],eax
 190         mov     ebp,esp                         ; ebp = aligned ebp
 191         sub     esp, temp5+9*SIZEOF_DWORD-pad
 192         push    ebx
 193         push    ecx
 194 ;       push    edx             ; need not be preserved
 195         push    esi
 196         push    edi
 197         push    ebp
 198
 199         mov esi, POINTER [eax+8]        ; (working_state *state)
 200         mov put_buffer,  DWORD [esi+8]  ; put_buffer = state->cur.put_buffer;
 201         mov put_bits,    DWORD [esi+12]  ; put_bits = state->cur.put_bits;
 202         push esi  ; esi is now scratch
 203
 204         get_GOT edx                       ; get GOT address
 205         movpic POINTER [esp+gotptr], edx  ; save GOT address
 206
 207         mov ecx, POINTER [eax+28]
 208         mov edx, POINTER [eax+16]
 209         mov esi, POINTER [eax+12]
 210         mov POINTER [esp+actbl],  ecx
 211         mov POINTER [esp+block],  edx
 212         mov POINTER [esp+buffer], esi
 213
 214         ; Encode the DC coefficient difference per section F.1.2.1
 215         mov esi, POINTER [esp+block]        ; block
 216         movsx ecx, word [esi]  ; temp = temp2 = block[0] - last_dc_val;
 217         sub   ecx, DWORD [eax+20]
 218         mov   esi, ecx
 219
 220         ; This is a well-known technique for obtaining the absolute value
 221         ; without a branch.  It is derived from an assembly language technique
 222         ; presented in "How to Optimize for the Pentium Processors",
 223         ; Copyright (c) 1996, 1997 by Agner Fog.
 224         mov edx, ecx
 225         sar edx, 31   ; temp3 = temp >> (CHAR_BIT * sizeof(int) - 1);
 226         xor ecx, edx ; temp ^= temp3;
 227         sub ecx, edx ; temp -= temp3;
 228
 229         ; For a negative input, want temp2 = bitwise complement of abs(input)
 230         ; This code assumes we are on a two's complement machine
 231         add esi, edx  ; temp2 += temp3;
 232         mov DWORD [esp+temp], esi  ; backup temp2 in temp
 233
 234         ; Find the number of bits needed for the magnitude of the coefficient
 235         movpic ebp, POINTER [esp+gotptr]   ; load GOT address (ebp)
 236         movzx edx, byte [GOTOFF(ebp, jpeg_nbits_table + ecx)]  ; nbits = JPEG_NBITS(temp);
 237         mov DWORD [esp+temp2], edx  ; backup nbits in temp2
 238
 239         ; Emit the Huffman-coded symbol for the number of bits
 240         mov    ebp, POINTER [eax+24]  ; After this point, arguments are not accessible anymore
 241         mov    eax,  INT [ebp + edx * 4]  ; code = dctbl->ehufco[nbits];
 242         movzx  ecx, byte [ebp + edx + 1024]  ; size = dctbl->ehufsi[nbits];
 243         EMIT_BITS eax  ; EMIT_BITS(code, size)
 244
 245         mov ecx, DWORD [esp+temp2]  ; restore nbits
 246
 247         ; Mask off any extra bits in code
 248         mov eax, 1
 249         shl eax, cl
 250         dec eax
 251         and eax, DWORD [esp+temp]  ; temp2 &= (((JLONG) 1)<<nbits) - 1;
 252
 253         ; Emit that number of bits of the value, if positive,
 254         ; or the complement of its magnitude, if negative.
 255         EMIT_BITS eax  ; EMIT_BITS(temp2, nbits)
 256
 257         ; Prepare data
 258         xor ecx, ecx
 259         mov esi, POINTER [esp+block]
 260         kloop_prepare  0,  1,  8,  16, 9,  2,  3,  10, 17, 24, 32, 25, \
 261                        18, 11, 4,  5,  12, 19, 26, 33, 40, 48, 41, 34, \
 262                        27, 20, 13, 6,  7,  14, 21, 28, 35, \
 263                        xmm0, xmm1, xmm2, xmm3
 264         kloop_prepare  32, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, \
 265                        30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, \
 266                        53, 60, 61, 54, 47, 55, 62, 63, 63, \
 267                        xmm0, xmm1, xmm2, xmm3
 268
 269         pxor xmm7, xmm7
 270         movdqa xmm0, XMMWORD [esp + t1 + 0 * SIZEOF_WORD]   ; __m128i tmp0 = _mm_loadu_si128((__m128i *)(t1 + 0));
 271         movdqa xmm1, XMMWORD [esp + t1 + 8 * SIZEOF_WORD]   ; __m128i tmp1 = _mm_loadu_si128((__m128i *)(t1 + 8));
 272         movdqa xmm2, XMMWORD [esp + t1 + 16 * SIZEOF_WORD]  ; __m128i tmp2 = _mm_loadu_si128((__m128i *)(t1 + 16));
 273         movdqa xmm3, XMMWORD [esp + t1 + 24 * SIZEOF_WORD]  ; __m128i tmp3 = _mm_loadu_si128((__m128i *)(t1 + 24));
 274         pcmpeqw xmm0, xmm7  ; tmp0 = _mm_cmpeq_epi16(tmp0, zero);
 275         pcmpeqw xmm1, xmm7  ; tmp1 = _mm_cmpeq_epi16(tmp1, zero);
 276         pcmpeqw xmm2, xmm7  ; tmp2 = _mm_cmpeq_epi16(tmp2, zero);
 277         pcmpeqw xmm3, xmm7  ; tmp3 = _mm_cmpeq_epi16(tmp3, zero);
 278         packsswb xmm0, xmm1  ; tmp0 = _mm_packs_epi16(tmp0, tmp1);
 279         packsswb xmm2, xmm3  ; tmp2 = _mm_packs_epi16(tmp2, tmp3);
 280         pmovmskb edx, xmm0  ; index  = ((uint64_t)_mm_movemask_epi8(tmp0)) << 0;
 281         pmovmskb ecx, xmm2  ; index  = ((uint64_t)_mm_movemask_epi8(tmp2)) << 16;
 282         shl ecx, 16
 283         or  edx, ecx
 284         not edx  ; index = ~index;
 285
 286         lea esi, [esp+t1]
 287         mov ebp, POINTER [esp+actbl]  ; ebp = actbl
 288
 289 .BLOOP:
 290         bsf ecx, edx  ; r = __builtin_ctzl(index);
 291         jz near .ELOOP
 292         lea esi, [esi+ecx*2]  ; k += r;
 293         shr edx, cl  ; index >>= r;
 294         mov DWORD [esp+temp3], edx
 295 .BRLOOP:
 296         cmp ecx, 16  ; while (r > 15) {
 297         jl near .ERLOOP
 298         sub ecx, 16 ; r -= 16;
 299         mov DWORD [esp+temp], ecx
 300         mov   eax, INT [ebp + 240 * 4]  ; code_0xf0 = actbl->ehufco[0xf0];
 301         movzx ecx, byte [ebp + 1024 + 240]  ; size_0xf0 = actbl->ehufsi[0xf0];
 302         EMIT_BITS eax  ; EMIT_BITS(code_0xf0, size_0xf0)
 303         mov ecx, DWORD [esp+temp]
 304         jmp .BRLOOP
 305 .ERLOOP:
 306         movsx eax, word [esi]  ; temp = t1[k];
 307         movpic edx, POINTER [esp+gotptr]   ; load GOT address (edx)
 308         movzx eax, byte [GOTOFF(edx, jpeg_nbits_table + eax)]  ; nbits = JPEG_NBITS(temp);
 309         mov DWORD [esp+temp2], eax
 310         ; Emit Huffman symbol for run length / number of bits
 311         shl ecx, 4  ; temp3 = (r << 4) + nbits;
 312         add ecx, eax
 313         mov   eax,  INT [ebp + ecx * 4]  ; code = actbl->ehufco[temp3];
 314         movzx ecx, byte [ebp + ecx + 1024]  ; size = actbl->ehufsi[temp3];
 315         EMIT_BITS eax
 316
 317         movsx edx, word [esi+DCTSIZE2*2]  ; temp2 = t2[k];
 318         ; Mask off any extra bits in code
 319         mov ecx, DWORD [esp+temp2]
 320         mov eax, 1
 321         shl eax, cl
 322         dec eax
 323         and eax, edx  ; temp2 &= (((JLONG) 1)<<nbits) - 1;
 324         EMIT_BITS eax  ; PUT_BITS(temp2, nbits)
 325         mov edx, DWORD [esp+temp3]
 326         add esi, 2  ; ++k;
 327         shr edx, 1  ; index >>= 1;
 328
 329         jmp .BLOOP
 330 .ELOOP:
 331         movdqa xmm0, XMMWORD [esp + t1 + 32 * SIZEOF_WORD]  ; __m128i tmp0 = _mm_loadu_si128((__m128i *)(t1 + 0));
 332         movdqa xmm1, XMMWORD [esp + t1 + 40 * SIZEOF_WORD]  ; __m128i tmp1 = _mm_loadu_si128((__m128i *)(t1 + 8));
 333         movdqa xmm2, XMMWORD [esp + t1 + 48 * SIZEOF_WORD]  ; __m128i tmp2 = _mm_loadu_si128((__m128i *)(t1 + 16));
 334         movdqa xmm3, XMMWORD [esp + t1 + 56 * SIZEOF_WORD]  ; __m128i tmp3 = _mm_loadu_si128((__m128i *)(t1 + 24));
 335         pcmpeqw xmm0, xmm7  ; tmp0 = _mm_cmpeq_epi16(tmp0, zero);
 336         pcmpeqw xmm1, xmm7  ; tmp1 = _mm_cmpeq_epi16(tmp1, zero);
 337         pcmpeqw xmm2, xmm7  ; tmp2 = _mm_cmpeq_epi16(tmp2, zero);
 338         pcmpeqw xmm3, xmm7  ; tmp3 = _mm_cmpeq_epi16(tmp3, zero);
 339         packsswb xmm0, xmm1  ; tmp0 = _mm_packs_epi16(tmp0, tmp1);
 340         packsswb xmm2, xmm3  ; tmp2 = _mm_packs_epi16(tmp2, tmp3);
 341         pmovmskb edx, xmm0  ; index  = ((uint64_t)_mm_movemask_epi8(tmp0)) << 0;
 342         pmovmskb ecx, xmm2  ; index  = ((uint64_t)_mm_movemask_epi8(tmp2)) << 16;
 343         shl ecx, 16
 344         or  edx, ecx
 345         not edx  ; index = ~index;
 346
 347         lea eax, [esp + t1 + (DCTSIZE2/2) * 2]
 348         sub eax, esi
 349         shr eax, 1
 350         bsf ecx, edx  ; r = __builtin_ctzl(index);
 351         jz near .ELOOP2
 352         shr edx, cl  ; index >>= r;
 353         add ecx, eax
 354         lea esi, [esi+ecx*2]  ; k += r;
 355         mov DWORD [esp+temp3], edx
 356         jmp .BRLOOP2
 357 .BLOOP2:
 358         bsf ecx, edx  ; r = __builtin_ctzl(index);
 359         jz near .ELOOP2
 360         lea esi, [esi+ecx*2]  ; k += r;
 361         shr edx, cl  ; index >>= r;
 362         mov DWORD [esp+temp3], edx
 363 .BRLOOP2:
 364         cmp ecx, 16  ; while (r > 15) {
 365         jl near .ERLOOP2
 366         sub ecx, 16  ; r -= 16;
 367         mov DWORD [esp+temp], ecx
 368         mov   eax, INT [ebp + 240 * 4]  ; code_0xf0 = actbl->ehufco[0xf0];
 369         movzx ecx, byte [ebp + 1024 + 240]  ; size_0xf0 = actbl->ehufsi[0xf0];
 370         EMIT_BITS eax  ; EMIT_BITS(code_0xf0, size_0xf0)
 371         mov ecx, DWORD [esp+temp]
 372         jmp .BRLOOP2
 373 .ERLOOP2:
 374         movsx eax, word [esi]  ; temp = t1[k];
 375         bsr eax, eax  ; nbits = 32 - __builtin_clz(temp);
 376         inc eax
 377         mov DWORD [esp+temp2], eax
 378         ; Emit Huffman symbol for run length / number of bits
 379         shl ecx, 4  ; temp3 = (r << 4) + nbits;
 380         add ecx, eax
 381         mov   eax,  INT [ebp + ecx * 4]  ; code = actbl->ehufco[temp3];
 382         movzx ecx, byte [ebp + ecx + 1024]  ; size = actbl->ehufsi[temp3];
 383         EMIT_BITS eax
 384
 385         movsx edx, word [esi+DCTSIZE2*2]  ; temp2 = t2[k];
 386         ; Mask off any extra bits in code
 387         mov ecx, DWORD [esp+temp2]
 388         mov eax, 1
 389         shl eax, cl
 390         dec eax
 391         and eax, edx  ; temp2 &= (((JLONG) 1)<<nbits) - 1;
 392         EMIT_BITS eax  ; PUT_BITS(temp2, nbits)
 393         mov edx, DWORD [esp+temp3]
 394         add esi, 2  ; ++k;
 395         shr edx, 1  ; index >>= 1;
 396
 397         jmp .BLOOP2
 398 .ELOOP2:
 399         ; If the last coef(s) were zero, emit an end-of-block code
 400         lea edx, [esp + t1 + (DCTSIZE2-1) * 2]  ; r = DCTSIZE2-1-k;
 401         cmp edx, esi  ; if (r > 0) {
 402         je .EFN
 403         mov   eax,  INT [ebp]  ; code = actbl->ehufco[0];
 404         movzx ecx, byte [ebp + 1024]  ; size = actbl->ehufsi[0];
 405         EMIT_BITS eax
 406 .EFN:
 407         mov eax, [esp+buffer]
 408         pop esi
 409         ; Save put_buffer & put_bits
 410         mov DWORD [esi+8], put_buffer  ; state->cur.put_buffer = put_buffer;
 411         mov DWORD [esi+12], put_bits  ; state->cur.put_bits = put_bits;
 412
 413         pop     ebp
 414         pop     edi
 415         pop     esi
 416 ;       pop     edx             ; need not be preserved
 417         pop     ecx
 418         pop     ebx
 419         mov     esp,ebp         ; esp <- aligned ebp
 420         pop     esp             ; esp <- original ebp
 421         pop     ebp
 422         ret
 423
 424 ; For some reason, the OS X linker does not honor the request to align the
 425 ; segment unless we do this.
 426         align   16