WebSVN – Kolibri OS – Diff – /contrib/sdk/sources/SDL-1.2.2_newlib/src/hermes/x86p_32.asm


;
; x86 format converters for HERMES
; Some routines Copyright (c) 1998 Christian Nentwich (brn@eleet.mcb.at)
; This source code is licensed under the GNU LGPL
; 
; Please refer to the file COPYING.LIB contained in the distribution for
; licensing conditions		
;
; Most routines are (c) Glenn Fiedler (ptc@gaffer.org), used with permission
; 
 
 
 
 
 
 
 
 
 
 
 
BITS 32
 
%include "common.inc"
 
SDL_FUNC _ConvertX86p32_32BGR888
SDL_FUNC _ConvertX86p32_32RGBA888
SDL_FUNC _ConvertX86p32_32BGRA888
SDL_FUNC _ConvertX86p32_24RGB888	
SDL_FUNC _ConvertX86p32_24BGR888
SDL_FUNC _ConvertX86p32_16RGB565
SDL_FUNC _ConvertX86p32_16BGR565
SDL_FUNC _ConvertX86p32_16RGB555
SDL_FUNC _ConvertX86p32_16BGR555
SDL_FUNC _ConvertX86p32_8RGB332
 
SECTION .text
 
 
;; _Convert_*
;; Paramters:	
;;   ESI = source 
;;   EDI = dest
;;   ECX = amount (NOT 0!!! (the _ConvertX86 routine checks for that though))
;; Destroys:
;;   EAX, EBX, EDX
 
 
_ConvertX86p32_32BGR888:
 
    ; check short
    cmp ecx,BYTE 32
    ja .L3
 
.L1: ; short loop
    mov edx,[esi]
    bswap edx
    ror edx,8
    mov [edi],edx
    add esi,BYTE 4
    add edi,BYTE 4
    dec ecx
    jnz .L1
.L2:
    retn
 
.L3: ; save ebp
    push ebp
 
    ; unroll four times
    mov ebp,ecx
    shr ebp,2
    
    ; save count
    push ecx
 
.L4:    mov eax,[esi]
        mov ebx,[esi+4]
 
        bswap eax
 
        bswap ebx
 
        ror eax,8
        mov ecx,[esi+8]
 
        ror ebx,8
        mov edx,[esi+12]
 
        bswap ecx
 
        bswap edx
 
        ror ecx,8
        mov [edi+0],eax
 
        ror edx,8
        mov [edi+4],ebx
 
        mov [edi+8],ecx
        mov [edi+12],edx
 
        add esi,BYTE 16
        add edi,BYTE 16
 
        dec ebp
        jnz .L4                 
 
    ; check tail
    pop ecx
    and ecx,BYTE 11b
    jz .L6
 
.L5: ; tail loop
    mov edx,[esi]
    bswap edx
    ror edx,8
    mov [edi],edx
    add esi,BYTE 4
    add edi,BYTE 4
    dec ecx
    jnz .L5
 
.L6: pop ebp
    retn
	
 
	
		
_ConvertX86p32_32RGBA888:
	
    ; check short
    cmp ecx,BYTE 32
    ja .L3
 
.L1: ; short loop
    mov edx,[esi]
    rol edx,8
    mov [edi],edx
    add esi,BYTE 4
    add edi,BYTE 4
    dec ecx
    jnz .L1
.L2:
    retn
 
.L3: ; save ebp
    push ebp
 
    ; unroll four times
    mov ebp,ecx
    shr ebp,2
    
    ; save count
    push ecx
 
.L4:    mov eax,[esi]
        mov ebx,[esi+4]
 
        rol eax,8
        mov ecx,[esi+8]
 
        rol ebx,8
        mov edx,[esi+12]
 
        rol ecx,8
        mov [edi+0],eax
 
        rol edx,8
        mov [edi+4],ebx
 
        mov [edi+8],ecx
        mov [edi+12],edx
 
        add esi,BYTE 16
        add edi,BYTE 16
 
        dec ebp
        jnz .L4                 
 
    ; check tail
    pop ecx
    and ecx,BYTE 11b
    jz .L6
 
.L5: ; tail loop
    mov edx,[esi]
    rol edx,8
    mov [edi],edx
    add esi,BYTE 4
    add edi,BYTE 4
    dec ecx
    jnz .L5
 
.L6: pop ebp
    retn
 
	
 
 
_ConvertX86p32_32BGRA888:
 
    ; check short
    cmp ecx,BYTE 32
    ja .L3
 
.L1: ; short loop
    mov edx,[esi]
    bswap edx
    mov [edi],edx
    add esi,BYTE 4
    add edi,BYTE 4
    dec ecx
    jnz .L1
.L2:
    retn
 
.L3: ; save ebp
    push ebp
 
    ; unroll four times
    mov ebp,ecx
    shr ebp,2
    
    ; save count
    push ecx
 
.L4:    mov eax,[esi]
        mov ebx,[esi+4]
 
        mov ecx,[esi+8]
        mov edx,[esi+12]
 
        bswap eax
 
        bswap ebx
 
        bswap ecx
 
        bswap edx
 
        mov [edi+0],eax
        mov [edi+4],ebx
 
        mov [edi+8],ecx
        mov [edi+12],edx
 
        add esi,BYTE 16
        add edi,BYTE 16
 
        dec ebp
        jnz .L4                 
 
    ; check tail
    pop ecx
    and ecx,BYTE 11b
    jz .L6
 
.L5: ; tail loop
    mov edx,[esi]
    bswap edx
    mov [edi],edx
    add esi,BYTE 4
    add edi,BYTE 4
    dec ecx
    jnz .L5
 
.L6: pop ebp
    retn
 
 
	
	
;; 32 bit RGB 888 to 24 BIT RGB 888
 
_ConvertX86p32_24RGB888:
 
	; check short
	cmp ecx,BYTE 32
	ja .L3
 
.L1:	; short loop
	mov al,[esi]
	mov bl,[esi+1]
	mov dl,[esi+2]
	mov [edi],al
	mov [edi+1],bl
	mov [edi+2],dl
	add esi,BYTE 4
	add edi,BYTE 3
	dec ecx
	jnz .L1
