Corretto l'effetto seppia che non funzionava con il filtro NTSC.

src/core/gfx.h

@@ -19,7 +19,7 @@
 /* definizione funzione virtuale */
 #if !defined (gfx_filter_function)
 #define gfx_filter_function(name)\
-	void name(WORD *screen, WORD **screen_index, uint32_t *palette, BYTE bpp, uint32_t pitch,\
+	void name(WORD *screen, WORD **screen_index, void *palette, BYTE bpp, uint32_t pitch,\
 	void *pix, WORD rows, WORD lines, WORD width, WORD height, BYTE factor)
 #endif
 
@@ -41,9 +41,9 @@
 #define change_color(plt, blck, index, color, operation)\
 	tmp = plt[index].color + operation;\
 	plt[index].color = (tmp < 0 ? blck : (tmp > 0xFF ? 0xFF : tmp))
-#define rgb_modifier(plt, blck, red, green, blue)\
+#define rgb_modifier(ntscin, plt, blck, red, green, blue)\
 	/* prima ottengo la paletta monocromatica */\
-	ntsc_set(cfg->ntsc_format, PALETTE_MONO, 0, 0, (BYTE *) plt);\
+	ntsc_set(ntscin, cfg->ntsc_format, PALETTE_MONO, 0, 0, (BYTE *) plt);\
 	/* quindi la modifico */\
 	{\
 		WORD i;\
@@ -58,7 +58,7 @@
 		}\
 	}\
 	/* ed infine utilizzo la nuova */\
-	ntsc_set(cfg->ntsc_format, FALSE, 0, (BYTE *) plt,(BYTE *) plt)
+	ntsc_set(ntscin, cfg->ntsc_format, FALSE, 0, (BYTE *) plt,(BYTE *) plt)
 
 enum fullscreen_type { NO_FULLSCR, FULLSCR };
 enum scale_type { X1 = 1, X2, X3, X4, X5, X6 };

src/core/gfx_functions_inline.h

