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