.L2:
	retn
 
.L3:	;	 head
	mov edx,edi
	and edx,BYTE 11b
	jz .L4
	mov al,[esi]
	mov bl,[esi+1]
	mov dl,[esi+2]
	mov [edi],al
	mov [edi+1],bl
	mov [edi+2],dl
	add esi,BYTE 4
	add edi,BYTE 3
	dec ecx
	jmp SHORT .L3
 
.L4: ; unroll 4 times
	push ebp
	mov ebp,ecx
	shr ebp,2
 
    ; save count
	push ecx
 
.L5:    mov eax,[esi]                   ; first dword            eax = [A][R][G][B]
        mov ebx,[esi+4]                 ; second dword           ebx = [a][r][g][b]
 
        shl eax,8                       ;                        eax = [R][G][B][.]
        mov ecx,[esi+12]                ; third dword            ecx = [a][r][g][b]
 
        shl ebx,8                       ;                        ebx = [r][g][b][.]
        mov al,[esi+4]                  ;                        eax = [R][G][B][b]
 
        ror eax,8                       ;                        eax = [b][R][G][B] (done)
        mov bh,[esi+8+1]                ;                        ebx = [r][g][G][.]
 
        mov [edi],eax
        add edi,BYTE 3*4
 
        shl ecx,8                       ;                        ecx = [r][g][b][.]
        mov bl,[esi+8+0]                ;                        ebx = [r][g][G][B]
 
        rol ebx,16                      ;                        ebx = [G][B][r][g] (done)
        mov cl,[esi+8+2]                ;                        ecx = [r][g][b][R] (done)
 
        mov [edi+4-3*4],ebx
        add esi,BYTE 4*4
        
        mov [edi+8-3*4],ecx
        dec ebp
 
        jnz .L5
 
    ; check tail
	pop ecx
	and ecx,BYTE 11b
	jz .L7
 
.L6: ; tail loop
	mov al,[esi]
	mov bl,[esi+1]
	mov dl,[esi+2]
	mov [edi],al
	mov [edi+1],bl
	mov [edi+2],dl
	add esi,BYTE 4
	add edi,BYTE 3
	dec ecx
	jnz .L6
 
.L7:	pop ebp
	retn
 
 
 
 
;; 32 bit RGB 888 to 24 bit BGR 888
 
_ConvertX86p32_24BGR888:
 
	; check short
	cmp ecx,BYTE 32
	ja .L3
 
 
.L1:	; short loop
	mov dl,[esi]
	mov bl,[esi+1]
	mov al,[esi+2]
	mov [edi],al
	mov [edi+1],bl
	mov [edi+2],dl
	add esi,BYTE 4
	add edi,BYTE 3
	dec ecx
	jnz .L1
.L2:
	retn
 
.L3: ; head
	mov edx,edi
	and edx,BYTE 11b
	jz .L4
	mov dl,[esi]
	mov bl,[esi+1]
	mov al,[esi+2]
	mov [edi],al
	mov [edi+1],bl
	mov [edi+2],dl
	add esi,BYTE 4
	add edi,BYTE 3
	dec ecx
	jmp SHORT .L3
 
.L4:	; unroll 4 times
	push ebp
	mov ebp,ecx
	shr ebp,2
 
	; save count
	push ecx
 
.L5:
	mov eax,[esi]                   ; first dword            eax = [A][R][G][B]
        mov ebx,[esi+4]                 ; second dword           ebx = [a][r][g][b]
 
        bswap eax                       ;                        eax = [B][G][R][A]
 
        bswap ebx                       ;                        ebx = [b][g][r][a]
 
        mov al,[esi+4+2]                ;                        eax = [B][G][R][r] 
        mov bh,[esi+4+4+1]              ;                        ebx = [b][g][G][a]
 
        ror eax,8                       ;                        eax = [r][B][G][R] (done)
        mov bl,[esi+4+4+2]              ;                        ebx = [b][g][G][R]
 
        ror ebx,16                      ;                        ebx = [G][R][b][g] (done)
        mov [edi],eax
    
        mov [edi+4],ebx
        mov ecx,[esi+12]                ; third dword            ecx = [a][r][g][b]
        
        bswap ecx                       ;                        ecx = [b][g][r][a]
        
        mov cl,[esi+8]                  ;                        ecx = [b][g][r][B] (done)
        add esi,BYTE 4*4
 
        mov [edi+8],ecx
        add edi,BYTE 3*4
 
        dec ebp
        jnz .L5
 
	; check tail
	pop ecx
	and ecx,BYTE 11b
	jz .L7
 
.L6:	; tail loop
	mov dl,[esi]
	mov bl,[esi+1]
	mov al,[esi+2]
	mov [edi],al
	mov [edi+1],bl
	mov [edi+2],dl
	add esi,BYTE 4
	add edi,BYTE 3
	dec ecx
	jnz .L6
 
.L7:
	pop ebp
	retn
 
 
	
		
;; 32 bit RGB 888 to 16 BIT RGB 565 
 
_ConvertX86p32_16RGB565:
	; check short
	cmp ecx,BYTE 16
	ja .L3
 
.L1: ; short loop
	mov bl,[esi+0]    ; blue
	mov al,[esi+1]    ; green
	mov ah,[esi+2]    ; red
	shr ah,3
        and al,11111100b
	shl eax,3
	shr bl,3
	add al,bl
	mov [edi+0],al
	mov [edi+1],ah
	add esi,BYTE 4
	add edi,BYTE 2
	dec ecx
	jnz .L1
 
.L2:				; End of short loop
	retn
 
	
.L3:	; head
	mov ebx,edi
	and ebx,BYTE 11b
	jz .L4
	
	mov bl,[esi+0]    ; blue
	mov al,[esi+1]    ; green
	mov ah,[esi+2]    ; red
	shr ah,3
	and al,11111100b
	shl eax,3
	shr bl,3
	add al,bl
	mov [edi+0],al
	mov [edi+1],ah
	add esi,BYTE 4
	add edi,BYTE 2
	dec ecx
 
