orga2-simd/filtros/diff_asm.asm

; asmsyntax=nasm

default rel
global _diff_asm
global diff_asm

; Alias para no volverme loco con los registros
%define src rdi
%define src2 rsi
%define dst rdx
%define cont rcx
%define size r8

; Algunos defines ultiles
%define PIXEL_SIZE	4

section .data
    ; Mascara para realizar un shuffle para repetir los valores del diff
	SHUFFLE_MASK: db 2,2,2,255,3,3,3,255,0,0,0,255,1,1,1,255
	DIVIDIR: dw 21,21,21,21,0,0,0,0

section .text
;void diff_asm    (
	;unsigned char *src,
    ;unsigned char *src2,
	;unsigned char *dst,
	;int filas,
	;int cols)

_diff_asm:
diff_asm:
    push rbp
    mov rbp, rsp

.calc_size:                     ; Calculo el tamaño de la imagen en bytes
    mov r9, dst                 ; Muevo el destino un rato para hacer el calculo del tamaño de la imagen
    mov rax, cont               ; Cargo filas
    mul size                    ; Multiplico por las columnas
    xor dst, dst                ; Limpio temportal
    mov dst, PIXEL_SIZE         ; Multiplico temporal
    mul dst                     ; Multiplico por el tamaño del pixel
    mov size, rax               ; Guardo el tamaño
    mov dst, r9

    xor cont, cont              ; Limpio el contador

.loop:
    cmp cont, size              ; Comparo tamaño con el contador
    jge .fin                    ; Si ya recorri la imagen voy al final
    pxor xmm1, xmm1
    movdqu xmm0, [src]          ; Cargo la imagen 1 => xmm0 = |B(P1)|G(P1)|R(P1)|A(P1)|B(P2)|G(P2)|......|
    movdqu xmm1, [src2]         ; Cargo la imagen 2 => xmm1 = |B(P1)|G(P1)|R(P1)|A(P1)|B(P2)|G(P2)|......|

.cuentas:                       ; Resto componente a componente de 4 pixeles de cada imagen
    psubb xmm1, xmm0            ; xmm1 = |B(img1_P1) - R(img2_P1)|G(Img1_P1) - Img2_P2|....|
	pabsb xmm0, xmm1            ; Almaceno en xmm0 el valor absoluto de la resta anterior

    ; TODO: Arreglar los comentarios por que estan desordenados los pixeles
	pxor xmm2, xmm2
	movdqu xmm1, xmm0           ; Copio xmm0 a xmm1
	punpckhbw xmm0, xmm2        ; Desempaqueto la parte alta => xmm0 = |B(P1)|G(P1)|R(P1)|A(P1)|B(P2)|G(P2)|R(P2)|A(P2)|
	punpcklbw xmm1, xmm2        ; Desempaqueto la parte baja => xmm1 = |B(P3)|G(P3)|R(P3)|A(P3)|B(P4)|G(P4)|R(P4)|A(P4)|

								; Sumo horizontalmente los pixeles:
	phaddw xmm0, xmm1           ; xmm0 = |B(P1)+G(P1)|R(P1)+A(P1)|B(P2)+G(P2)|R(P2)+A(P2)|....|
	phaddw xmm0, xmm2           ; xmm0 = |B+G+R+A (P1)| B+G+R+A(P2) | B+G+R+A(P3) | B+G+R+A(P4)| 0x0 | 0x0 | 0x0 | 0x0 |

.dividir:
	movdqu xmm3, [DIVIDIR]		; Cargo la mascara para dividir
	pmullw xmm0, xmm3			; Multiplico y almaceno parte baja TODO: Demostrar que no puedo llegar a la parte alta
	psrlw xmm0, 6				; Divido por 64

	packuswb xmm0, xmm2         ; xmm0 = |P1|P2|P3|P4|0x0|0x0|0x0|0x0|0x0|....|

	movdqu xmm2, [SHUFFLE_MASK] ; Cargo la mascara para shuffle
	pshufb xmm0, xmm2           ; Le hago un shuffle a xmm0 con los nuevos valores calculados
.write:
    movdqu [dst], xmm0          ; Escribo en el destino
.endLoop:
    ; TODO: Si el tamaño de la imagen no es multiplo de 4 acá va a sumar y hacer invalid read al llegar al final
    add src, PIXEL_SIZE	* 4     ; Incremento 4 pixeles
    add src2, PIXEL_SIZE * 4
    add dst, PIXEL_SIZE * 4
    add cont, PIXEL_SIZE * 4
    jmp .loop

.fin:
    pop rbp
    ret