@@ -88,7 +88,7 @@ static void INLINE gfx_FILTER(int filter) {
 		case NTSC_FILTER:
 			gfx_set_screen(NO_CHANGE, NTSC_FILTER, NO_CHANGE, NO_CHANGE, FALSE, FALSE);
 			if (cfg->filter == NTSC_FILTER) {
-				ntsc_set(cfg->ntsc_format, 0, 0, (BYTE *) palette_RGB, 0);
+				ntsc_set(NULL, cfg->ntsc_format, 0, 0, (BYTE *) palette_RGB, 0);
 			}
 			break;
 		case XBRZ2X:

src/video/d3d9/gfx.c

@@ -466,35 +466,35 @@ void gfx_set_screen(BYTE scale, DBWORD filter, BYTE fullscreen, BYTE palette, BY
 						palette = PALETTE_SONY;
 					}
 				} else {
-					ntsc_set(cfg->ntsc_format, FALSE, (BYTE *) palette_base_file, 0,
+					ntsc_set(NULL, cfg->ntsc_format, FALSE, (BYTE *) palette_base_file, 0,
 							(BYTE *) palette_RGB);
 				}
 			}
 		}
 
 		switch (palette) {
 			case PALETTE_PAL:
-				ntsc_set(cfg->ntsc_format, FALSE, (BYTE *) palette_base_pal, 0,
+				ntsc_set(NULL, cfg->ntsc_format, FALSE, (BYTE *) palette_base_pal, 0,
 						(BYTE *) palette_RGB);
 				break;
 			case PALETTE_NTSC:
-				ntsc_set(cfg->ntsc_format, FALSE, 0, 0, (BYTE *) palette_RGB);
+				ntsc_set(NULL, cfg->ntsc_format, FALSE, 0, 0, (BYTE *) palette_RGB);
 				break;
 			case PALETTE_FRBX_UNSATURED:
-				ntsc_set(cfg->ntsc_format, FALSE, (BYTE *) palette_firebrandx_unsaturated_v6, 0,
+				ntsc_set(NULL, cfg->ntsc_format, FALSE, (BYTE *) palette_firebrandx_unsaturated_v6, 0,
 						(BYTE *) palette_RGB);
 				break;
 			case PALETTE_FRBX_YUV:
-				ntsc_set(cfg->ntsc_format, FALSE, (BYTE *) palette_firebrandx_YUV_v3, 0,
+				ntsc_set(NULL, cfg->ntsc_format, FALSE, (BYTE *) palette_firebrandx_YUV_v3, 0,
 						(BYTE *) palette_RGB);
 				break;
 			case PALETTE_GREEN:
-				rgb_modifier(palette_RGB, 0x00, -0x20, 0x20, -0x20);
+				rgb_modifier(NULL, palette_RGB, 0x00, -0x20, 0x20, -0x20);
 				break;
 			case PALETTE_FILE:
 				break;
 			default:
-				ntsc_set(cfg->ntsc_format, palette, 0, 0, (BYTE *) palette_RGB);
+				ntsc_set(NULL, cfg->ntsc_format, palette, 0, 0, (BYTE *) palette_RGB);
 				break;
 		}
 
@@ -504,19 +504,19 @@ void gfx_set_screen(BYTE scale, DBWORD filter, BYTE fullscreen, BYTE palette, BY
 				case RP2C03G:
 					break;
 				case RP2C04:
-					ntsc_set(cfg->ntsc_format, FALSE, (BYTE *) palette_RP2C04_0001, 0,
+					ntsc_set(NULL, cfg->ntsc_format, FALSE, (BYTE *) palette_RP2C04_0001, 0,
 					        (BYTE *) palette_RGB);
 					break;
 				case RP2C04_0002:
-					ntsc_set(cfg->ntsc_format, FALSE, (BYTE *) palette_RP2C04_0002, 0,
+					ntsc_set(NULL, cfg->ntsc_format, FALSE, (BYTE *) palette_RP2C04_0002, 0,
 					        (BYTE *) palette_RGB);
 					break;
 				case RP2C04_0003:
-					ntsc_set(cfg->ntsc_format, FALSE, (BYTE *) palette_RP2C04_0003, 0,
+					ntsc_set(NULL, cfg->ntsc_format, FALSE, (BYTE *) palette_RP2C04_0003, 0,
 					        (BYTE *) palette_RGB);
 					break;
 				case RP2C04_0004:
-					ntsc_set(cfg->ntsc_format, FALSE, (BYTE *) palette_RP2C04_0004, 0,
+					ntsc_set(NULL, cfg->ntsc_format, FALSE, (BYTE *) palette_RP2C04_0004, 0,
 					        (BYTE *) palette_RGB);
 					break;
 				case RC2C03B:
@@ -658,11 +658,21 @@ void gfx_set_screen(BYTE scale, DBWORD filter, BYTE fullscreen, BYTE palette, BY
 	}
 }
 void gfx_draw_screen(BYTE forced) {
-	uint32_t *palette = gfx.palette;
+	void *palette = NULL;
+
+	if (cfg->filter == NTSC_FILTER) {
+		palette = NULL;
+	} else {
+		palette = (void *) gfx.palette;
+	}
 
 	if (!forced) {
 		if (info.no_rom | info.turn_off) {
-			palette = turn_off.palette;
+			if (cfg->filter == NTSC_FILTER) {
+				palette = turn_off.ntsc;
+			} else {
+				palette = (void *) turn_off.palette;
+			}
 
 			if (++info.pause_frames_drawscreen == 2) {
 				tv_noise_effect();
@@ -673,7 +683,11 @@ void gfx_draw_screen(BYTE forced) {
 			}
 		} else if (info.pause) {
 			if (!cfg->disable_sepia_color) {
-				palette = pause.palette;
+				if (cfg->filter == NTSC_FILTER) {
+					palette = pause.ntsc;
+				} else {
+					palette = pause.palette;
+				}
 			}
 
 			if ((++info.pause_frames_drawscreen == 15) || text.on_screen) {

src/video/effects/pause.c

@@ -24,18 +24,25 @@
 #include "video/filters/ntsc.h"
 
 BYTE pause_init(void) {
+	uint32_t *palette;
 	_color_RGB pRGB[NUM_COLORS];
 	WORD i;
 
-	if (!(pause.palette = (uint32_t *) malloc(NUM_COLORS * sizeof(uint32_t)))) {
+	if (!(pause.palette = malloc(NUM_COLORS * sizeof(uint32_t)))) {
 		fprintf(stderr, "Unable to allocate the palette\n");
 		return (EXIT_ERROR);
 	}
+	palette = (uint32_t *) pause.palette;
 
-	rgb_modifier(pRGB, 0x1A, -0x0A, -0x0A, -0x30);
+	if (!(pause.ntsc = malloc(sizeof(nes_ntsc_t)))) {;
+		fprintf(stderr, "Unable to allocate the palette\n");
+		return (EXIT_ERROR);
+	}
+
+	rgb_modifier((nes_ntsc_t *) pause.ntsc, pRGB, 0x1A, -0x0A, -0x0A, -0x30);
 
 	for (i = 0; i < NUM_COLORS; i++) {
-		pause.palette[i] = gfx_color(255, pRGB[i].r, pRGB[i].g, pRGB[i].b);
+		palette[i] = gfx_color(255, pRGB[i].r, pRGB[i].g, pRGB[i].b);
 	}
 
 	return (EXIT_OK);
@@ -45,4 +52,8 @@ void pause_quit(void) {
 		free(pause.palette);
 		pause.palette = NULL;
 	}
+	if (pause.ntsc) {
+		free(pause.ntsc);
+		pause.ntsc = NULL;
+	}
 }

src/video/effects/pause.h

@@ -28,7 +28,8 @@
 #endif
 
 EXTERNC struct _pause {
-	uint32_t *palette;
+	void *palette;
+	void *ntsc;
 } pause;
 
 EXTERNC BYTE pause_init(void);

src/video/effects/tv_noise.c

@@ -26,19 +26,26 @@
 #include "video/filters/ntsc.h"
 
 BYTE tv_noise_init(void) {
+	uint32_t *palette;
 	_color_RGB pRGB[NUM_COLORS];
 	WORD i;
 
-	if (!(turn_off.palette = (uint32_t *) malloc(NUM_COLORS * sizeof(uint32_t)))) {
+	if (!(turn_off.palette = malloc(NUM_COLORS * sizeof(uint32_t)))) {
 		fprintf(stderr, "Unable to allocate the palette\n");
 		return (EXIT_ERROR);
 	}
+	palette = (uint32_t *) turn_off.palette;
 
-	rgb_modifier(pRGB, 0x1A, -0x20, -0x30, -0x20);
-	//rgb_modifier(pRGB, 0x00, -0x20, -0x20, -0x20);
+	if (!(turn_off.ntsc = malloc(sizeof(nes_ntsc_t)))) {;
+		fprintf(stderr, "Unable to allocate the palette\n");
+		return (EXIT_ERROR);
+	}
+
+	rgb_modifier((nes_ntsc_t *) turn_off.ntsc, pRGB, 0x1A, -0x20, -0x30, -0x20);
+	//rgb_modifier((nes_ntsc_t *) turn_off.ntsc, pRGB, 0x00, -0x20, -0x20, -0x20);
 
 	for (i = 0; i < NUM_COLORS; i++) {
-		turn_off.palette[i] = gfx_color(255, pRGB[i].r, pRGB[i].g, pRGB[i].b);
+		palette[i] = gfx_color(255, pRGB[i].r, pRGB[i].g, pRGB[i].b);
 	}
 
 	return (EXIT_OK);
@@ -48,6 +55,10 @@ void tv_noise_quit(void) {
 		free(turn_off.palette);
 		turn_off.palette = NULL;
 	}
+	if (turn_off.ntsc) {
+		free(turn_off.ntsc);
+		turn_off.ntsc = NULL;
+	}
 }
 void tv_noise_effect(void) {
 	static WORD t0 = 0;

src/video/effects/tv_noise.h

@@ -28,7 +28,8 @@
 #endif
 
 EXTERNC struct _turn_off {
-	uint32_t *palette;
+	void *palette;
+	void *ntsc;
 } turn_off;
 
 EXTERNC BYTE tv_noise_init(void);

src/video/filters/hqx.c

@@ -55,10 +55,10 @@ gfx_filter_function(hqNx) {
 	if (factor == 1) {
 		return;
 	} else if (factor == 2) {
-		hq2x_32_rb(screen, pix, palette);
+		hq2x_32_rb(screen, pix, (uint32_t *) palette);
 	} else if (factor == 3) {
-		hq3x_32_rb(screen, pix, palette);
+		hq3x_32_rb(screen, pix, (uint32_t *) palette);
 	} else if (factor == 4) {
-		hq4x_32_rb(screen, pix, palette);
+		hq4x_32_rb(screen, pix, (uint32_t *) palette);
 	}
 }

src/video/filters/ntsc.c

@@ -80,8 +80,8 @@ int burst_phase = 0;
 	*(type *) (out + (pitch << 1)) = *(type *) (out + ((pitch << 1) + pitch)) =\
 			((mixed >> 1) - (mixed >> 4 & mask_darken)) | mask_alpha;\
 }
-#define nes_ntsc(factor) nes_ntscx##factor(ntsc, screen, SCR_ROWS, burst_phase, SCR_ROWS, lines,\
-	pix, pitch, bpp)
+#define nes_ntsc(ntscin, factor) nes_ntscx##factor(ntscin, screen, SCR_ROWS, burst_phase, SCR_ROWS,\
+	lines, pix, pitch, bpp)
 
 /*
  * cio' che non utilizzo in questa funzione
@@ -95,16 +95,20 @@ gfx_filter_function(ntsc_surface) {
 		screen += (SCR_ROWS * overscan.borders->up);
 	}
 
+	if (palette == NULL) {
+		palette = (void *) ntsc;
+	}
+
 	if (factor == 1) {
 		return;
 	} else if (factor == 2) {
-		nes_ntsc(2);
+		nes_ntsc((nes_ntsc_t *) palette, 2);
 		adjust_output(DOUBLE)
 	} else if (factor == 3) {
-		nes_ntsc(3);
+		nes_ntsc((nes_ntsc_t *) palette, 3);
 		adjust_output(TRIPLE);
 	} else if (factor == 4) {
-		nes_ntsc(4);
+		nes_ntsc((nes_ntsc_t *) palette, 4);
 		adjust_output(QUADRUPLE)
 	}
 }
@@ -114,18 +118,22 @@ BYTE ntsc_init(BYTE effect, BYTE color, BYTE *palette_base, BYTE *palette_in, BY
 	format[SVIDEO] = nes_ntsc_svideo;
 	format[RGBMODE] = nes_ntsc_rgb;
 
-	ntsc = (nes_ntsc_t *) malloc(sizeof(nes_ntsc_t));
-	if (!ntsc) {
+	if (!(ntsc = (nes_ntsc_t *) malloc(sizeof(nes_ntsc_t)))) {
 		fprintf(stderr, "Out of memory\n");
 		return (EXIT_ERROR);
 	}
-	ntsc_set(effect, color, palette_base, palette_in, palette_out);
+	ntsc_set(NULL, effect, color, palette_base, palette_in, palette_out);
 	return (EXIT_OK);
 }
 void ntsc_quit(void) {
 	free(ntsc);
 }
-void ntsc_set(BYTE effect, BYTE color, BYTE *palette_base, BYTE *palette_in, BYTE *palette_out) {
+void ntsc_set(nes_ntsc_t *ntsc_in, BYTE effect, BYTE color, BYTE *palette_base, BYTE *palette_in,
+		BYTE *palette_out) {
+	if (!ntsc_in) {
+		ntsc_in = ntsc;
+	}
+
 	if (palette_base) {
 		format[effect].base_palette = (unsigned char *) palette_base;
 	} else {
@@ -167,5 +175,5 @@ void ntsc_set(BYTE effect, BYTE color, BYTE *palette_base, BYTE *palette_in, BYT
 		}
 	}
 
-	nes_ntsc_init(ntsc, &format[effect]);
+	nes_ntsc_init(ntsc_in, &format[effect]);
 }

src/video/filters/ntsc.h

@@ -36,8 +36,8 @@ EXTERNC gfx_filter_function(ntsc_surface);
 EXTERNC BYTE ntsc_init(BYTE effect, BYTE color, BYTE *palette_base, BYTE *palette_in,
 		BYTE *palette_out);
 EXTERNC void ntsc_quit(void);
-EXTERNC void ntsc_set(BYTE effect, BYTE color, BYTE *palette_base, BYTE *palette_in,
-		BYTE *palette_out);
+EXTERNC void ntsc_set(nes_ntsc_t *ntsc_in, BYTE effect, BYTE color, BYTE *palette_base,
+		BYTE *palette_in, BYTE *palette_out);
 
 #undef EXTERNC
 

src/video/filters/scale.c

@@ -49,13 +49,13 @@ gfx_filter_function(scale_surface) {
 	}
 
 	if (factor == 1) {
-		scale_surface1x(screen_index, palette, bpp, pitch, pix);
+		scale_surface1x(screen_index, (uint32_t *) palette, bpp, pitch, pix);
 	} else if (factor == 2) {
-		scale_surface2x(screen_index, palette, bpp, pitch, pix);
+		scale_surface2x(screen_index, (uint32_t *) palette, bpp, pitch, pix);
 	} else if (factor == 3) {
-		scale_surface3x(screen_index, palette, bpp, pitch, pix);
+		scale_surface3x(screen_index, (uint32_t *) palette, bpp, pitch, pix);
 	} else if (factor == 4) {
-		scale_surface4x(screen_index, palette, bpp, pitch, pix);
+		scale_surface4x(screen_index, (uint32_t *) palette, bpp, pitch, pix);
 	}
 }
 void scale_surface1x(WORD **screen_index, uint32_t *palette, BYTE bpp, uint32_t pitch, void *pix) {

src/video/filters/scale2x.c

@@ -93,9 +93,9 @@ gfx_filter_function(scaleNx) {
 	if (factor == 1) {
 		return;
 	} else if (factor == 2) {
-		scale2x(screen_index, palette, bpp, pitch, pix);
+		scale2x(screen_index, (uint32_t *) palette, bpp, pitch, pix);
 	} else if (factor == 3) {
-		scale3x(screen_index, palette, bpp, pitch, pix);
+		scale3x(screen_index, (uint32_t *) palette, bpp, pitch, pix);
 	} else if (factor == 4) {
 		scl4x_buffer.w = rows * 2;
 		scl4x_buffer.h = lines * 2;
@@ -111,7 +111,7 @@ gfx_filter_function(scaleNx) {
 		}
 		scl4x_buffer.size = scl4x_buffer.pitch * scl4x_buffer.h;
 
-		scale4x(screen_index, palette, bpp, pitch, pix);
+		scale4x(screen_index, (uint32_t *) palette, bpp, pitch, pix);
 	}
 }
 void scale2x(WORD **screen_index, uint32_t *palette, BYTE bpp, uint32_t pitch, void *pix) {

src/video/filters/xBRZ.c

@@ -30,7 +30,7 @@ gfx_filter_function(xBRZ) {
 	if (factor == 1) {
 		return;
 	} else {
-		xbrz_scale(factor, screen, (uint32_t *) pix, palette, SCR_ROWS,
+		xbrz_scale(factor, screen, (uint32_t *) pix, (uint32_t *) palette, SCR_ROWS,
 		        (overscan.enabled == TRUE ? overscan.borders->left : 0), rows, lines);
 	}
 }