.L4:	 
    ; save count
	push ecx
 
    ; unroll twice
	shr ecx,1
    
    ; point arrays to end
	lea esi,[esi+ecx*8]
	lea edi,[edi+ecx*4]
 
    ; negative counter 
	neg ecx
	jmp SHORT .L6
 
.L5:	    
	mov [edi+ecx*4-4],eax
.L6:	
	mov eax,[esi+ecx*8]
 
        shr ah,2
        mov ebx,[esi+ecx*8+4]
 
        shr eax,3
        mov edx,[esi+ecx*8+4]
 
        shr bh,2
        mov dl,[esi+ecx*8+2]
 
        shl ebx,13
        and eax,000007FFh
        
        shl edx,8
        and ebx,07FF0000h
 
        and edx,0F800F800h
        add eax,ebx
 
        add eax,edx
        inc ecx
 
        jnz .L5                 
 
	mov [edi+ecx*4-4],eax
 
    ; tail
	pop ecx
	test cl,1
	jz .L7
	
	mov bl,[esi+0]    ; blue
	mov al,[esi+1]    ; green
	mov ah,[esi+2]    ; red
	shr ah,3
	and al,11111100b
	shl eax,3
	shr bl,3
	add al,bl
	mov [edi+0],al
	mov [edi+1],ah
	add esi,BYTE 4
	add edi,BYTE 2
 
.L7:	
	retn
 
 
 
	
;; 32 bit RGB 888 to 16 BIT BGR 565 
 
_ConvertX86p32_16BGR565:
	
	; check short
	cmp ecx,BYTE 16
	ja .L3
 
.L1:	; short loop
	mov ah,[esi+0]    ; blue
	mov al,[esi+1]    ; green
	mov bl,[esi+2]    ; red
	shr ah,3
	and al,11111100b
	shl eax,3
	shr bl,3
	add al,bl
	mov [edi+0],al
	mov [edi+1],ah
	add esi,BYTE 4
	add edi,BYTE 2
	dec ecx
	jnz .L1
.L2:
	retn
 
.L3:	; head
	mov ebx,edi
	and ebx,BYTE 11b
	jz .L4   
	mov ah,[esi+0]    ; blue
	mov al,[esi+1]    ; green
	mov bl,[esi+2]    ; red
	shr ah,3
	and al,11111100b
	shl eax,3
	shr bl,3
	add al,bl
	mov [edi+0],al
	mov [edi+1],ah
	add esi,BYTE 4
	add edi,BYTE 2
	dec ecx
 
.L4:	; save count
	push ecx
 
	; unroll twice
	shr ecx,1
    
	; point arrays to end
	lea esi,[esi+ecx*8]
	lea edi,[edi+ecx*4]
 
	; negative count
	neg ecx
	jmp SHORT .L6
 
.L5:
	mov [edi+ecx*4-4],eax            
.L6:
	mov edx,[esi+ecx*8+4]
 
        mov bh,[esi+ecx*8+4]                       
        mov ah,[esi+ecx*8]                       
 
        shr bh,3
        mov al,[esi+ecx*8+1]             
 
        shr ah,3
        mov bl,[esi+ecx*8+5]           
 
        shl eax,3
        mov dl,[esi+ecx*8+2]
 
        shl ebx,19
        and eax,0000FFE0h              
                
        shr edx,3
        and ebx,0FFE00000h             
        
        and edx,001F001Fh               
        add eax,ebx
 
        add eax,edx
        inc ecx
 
        jnz .L5                 
 
	mov [edi+ecx*4-4],eax            
 
	; tail
	pop ecx
	and ecx,BYTE 1
	jz .L7
	mov ah,[esi+0]    ; blue
	mov al,[esi+1]    ; green
	mov bl,[esi+2]    ; red
	shr ah,3
	and al,11111100b
	shl eax,3
	shr bl,3
	add al,bl
	mov [edi+0],al
	mov [edi+1],ah
	add esi,BYTE 4
	add edi,BYTE 2
 
.L7:
	retn
 
 
	
	
;; 32 BIT RGB TO 16 BIT RGB 555
 
_ConvertX86p32_16RGB555:
 
	; check short
	cmp ecx,BYTE 16
	ja .L3
 
.L1:	; short loop
	mov bl,[esi+0]    ; blue
	mov al,[esi+1]    ; green
	mov ah,[esi+2]    ; red
	shr ah,3
	and al,11111000b
	shl eax,2
	shr bl,3
	add al,bl
	mov [edi+0],al
	mov [edi+1],ah
	add esi,BYTE 4
	add edi,BYTE 2
	dec ecx
	jnz .L1
.L2:
	retn
 
.L3:	; head
	mov ebx,edi
        and ebx,BYTE 11b
	jz .L4   
	mov bl,[esi+0]    ; blue
	mov al,[esi+1]    ; green
	mov ah,[esi+2]    ; red
	shr ah,3
	and al,11111000b
	shl eax,2
	shr bl,3
	add al,bl
	mov [edi+0],al
	mov [edi+1],ah
	add esi,BYTE 4
	add edi,BYTE 2
	dec ecx
 
.L4:	; save count
	push ecx
 
	; unroll twice
	shr ecx,1
    
	; point arrays to end
	lea esi,[esi+ecx*8]
	lea edi,[edi+ecx*4]
 
	; negative counter 
	neg ecx
	jmp SHORT .L6
 
.L5:
	mov [edi+ecx*4-4],eax
.L6:
	mov eax,[esi+ecx*8]
 
        shr ah,3
        mov ebx,[esi+ecx*8+4]
 
        shr eax,3
        mov edx,[esi+ecx*8+4]
 
        shr bh,3
        mov dl,[esi+ecx*8+2]
 
        shl ebx,13
        and eax,000007FFh
        
        shl edx,7
        and ebx,07FF0000h
 
        and edx,07C007C00h
        add eax,ebx
 
        add eax,edx
        inc ecx
 
        jnz .L5                 
 
	mov [edi+ecx*4-4],eax
 
	; tail
	pop ecx
	and ecx,BYTE 1
	jz .L7
	mov bl,[esi+0]    ; blue
	mov al,[esi+1]    ; green
	mov ah,[esi+2]    ; red
	shr ah,3
	and al,11111000b
	shl eax,2
	shr bl,3
	add al,bl
	mov [edi+0],al
	mov [edi+1],ah
	add esi,BYTE 4
	add edi,BYTE 2
 
