Adecuado el diff para que sea como piden.

filtros/diff_asm.asm

@@ -13,17 +13,13 @@ global diff_asm
 
 ; Algunos defines ultiles
 %define PIXEL_SIZE  4
-%define SHIFT_VALUE 8                   ; Potencia de 2 para hacer el calculo del promedio en enteros.
-%define DIV_VALUE   85                  ; Multiplico por el valor sobre 3 para hacer un shift de 8bits a la derecha. (DIV * P)>>8
-                                        ; TODO: El valor SHIFT_VALUE NO PUEDE ser mayor a 8 o pierdo información en la multiplicacion
-                                        ; Para ser mayor tengo que multiplicar y tener en cuenta la parte alta (pmulhw)
-                                        ; Se que el valor máximo que va a haber que multiplicar es es (255*3), por eso puedo
-                                        ; multiplicar hasta por 85 = (256/3), sin que supere 2^16, quedando en parte baja para pmullw.
 
 ; Mascaras y esas cosas
 section .data
-    SHUFFLE_MASK: db 2,2,2,255,3,3,3,255,0,0,0,255,1,1,1,255    ; Mascara para realizar un shuffle para repetir los valores del diff
-    DIVIDIR: dw DIV_VALUE,DIV_VALUE,DIV_VALUE,DIV_VALUE,0,0,0,0 ; Mascara para dividir con enteros usando shifts
+	BLUE_MASK:	db 0,0,0,255,4,4,4,255,8,8,8,255,12,12,12,255 ; TODO: Ver que hacer con el alpha
+	;TODO: Si el alpha viene en 255 entonces puedo poner el mismo byte que vino!!!!
+	GREEN_MASK:	db 1,1,1,255,5,5,5,255,9,9,9,255,13,13,13,255
+	RED_MASK:	db 2,2,2,255,6,6,6,255,10,10,10,255,14,14,14,255
 
 section .text
 ;void diff_asm    (
@@ -44,7 +40,7 @@ diff_asm:
     mov size, rax               ; Guardo el tamaño
     mov dst, r9
     xor cont, cont              ; Limpio el contador
-    movdqu xmm3, [DIVIDIR]      ; Cargo el valor para las divisiones para el promedio
+;    movdqu xmm3, [DIVIDIR]      ; Cargo el valor para las divisiones para el promedio
 
 .loop:
     cmp cont, size              ; Comparo tamaño con el contador
@@ -57,26 +53,25 @@ diff_asm:
     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 |
+.max:
+	; TODO: Mover afuera del ciclo
+	movdqu xmm15, [BLUE_MASK]
+	movdqu xmm14, [GREEN_MASK]
+	movdqu xmm13, [RED_MASK]
+
+	movdqu xmm2, xmm0
+	movdqu xmm3, xmm0
+
+	pshufb xmm0, xmm15			; Pongo en la misma posición cada elemento maximo
+	pshufb xmm2, xmm14
+	pshufb xmm3, xmm13
+
+	pmaxub xmm2, xmm3
+	pmaxub xmm0, xmm2
 
-.dividir:
-    pmullw xmm0, xmm3           ; Multiplico y almaceno parte baja, no llego a usar la parte alta si SHIFT_VALUE < 8
-    psrlw xmm0, SHIFT_VALUE     ; Divido por el valor
-.shuffle:
-    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 tirar invalid read al leer los ultimos pixeles
     add src, PIXEL_SIZE * 4     ; Incremento 4 pixeles
     add src2, PIXEL_SIZE * 4
     add dst, PIXEL_SIZE * 4

filtros/diff_c.c

@@ -3,17 +3,15 @@
 #include <math.h>
 #include "../tp2.h"
 
+int max(int a, int b, int c){
+	if (a > b) {
+		return a > c ? a : c;
+	}else {
+		return b > c ? b : c;
+	}
+}
 
-void diff_c (
-	unsigned char *src,
-	unsigned char *src_2,
-	unsigned char *dst,
-	int m,
-	int n,
-	int src_row_size,
-	int src_2_row_size,
-	int dst_row_size
-) {
+void diff_c (unsigned char *src, unsigned char *src_2, unsigned char *dst, int m, int n, int src_row_size, int src_2_row_size, int dst_row_size) {
 	unsigned char (*src_matrix)[src_row_size] = (unsigned char (*)[src_row_size]) src;
 	unsigned char (*src_2_matrix)[src_2_row_size] = (unsigned char (*)[src_2_row_size]) src_2;
 	unsigned char (*dst_matrix)[dst_row_size] = (unsigned char (*)[dst_row_size]) dst;
@@ -23,9 +21,9 @@ void diff_c (
 
 	for(i=0;i<n;i++){
 		for(j=0;j<m*4;j+=4){
-			val=(abs(src_matrix[i][j+0]-src_2_matrix[i][j+0])+
-				 abs(src_matrix[i][j+1]-src_2_matrix[i][j+1])+
-				 abs(src_matrix[i][j+2]-src_2_matrix[i][j+2])) / 3;
+			val=max(abs(src_matrix[i][j+0]-src_2_matrix[i][j+0]),
+ 					abs(src_matrix[i][j+1]-src_2_matrix[i][j+1]),
+  					abs(src_matrix[i][j+2]-src_2_matrix[i][j+2]));
 
 			dst_matrix[i][j+0]=val;
 			dst_matrix[i][j+1]=val;
@@ -34,5 +32,3 @@ void diff_c (
 		}
 	}
 }
-
-//unsigned inline int abs(