.L7:
	retn
 
 
 
 
;; 32 BIT RGB TO 16 BIT BGR 555
	
_ConvertX86p32_16BGR555:
	
	; check short
	cmp ecx,BYTE 16
	ja .L3
 
 
.L1:	; short loop
	mov ah,[esi+0]    ; blue
	mov al,[esi+1]    ; green
	mov bl,[esi+2]    ; red
	shr ah,3
	and al,11111000b
	shl eax,2
	shr bl,3
	add al,bl
	mov [edi+0],al
	mov [edi+1],ah
	add esi,BYTE 4
	add edi,BYTE 2
	dec ecx
	jnz .L1
.L2:
	retn
 
.L3:	; head
	mov ebx,edi
        and ebx,BYTE 11b
	jz .L4   
	mov ah,[esi+0]    ; blue
	mov al,[esi+1]    ; green
	mov bl,[esi+2]    ; red
	shr ah,3
	and al,11111000b
	shl eax,2
	shr bl,3
	add al,bl
	mov [edi+0],al
	mov [edi+1],ah
	add esi,BYTE 4
	add edi,BYTE 2
	dec ecx
 
.L4:	; save count
	push ecx
 
	; unroll twice
	shr ecx,1
    
	; point arrays to end
	lea esi,[esi+ecx*8]
	lea edi,[edi+ecx*4]
 
	; negative counter 
	neg ecx
	jmp SHORT .L6
 
.L5:
	mov [edi+ecx*4-4],eax            
.L6:
	mov edx,[esi+ecx*8+4]
 
        mov bh,[esi+ecx*8+4]                       
        mov ah,[esi+ecx*8]                       
 
        shr bh,3
        mov al,[esi+ecx*8+1]             
 
        shr ah,3
        mov bl,[esi+ecx*8+5]           
 
        shl eax,2
        mov dl,[esi+ecx*8+2]
 
        shl ebx,18
        and eax,00007FE0h              
                
        shr edx,3
        and ebx,07FE00000h             
        
        and edx,001F001Fh               
        add eax,ebx
 
        add eax,edx
        inc ecx
 
        jnz .L5                 
 
	mov [edi+ecx*4-4],eax            
 
	; tail
	pop ecx
	and ecx,BYTE 1
	jz .L7
	mov ah,[esi+0]    ; blue
	mov al,[esi+1]    ; green
	mov bl,[esi+2]    ; red
	shr ah,3
	and al,11111000b
	shl eax,2
	shr bl,3
	add al,bl
	mov [edi+0],al
	mov [edi+1],ah
	add esi,BYTE 4
	add edi,BYTE 2
 
.L7:
	retn
 
 
 
 
	
;; FROM 32 BIT RGB to 8 BIT RGB (rrrgggbbb)
;; This routine writes FOUR pixels at once (dword) and then, if they exist
;; the trailing three pixels
_ConvertX86p32_8RGB332:
 
	
.L_ALIGNED:
	push ecx
 
	shr ecx,2		; We will draw 4 pixels at once
	jnz .L1
	
	jmp .L2			; short jump out of range :(
	
.L1:
	mov eax,[esi]		; first pair of pixels
	mov edx,[esi+4]
 
	shr dl,6
	mov ebx,eax
 
	shr al,6
	and ah,0e0h
 
	shr ebx,16
	and dh,0e0h
	
	shr ah,3
	and bl,0e0h
 
	shr dh,3
	
	or al,bl
	
	mov ebx,edx	
	or al,ah
	
	shr ebx,16
	or dl,dh
 
	and bl,0e0h
	
	or dl,bl
 
	mov ah,dl
 
	
		
	mov ebx,[esi+8]		; second pair of pixels
 
	mov edx,ebx
	and bh,0e0h
 
	shr bl,6
	and edx,0e00000h
 
	shr edx,16
 
	shr bh,3
 
	ror eax,16
	or bl,dl
 
	mov edx,[esi+12]
	or bl,bh
	
	mov al,bl
 
	mov ebx,edx
	and dh,0e0h
 
	shr dl,6
	and ebx,0e00000h
	
	shr dh,3
	mov ah,dl
 
	shr ebx,16
	or ah,dh
 
	or ah,bl
 
	rol eax,16
	add esi,BYTE 16
			
	mov [edi],eax	
	add edi,BYTE 4
	
	dec ecx
	jz .L2			; L1 out of range for short jump :(
	
	jmp .L1
.L2:
	
	pop ecx
	and ecx,BYTE 3		; mask out number of pixels to draw
	
	jz .L4			; Nothing to do anymore
 
.L3:
	mov eax,[esi]		; single pixel conversion for trailing pixels
 
        mov ebx,eax
 
        shr al,6
        and ah,0e0h
 
        shr ebx,16
 
        shr ah,3
        and bl,0e0h
 
        or al,ah
        or al,bl
 
        mov [edi],al
 
        inc edi
        add esi,BYTE 4
 
	dec ecx
	jnz .L3
	
.L4:	
	retn
 
%ifidn __OUTPUT_FORMAT__,elf32
section .note.GNU-stack noalloc noexec nowrite progbits
%endif

Rev 8210	Rev 9172
1	;	1	;
2	; x86 format converters for HERMES	2	; x86 format converters for HERMES
3	; Some routines Copyright (c) 1998 Christian Nentwich (brn@eleet.mcb.at)	3	; Some routines Copyright (c) 1998 Christian Nentwich (brn@eleet.mcb.at)
4	; This source code is licensed under the GNU LGPL	4	; This source code is licensed under the GNU LGPL
5	;	5	;
6	; Please refer to the file COPYING.LIB contained in the distribution for	6	; Please refer to the file COPYING.LIB contained in the distribution for
7	; licensing conditions	7	; licensing conditions
8	;	8	;
9	; Most routines are (c) Glenn Fiedler (ptc@gaffer.org), used with permission	9	; Most routines are (c) Glenn Fiedler (ptc@gaffer.org), used with permission
10	;	10	;
11		-
12		11
13	BITS 32	-
14		-
15	GLOBAL _ConvertX86p32_32BGR888	-
16	GLOBAL _ConvertX86p32_32RGBA888	-
17	GLOBAL _ConvertX86p32_32BGRA888	-
18	GLOBAL _ConvertX86p32_24RGB888	-
19	GLOBAL _ConvertX86p32_24BGR888	-
20	GLOBAL _ConvertX86p32_16RGB565	-
21	GLOBAL _ConvertX86p32_16BGR565	-
22	GLOBAL _ConvertX86p32_16RGB555	12	BITS 32
-		13
-		14	%include "common.inc"
-		15
-		16	SDL_FUNC _ConvertX86p32_32BGR888
-		17	SDL_FUNC _ConvertX86p32_32RGBA888
-		18	SDL_FUNC _ConvertX86p32_32BGRA888
-		19	SDL_FUNC _ConvertX86p32_24RGB888
-		20	SDL_FUNC _ConvertX86p32_24BGR888
-		21	SDL_FUNC _ConvertX86p32_16RGB565
23	GLOBAL _ConvertX86p32_16BGR555	22	SDL_FUNC _ConvertX86p32_16BGR565
24	GLOBAL _ConvertX86p32_8RGB332	23	SDL_FUNC _ConvertX86p32_16RGB555
25		24	SDL_FUNC _ConvertX86p32_16BGR555
26	EXTERN _x86return	25	SDL_FUNC _ConvertX86p32_8RGB332
27		26
28	SECTION .text	27	SECTION .text
29		-
30		28
31	;; _Convert_*	29	;; _Convert_*
32	;; Paramters:	30	;; Paramters:
33	;; ESI = source	31	;; ESI = source
34	;; EDI = dest	32	;; EDI = dest
35	;; ECX = amount (NOT 0!!! (the _ConvertX86 routine checks for that though))	33	;; ECX = amount (NOT 0!!! (the _ConvertX86 routine checks for that though))
36	;; Destroys:	34	;; Destroys:
37	;; EAX, EBX, EDX	35	;; EAX, EBX, EDX
38		36
39		37
40	_ConvertX86p32_32BGR888:	38	_ConvertX86p32_32BGR888:
41		39
42	; check short	40	; check short
43	cmp ecx,BYTE 32	41	cmp ecx,BYTE 32
44	ja .L3	42	ja .L3
45		43
46	.L1 ; short loop	44	.L1: ; short loop
47	mov edx,[esi]	45	mov edx,[esi]
48	bswap edx	46	bswap edx
49	ror edx,8	47	ror edx,8
50	mov [edi],edx	48	mov [edi],edx
51	add esi,BYTE 4	49	add esi,BYTE 4
52	add edi,BYTE 4	50	add edi,BYTE 4
53	dec ecx	51	dec ecx
54	jnz .L1	52	jnz .L1
55	.L2	53	.L2:
56	jmp _x86return	54	retn
57		55
58	.L3 ; save ebp	56	.L3: ; save ebp
59	push ebp	57	push ebp
60		58
61	; unroll four times	59	; unroll four times
62	mov ebp,ecx	60	mov ebp,ecx
63	shr ebp,2	61	shr ebp,2
64		62
65	; save count	63	; save count
66	push ecx	64	push ecx
67		65
68	.L4 mov eax,[esi]	66	.L4: mov eax,[esi]
69	mov ebx,[esi+4]	67	mov ebx,[esi+4]
70		68
71	bswap eax	69	bswap eax
72		70
73	bswap ebx	71	bswap ebx
74		72
75	ror eax,8	73	ror eax,8
76	mov ecx,[esi+8]	74	mov ecx,[esi+8]
77		75
78	ror ebx,8	76	ror ebx,8
79	mov edx,[esi+12]	77	mov edx,[esi+12]
80		78
81	bswap ecx	79	bswap ecx
82		80
83	bswap edx	81	bswap edx
84		82
85	ror ecx,8	83	ror ecx,8
86	mov [edi+0],eax	84	mov [edi+0],eax
87		85
88	ror edx,8	86	ror edx,8
89	mov [edi+4],ebx	87	mov [edi+4],ebx
90		88
91	mov [edi+8],ecx	89	mov [edi+8],ecx
92	mov [edi+12],edx	90	mov [edi+12],edx
93		91
94	add esi,BYTE 16	92	add esi,BYTE 16
95	add edi,BYTE 16	93	add edi,BYTE 16
96		94
97	dec ebp	95	dec ebp
98	jnz .L4	96	jnz .L4
99		97
100	; check tail	98	; check tail
101	pop ecx	99	pop ecx
102	and ecx,BYTE 11b	100	and ecx,BYTE 11b
103	jz .L6	101	jz .L6
104		102
105	.L5 ; tail loop	103	.L5: ; tail loop
106	mov edx,[esi]	104	mov edx,[esi]
107	bswap edx	105	bswap edx
108	ror edx,8	106	ror edx,8
109	mov [edi],edx	107	mov [edi],edx
110	add esi,BYTE 4	108	add esi,BYTE 4
111	add edi,BYTE 4	109	add edi,BYTE 4
112	dec ecx	110	dec ecx
113	jnz .L5	111	jnz .L5
114		112
115	.L6 pop ebp	113	.L6: pop ebp
116	jmp _x86return	114	retn
117		115
118		116
119		117
120		118
121	_ConvertX86p32_32RGBA888:	119	_ConvertX86p32_32RGBA888:
122		120
123	; check short	121	; check short
124	cmp ecx,BYTE 32	122	cmp ecx,BYTE 32
125	ja .L3	123	ja .L3
126		124
127	.L1 ; short loop	125	.L1: ; short loop
128	mov edx,[esi]	126	mov edx,[esi]
129	rol edx,8	127	rol edx,8
130	mov [edi],edx	128	mov [edi],edx
131	add esi,BYTE 4	129	add esi,BYTE 4
132	add edi,BYTE 4	130	add edi,BYTE 4
133	dec ecx	131	dec ecx
134	jnz .L1	132	jnz .L1
135	.L2	133	.L2:
136	jmp _x86return	134	retn
137		135
138	.L3 ; save ebp	136	.L3: ; save ebp
139	push ebp	137	push ebp
140		138
141	; unroll four times	139	; unroll four times
142	mov ebp,ecx	140	mov ebp,ecx
143	shr ebp,2	141	shr ebp,2
144		142
145	; save count	143	; save count
146	push ecx	144	push ecx
147		145
148	.L4 mov eax,[esi]	146	.L4: mov eax,[esi]
149	mov ebx,[esi+4]	147	mov ebx,[esi+4]
150		148
151	rol eax,8	149	rol eax,8
152	mov ecx,[esi+8]	150	mov ecx,[esi+8]
153		151
154	rol ebx,8	152	rol ebx,8
155	mov edx,[esi+12]	153	mov edx,[esi+12]
156		154
157	rol ecx,8	155	rol ecx,8
158	mov [edi+0],eax	156	mov [edi+0],eax
159		157
160	rol edx,8	158	rol edx,8
161	mov [edi+4],ebx	159	mov [edi+4],ebx
162		160
163	mov [edi+8],ecx	161	mov [edi+8],ecx
164	mov [edi+12],edx	162	mov [edi+12],edx
165		163
166	add esi,BYTE 16	164	add esi,BYTE 16
167	add edi,BYTE 16	165	add edi,BYTE 16
168		166
169	dec ebp	167	dec ebp
170	jnz .L4	168	jnz .L4
171		169
172	; check tail	170	; check tail
173	pop ecx	171	pop ecx
174	and ecx,BYTE 11b	172	and ecx,BYTE 11b
175	jz .L6	173	jz .L6
176		174
177	.L5 ; tail loop	175	.L5: ; tail loop
178	mov edx,[esi]	176	mov edx,[esi]
179	rol edx,8	177	rol edx,8
180	mov [edi],edx	178	mov [edi],edx
181	add esi,BYTE 4	179	add esi,BYTE 4
182	add edi,BYTE 4	180	add edi,BYTE 4
183	dec ecx	181	dec ecx
184	jnz .L5	182	jnz .L5
185		183
186	.L6 pop ebp	184	.L6: pop ebp
187	jmp _x86return	185	retn
188		186
189		187
190		188
191		189
192	_ConvertX86p32_32BGRA888:	190	_ConvertX86p32_32BGRA888:
193		191
194	; check short	192	; check short
195	cmp ecx,BYTE 32	193	cmp ecx,BYTE 32
196	ja .L3	194	ja .L3
197		195
198	.L1 ; short loop	196	.L1: ; short loop
199	mov edx,[esi]	197	mov edx,[esi]
200	bswap edx	198	bswap edx
201	mov [edi],edx	199	mov [edi],edx
202	add esi,BYTE 4	200	add esi,BYTE 4
203	add edi,BYTE 4	201	add edi,BYTE 4
204	dec ecx	202	dec ecx
205	jnz .L1	203	jnz .L1
206	.L2	204	.L2:
207	jmp _x86return	205	retn
208		206
209	.L3 ; save ebp	207	.L3: ; save ebp
210	push ebp	208	push ebp
211		209
212	; unroll four times	210	; unroll four times
213	mov ebp,ecx	211	mov ebp,ecx
214	shr ebp,2	212	shr ebp,2
215		213
216	; save count	214	; save count
217	push ecx	215	push ecx
218		216
219	.L4 mov eax,[esi]	217	.L4: mov eax,[esi]
220	mov ebx,[esi+4]	218	mov ebx,[esi+4]
221		219
222	mov ecx,[esi+8]	220	mov ecx,[esi+8]
223	mov edx,[esi+12]	221	mov edx,[esi+12]
224		222
225	bswap eax	223	bswap eax
226		224
227	bswap ebx	225	bswap ebx
228		226
229	bswap ecx	227	bswap ecx
230		228
231	bswap edx	229	bswap edx
232		230
233	mov [edi+0],eax	231	mov [edi+0],eax
234	mov [edi+4],ebx	232	mov [edi+4],ebx
235		233
236	mov [edi+8],ecx	234	mov [edi+8],ecx
237	mov [edi+12],edx	235	mov [edi+12],edx
238		236
239	add esi,BYTE 16	237	add esi,BYTE 16
240	add edi,BYTE 16	238	add edi,BYTE 16
241		239
242	dec ebp	240	dec ebp
243	jnz .L4	241	jnz .L4
244		242
245	; check tail	243	; check tail
246	pop ecx	244	pop ecx
247	and ecx,BYTE 11b	245	and ecx,BYTE 11b
248	jz .L6	246	jz .L6
249		247
250	.L5 ; tail loop	248	.L5: ; tail loop
251	mov edx,[esi]	249	mov edx,[esi]
252	bswap edx	250	bswap edx
253	mov [edi],edx	251	mov [edi],edx
254	add esi,BYTE 4	252	add esi,BYTE 4
255	add edi,BYTE 4	253	add edi,BYTE 4
256	dec ecx	254	dec ecx
257	jnz .L5	255	jnz .L5
258		256
259	.L6 pop ebp	257	.L6: pop ebp
260	jmp _x86return	258	retn
261		259
262		260
263		261
264		262
265	;; 32 bit RGB 888 to 24 BIT RGB 888	263	;; 32 bit RGB 888 to 24 BIT RGB 888
266		264
267	_ConvertX86p32_24RGB888:	265	_ConvertX86p32_24RGB888:
268		266
269	; check short	267	; check short
270	cmp ecx,BYTE 32	268	cmp ecx,BYTE 32
271	ja .L3	269	ja .L3
272		270
273	.L1 ; short loop	271	.L1: ; short loop
274	mov al,[esi]	272	mov al,[esi]
275	mov bl,[esi+1]	273	mov bl,[esi+1]
276	mov dl,[esi+2]	274	mov dl,[esi+2]
277	mov [edi],al	275	mov [edi],al
278	mov [edi+1],bl	276	mov [edi+1],bl
279	mov [edi+2],dl	277	mov [edi+2],dl
280	add esi,BYTE 4	278	add esi,BYTE 4
281	add edi,BYTE 3	279	add edi,BYTE 3
282	dec ecx	280	dec ecx
283	jnz .L1	281	jnz .L1
284	.L2	282	.L2:
285	jmp _x86return	283	retn
286		284
287	.L3 ; head	285	.L3: ; head
288	mov edx,edi	286	mov edx,edi
289	and edx,BYTE 11b	287	and edx,BYTE 11b
290	jz .L4	288	jz .L4
291	mov al,[esi]	289	mov al,[esi]
292	mov bl,[esi+1]	290	mov bl,[esi+1]
293	mov dl,[esi+2]	291	mov dl,[esi+2]
294	mov [edi],al	292	mov [edi],al
295	mov [edi+1],bl	293	mov [edi+1],bl
296	mov [edi+2],dl	294	mov [edi+2],dl
297	add esi,BYTE 4	295	add esi,BYTE 4
298	add edi,BYTE 3	296	add edi,BYTE 3
299	dec ecx	297	dec ecx
300	jmp SHORT .L3	298	jmp SHORT .L3
301		299
302	.L4 ; unroll 4 times	300	.L4: ; unroll 4 times
303	push ebp	301	push ebp
304	mov ebp,ecx	302	mov ebp,ecx
305	shr ebp,2	303	shr ebp,2
306		304
307	; save count	305	; save count
308	push ecx	306	push ecx
309		307
310	.L5 mov eax,[esi] ; first dword eax = [A][R][G][B]	308	.L5: mov eax,[esi] ; first dword eax = [A][R][G][B]
311	mov ebx,[esi+4] ; second dword ebx = [a][r][g][b]	309	mov ebx,[esi+4] ; second dword ebx = [a][r][g][b]
312		310
313	shl eax,8 ; eax = [R][G][B][.]	311	shl eax,8 ; eax = [R][G][B][.]
314	mov ecx,[esi+12] ; third dword ecx = [a][r][g][b]	312	mov ecx,[esi+12] ; third dword ecx = [a][r][g][b]
315		313
316	shl ebx,8 ; ebx = [r][g][b][.]	314	shl ebx,8 ; ebx = [r][g][b][.]
317	mov al,[esi+4] ; eax = [R][G][B][b]	315	mov al,[esi+4] ; eax = [R][G][B][b]
318		316
319	ror eax,8 ; eax = [b][R][G][B] (done)	317	ror eax,8 ; eax = [b][R][G][B] (done)
320	mov bh,[esi+8+1] ; ebx = [r][g][G][.]	318	mov bh,[esi+8+1] ; ebx = [r][g][G][.]
321		319
322	mov [edi],eax	320	mov [edi],eax
323	add edi,BYTE 3*4	321	add edi,BYTE 3*4
324		322
325	shl ecx,8 ; ecx = [r][g][b][.]	323	shl ecx,8 ; ecx = [r][g][b][.]
326	mov bl,[esi+8+0] ; ebx = [r][g][G][B]	324	mov bl,[esi+8+0] ; ebx = [r][g][G][B]
327		325
328	rol ebx,16 ; ebx = [G][B][r][g] (done)	326	rol ebx,16 ; ebx = [G][B][r][g] (done)
329	mov cl,[esi+8+2] ; ecx = [r][g][b][R] (done)	327	mov cl,[esi+8+2] ; ecx = [r][g][b][R] (done)
330		328
331	mov [edi+4-3*4],ebx	329	mov [edi+4-3*4],ebx
332	add esi,BYTE 4*4	330	add esi,BYTE 4*4
333		331
334	mov [edi+8-3*4],ecx	332	mov [edi+8-3*4],ecx
335	dec ebp	333	dec ebp
336		334
337	jnz .L5	335	jnz .L5
338		336
339	; check tail	337	; check tail
340	pop ecx	338	pop ecx
341	and ecx,BYTE 11b	339	and ecx,BYTE 11b
342	jz .L7	340	jz .L7
343		341
344	.L6 ; tail loop	342	.L6: ; tail loop
345	mov al,[esi]	343	mov al,[esi]
346	mov bl,[esi+1]	344	mov bl,[esi+1]
347	mov dl,[esi+2]	345	mov dl,[esi+2]
348	mov [edi],al	346	mov [edi],al
349	mov [edi+1],bl	347	mov [edi+1],bl
350	mov [edi+2],dl	348	mov [edi+2],dl
351	add esi,BYTE 4	349	add esi,BYTE 4
352	add edi,BYTE 3	350	add edi,BYTE 3
353	dec ecx	351	dec ecx
354	jnz .L6	352	jnz .L6
355		353
356	.L7 pop ebp	354	.L7: pop ebp
357	jmp _x86return	355	retn
358		356
359		357
360		358
361		359
362	;; 32 bit RGB 888 to 24 bit BGR 888	360	;; 32 bit RGB 888 to 24 bit BGR 888
363		361
364	_ConvertX86p32_24BGR888:	362	_ConvertX86p32_24BGR888:
365		363
366	; check short	364	; check short
367	cmp ecx,BYTE 32	365	cmp ecx,BYTE 32
368	ja .L3	366	ja .L3
369		-
370		367
371	.L1 ; short loop	368	.L1: ; short loop
372	mov dl,[esi]	369	mov dl,[esi]
373	mov bl,[esi+1]	370	mov bl,[esi+1]
374	mov al,[esi+2]	371	mov al,[esi+2]
375	mov [edi],al	372	mov [edi],al
376	mov [edi+1],bl	373	mov [edi+1],bl
377	mov [edi+2],dl	374	mov [edi+2],dl
378	add esi,BYTE 4	375	add esi,BYTE 4
379	add edi,BYTE 3	376	add edi,BYTE 3
380	dec ecx	377	dec ecx
381	jnz .L1	378	jnz .L1
382	.L2	379	.L2:
383	jmp _x86return	380	retn
384		381
385	.L3 ; head	382	.L3: ; head
386	mov edx,edi	383	mov edx,edi
387	and edx,BYTE 11b	384	and edx,BYTE 11b
388	jz .L4	385	jz .L4
389	mov dl,[esi]	386	mov dl,[esi]
390	mov bl,[esi+1]	387	mov bl,[esi+1]
391	mov al,[esi+2]	388	mov al,[esi+2]
392	mov [edi],al	389	mov [edi],al
393	mov [edi+1],bl	390	mov [edi+1],bl
394	mov [edi+2],dl	391	mov [edi+2],dl
395	add esi,BYTE 4	392	add esi,BYTE 4
396	add edi,BYTE 3	393	add edi,BYTE 3
397	dec ecx	394	dec ecx
398	jmp SHORT .L3	395	jmp SHORT .L3
399		396
400	.L4 ; unroll 4 times	397	.L4: ; unroll 4 times
401	push ebp	398	push ebp
402	mov ebp,ecx	399	mov ebp,ecx
403	shr ebp,2	400	shr ebp,2
404		401
405	; save count	402	; save count
406	push ecx	403	push ecx
407		404
408	.L5	405	.L5:
409	mov eax,[esi] ; first dword eax = [A][R][G][B]	406	mov eax,[esi] ; first dword eax = [A][R][G][B]
410	mov ebx,[esi+4] ; second dword ebx = [a][r][g][b]	407	mov ebx,[esi+4] ; second dword ebx = [a][r][g][b]
411		408
412	bswap eax ; eax = [B][G][R][A]	409	bswap eax ; eax = [B][G][R][A]
413		410
414	bswap ebx ; ebx = [b][g][r][a]	411	bswap ebx ; ebx = [b][g][r][a]
415		412
416	mov al,[esi+4+2] ; eax = [B][G][R][r]	413	mov al,[esi+4+2] ; eax = [B][G][R][r]
417	mov bh,[esi+4+4+1] ; ebx = [b][g][G][a]	414	mov bh,[esi+4+4+1] ; ebx = [b][g][G][a]
418		415
419	ror eax,8 ; eax = [r][B][G][R] (done)	416	ror eax,8 ; eax = [r][B][G][R] (done)
420	mov bl,[esi+4+4+2] ; ebx = [b][g][G][R]	417	mov bl,[esi+4+4+2] ; ebx = [b][g][G][R]
421		418
422	ror ebx,16 ; ebx = [G][R][b][g] (done)	419	ror ebx,16 ; ebx = [G][R][b][g] (done)
423	mov [edi],eax	420	mov [edi],eax
424		421
425	mov [edi+4],ebx	422	mov [edi+4],ebx
426	mov ecx,[esi+12] ; third dword ecx = [a][r][g][b]	423	mov ecx,[esi+12] ; third dword ecx = [a][r][g][b]
427		424
428	bswap ecx ; ecx = [b][g][r][a]	425	bswap ecx ; ecx = [b][g][r][a]
429		426
430	mov cl,[esi+8] ; ecx = [b][g][r][B] (done)	427	mov cl,[esi+8] ; ecx = [b][g][r][B] (done)
431	add esi,BYTE 4*4	428	add esi,BYTE 4*4
432		429
433	mov [edi+8],ecx	430	mov [edi+8],ecx
434	add edi,BYTE 3*4	431	add edi,BYTE 3*4
435		432
436	dec ebp	433	dec ebp
437	jnz .L5	434	jnz .L5
438		435
439	; check tail	436	; check tail
440	pop ecx	437	pop ecx
441	and ecx,BYTE 11b	438	and ecx,BYTE 11b
442	jz .L7	439	jz .L7
443		440
444	.L6 ; tail loop	441	.L6: ; tail loop
445	mov dl,[esi]	442	mov dl,[esi]
446	mov bl,[esi+1]	443	mov bl,[esi+1]
447	mov al,[esi+2]	444	mov al,[esi+2]
448	mov [edi],al	445	mov [edi],al
449	mov [edi+1],bl	446	mov [edi+1],bl
450	mov [edi+2],dl	447	mov [edi+2],dl
451	add esi,BYTE 4	448	add esi,BYTE 4
452	add edi,BYTE 3	449	add edi,BYTE 3
453	dec ecx	450	dec ecx
454	jnz .L6	451	jnz .L6
455		452
456	.L7	453	.L7:
457	pop ebp	454	pop ebp
458	jmp _x86return	455	retn
459		456
460		457
461		458
462		459
463	;; 32 bit RGB 888 to 16 BIT RGB 565	460	;; 32 bit RGB 888 to 16 BIT RGB 565
464		461
465	_ConvertX86p32_16RGB565:	462	_ConvertX86p32_16RGB565:
466	; check short	463	; check short
467	cmp ecx,BYTE 16	464	cmp ecx,BYTE 16
468	ja .L3	465	ja .L3
469		466
470	.L1 ; short loop	467	.L1: ; short loop
471	mov bl,[esi+0] ; blue	468	mov bl,[esi+0] ; blue
472	mov al,[esi+1] ; green	469	mov al,[esi+1] ; green
473	mov ah,[esi+2] ; red	470	mov ah,[esi+2] ; red
474	shr ah,3	471	shr ah,3
475	and al,11111100b	472	and al,11111100b
476	shl eax,3	473	shl eax,3
477	shr bl,3	474	shr bl,3
478	add al,bl	475	add al,bl
479	mov [edi+0],al	476	mov [edi+0],al
480	mov [edi+1],ah	477	mov [edi+1],ah
481	add esi,BYTE 4	478	add esi,BYTE 4
482	add edi,BYTE 2	479	add edi,BYTE 2
483	dec ecx	480	dec ecx
484	jnz .L1	481	jnz .L1
485		482
486	.L2: ; End of short loop	483	.L2: ; End of short loop
487	jmp _x86return	484	retn
488		485
489		486
490	.L3 ; head	487	.L3: ; head
491	mov ebx,edi	488	mov ebx,edi

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/SDL-1.2.2_newlib/src/hermes/x86p_32.asm – Rev 8210 → 9172