From 266bc3b92fece7e82f7871a981e3c5d5aa22f107 Mon Sep 17 00:00:00 2001 From: negativeExponent Date: Sun, 26 Jan 2020 10:22:42 +0800 Subject: [PATCH] Implement blargg ntsc filters - this implements blargg's nes ntsc filters using core options - an optional height doubling is also added but disabled for performance reasons (might make that optional as a core option) - since PS2 and PSP have their own blitter branches, these platforms do not have the ntsc filters since i dont have the means to test on those systems. - compile with HAVE_NTSC=1 to have these options, HAVE_NTSC=0 disabled filter including core options - HAVE_NTSC=1 is set as default, other than PS2 and PSP as stated above. --- Makefile.common | 5 + Makefile.libretro | 3 + src/drivers/libretro/libretro.c | 240 +++++++-- src/drivers/libretro/libretro_core_options.h | 16 + src/ntsc/changes.txt | 139 +++++ src/ntsc/license.txt | 504 +++++++++++++++++++ src/ntsc/nes_ntsc.c | 289 +++++++++++ src/ntsc/nes_ntsc.h | 192 +++++++ src/ntsc/nes_ntsc.txt | 218 ++++++++ src/ntsc/nes_ntsc_config.h | 27 + src/ntsc/nes_ntsc_impl.h | 439 ++++++++++++++++ src/ntsc/readme.txt | 61 +++ 12 files changed, 2091 insertions(+), 42 deletions(-) create mode 100644 src/ntsc/changes.txt create mode 100644 src/ntsc/license.txt create mode 100644 src/ntsc/nes_ntsc.c create mode 100644 src/ntsc/nes_ntsc.h create mode 100644 src/ntsc/nes_ntsc.txt create mode 100644 src/ntsc/nes_ntsc_config.h create mode 100644 src/ntsc/nes_ntsc_impl.h create mode 100644 src/ntsc/readme.txt diff --git a/Makefile.common b/Makefile.common index 91305d2..6283995 100644 --- a/Makefile.common +++ b/Makefile.common @@ -17,6 +17,11 @@ else SOURCES_C = $(CORE_DIR)/boards/*.c $(CORE_DIR)/input/*.c endif +ifeq ($(HAVE_NTSC),1) +CFLAGS += -DHAVE_NTSC_FILTER -I$(CORE_DIR)/ntsc +SOURCES_C += $(CORE_DIR)/ntsc/nes_ntsc.c +endif + ifeq ($(HAVE_GRIFFIN),1) SOURCES_C += $(CORE_DIR)/drivers/libretro/griffin.c else diff --git a/Makefile.libretro b/Makefile.libretro index ef52ec0..c687a5f 100644 --- a/Makefile.libretro +++ b/Makefile.libretro @@ -5,6 +5,7 @@ HAVE_GRIFFIN=1 STATIC_LINKING=0 ENDIANNESS_DEFINES= SIGNED_CHAR=0 +HAVE_NTSC=1 SPACE := SPACE := $(SPACE) $(SPACE) @@ -180,6 +181,7 @@ else ifeq ($(platform), ps2) EXTERNAL_ZLIB=1 RETROARCH_OBJECTS += ps2/SMS_Utils.o + HAVE_NTSC = 0 # PSP else ifeq ($(platform), psp1) @@ -192,6 +194,7 @@ else ifeq ($(platform), psp1) PLATFORM_DEFINES += -falign-functions=32 -falign-loops -falign-labels -falign-jumps STATIC_LINKING=1 EXTERNAL_ZLIB=1 + HAVE_NTSC = 0 # Vita else ifeq ($(platform), vita) diff --git a/src/drivers/libretro/libretro.c b/src/drivers/libretro/libretro.c index 85d0c99..8118900 100644 --- a/src/drivers/libretro/libretro.c +++ b/src/drivers/libretro/libretro.c @@ -144,6 +144,30 @@ extern CartInfo UNIFCart; extern int show_crosshair; extern int option_ramstate; +#ifdef HAVE_NTSC_FILTER +/* ntsc */ +#include "nes_ntsc.h" +#define NTSC_NONE 0 +#define NTSC_COMPOSITE 1 +#define NTSC_SVIDEO 2 +#define NTSC_RGB 3 +#define NTSC_MONOCHROME 4 + +static unsigned use_ntsc = 0; +static unsigned burst_phase; +static nes_ntsc_t nes_ntsc; +static nes_ntsc_setup_t ntsc_setup; +static pal base_palette[64]; +static uint8_t *ntsc_video_out = NULL; /* for ntsc blit buffer */ + +static void nes_ntsc_cleanup(void) +{ + if (ntsc_video_out) + free(ntsc_video_out); + ntsc_video_out = NULL; +} +#endif /* HAVE_NTSC_FILTER */ + /* emulator-specific callback functions */ void UpdatePPUView(int refreshchr) { } @@ -836,16 +860,22 @@ void retro_get_system_info(struct retro_system_info *info) void retro_get_system_av_info(struct retro_system_av_info *info) { + unsigned width, height, maxwidth; #ifdef PSP - unsigned width = NES_WIDTH - (use_overscan ? 16 : 0); - unsigned height = NES_HEIGHT - (use_overscan ? 16 : 0); + width = NES_WIDTH - (use_overscan ? 16 : 0); + height = NES_HEIGHT - (use_overscan ? 16 : 0); #else - unsigned width = NES_WIDTH - (overscan_h ? 16 : 0); - unsigned height = NES_HEIGHT - (overscan_v ? 16 : 0); + width = NES_WIDTH - (overscan_h ? 16 : 0); + height = NES_HEIGHT - (overscan_v ? 16 : 0); +#endif +#ifdef HAVE_NTSC_FILTER + maxwidth = NES_NTSC_OUT_WIDTH(NES_WIDTH); +#else + maxwidth = NES_WIDTH; #endif info->geometry.base_width = width; info->geometry.base_height = height; - info->geometry.max_width = NES_WIDTH; + info->geometry.max_width = maxwidth; info->geometry.max_height = NES_HEIGHT; info->geometry.aspect_ratio = (float)(use_par ? NES_8_7_PAR : NES_4_3); info->timing.sample_rate = (float)sndsamplerate; @@ -883,13 +913,17 @@ void retro_init(void) static void retro_set_custom_palette(void) { - uint8_t i,r,g,b; + unsigned i; + unsigned palette_changed; + pal color; ipalette = 0; use_raw_palette = false; + palette_changed = 0; - if (current_palette == PAL_DEFAULT || current_palette == PAL_CUSTOM - || (GameInfo->type == GIT_VSUNI)) + if ((current_palette == PAL_DEFAULT) || + (current_palette == PAL_CUSTOM) || + (GameInfo->type == GIT_VSUNI)) { if (current_palette == PAL_CUSTOM) { @@ -902,35 +936,73 @@ static void retro_set_custom_palette(void) * else it will load default NES palette. * VS Unisystem should always use default palette. */ - return; } - if (current_palette == PAL_RAW) /* raw palette */ + /* setup raw palette */ + else if (current_palette == PAL_RAW) { use_raw_palette = true; for (i = 0; i < 64; i++) { - r = (((i >> 0) & 0xF) * 255) / 15; - g = (((i >> 4) & 0x3) * 255) / 3; - FCEUD_SetPalette( i, r, g, 0); + color.r = (((i >> 0) & 0xF) * 255) / 15; + color.g = (((i >> 4) & 0x3) * 255) / 3; + color.b = 0; + FCEUD_SetPalette( i, color.r, color.g, color.b); } - return; } /* Setup this palette*/ - - for ( i = 0; i < 64; i++ ) + else { - unsigned palette_data = palettes[current_palette].data[i]; - r = ( palette_data >> 16 ) & 0xff; - g = ( ( palette_data & 0xff00 ) >> 8 ) & 0xff; - b = ( palette_data & 0xff ); - FCEUD_SetPalette( i, r, g, b); - FCEUD_SetPalette( i + 64, r, g, b); - FCEUD_SetPalette( i + 128, r, g, b); - FCEUD_SetPalette( i + 192, r, g, b); + unsigned *palette_data = palettes[current_palette].data; + for ( i = 0; i < 64; i++ ) + { + unsigned data = palette_data[i]; + color.r = ( data >> 16 ) & 0xff; + color.g = ( data >> 8 ) & 0xff; + color.b = ( data & 0xff ); + FCEUD_SetPalette( i, color.r, color.g, color.b); + FCEUD_SetPalette( i + 64, color.r, color.g, color.b); + FCEUD_SetPalette( i + 128, color.r, color.g, color.b); + FCEUD_SetPalette( i + 192, color.r, color.g, color.b); +#ifdef HAVE_NTSC_FILTER + palette_changed = 1; + if (use_ntsc) + { + base_palette[i].r = color.r; + base_palette[i].g = color.g; + base_palette[i].b = color.b; + } +#endif + } } +#ifdef HAVE_NTSC_FILTER + if (use_ntsc) { + switch (use_ntsc) { + case NTSC_COMPOSITE: + ntsc_setup = nes_ntsc_composite; + break; + case NTSC_SVIDEO: + ntsc_setup = nes_ntsc_svideo; + break; + case NTSC_RGB: + ntsc_setup = nes_ntsc_rgb; + break; + case NTSC_MONOCHROME: + ntsc_setup = nes_ntsc_monochrome; + break; + default: + break; + } + if (palette_changed) + ntsc_setup.base_palette = (unsigned char const*)base_palette; + else + ntsc_setup.base_palette = ipalette ? (unsigned char const*)palo : NULL; + nes_ntsc_init(&nes_ntsc, &ntsc_setup); + } +#endif + #if defined(RENDER_GSKIT_PS2) if (ps2) { ps2->updatedPalette = true; @@ -990,6 +1062,9 @@ void retro_deinit (void) #endif libretro_supports_bitmasks = false; DPSW_Cleanup(); +#ifdef HAVE_NTSC_FILTER + nes_ntsc_cleanup(); +#endif } void retro_reset(void) @@ -1023,6 +1098,7 @@ static void check_variables(bool startup) struct retro_variable var = {0}; struct retro_system_av_info av_info; bool geometry_update = false; + bool palette_updated = false; char key[256]; int i, enable_apu; @@ -1038,6 +1114,27 @@ static void check_variables(bool startup) option_ramstate = 0; } +#ifdef HAVE_NTSC_FILTER + var.key = "fceumm_ntsc_filter"; + + if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var)) + { + unsigned orig_value = use_ntsc; + if (strcmp(var.value, "disabled") == 0) + use_ntsc = NTSC_NONE; + else if (strcmp(var.value, "composite") == 0) + use_ntsc = NTSC_COMPOSITE; + else if (strcmp(var.value, "svideo") == 0) + use_ntsc = NTSC_SVIDEO; + else if (strcmp(var.value, "rgb") == 0) + use_ntsc = NTSC_RGB; + else if (strcmp(var.value, "monochrome") == 0) + use_ntsc = NTSC_MONOCHROME; + if (use_ntsc != orig_value) + palette_updated = true; + } +#endif + var.key = "fceumm_palette"; if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value) @@ -1084,9 +1181,12 @@ static void check_variables(bool startup) current_palette = 15; if (current_palette != orig_value) - retro_set_custom_palette(); + palette_updated = true; } + if (palette_updated) + retro_set_custom_palette(); + var.key = "fceumm_up_down_allowed"; if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value) @@ -1715,28 +1815,74 @@ static void retro_run_blit(uint8_t *gfx) video_cb(buf, width, height, pitch); #else - incr += (overscan_h ? 16 : 0); - width -= (overscan_h ? 16 : 0); - height -= (overscan_v ? 16 : 0); - pitch -= (overscan_h ? 32 : 0); - gfx += (overscan_v ? ((overscan_h ? 8 : 0) + 256 * 8) : (overscan_h ? 8 : 0)); - - if (use_raw_palette) +#ifdef HAVE_NTSC_FILTER + if (use_ntsc) { - extern uint8 PPU[4]; - int deemp = (PPU[1] >> 5) << 2; - for (y = 0; y < height; y++, gfx += incr) - for ( x = 0; x < width; x++, gfx++) - fceu_video_out[y * width + x] = retro_palette[*gfx & 0x3F] | deemp; + int y; + unsigned out_width, out_height, out_pitch; + + /*burst_phase ^= 1; + if (ntsc_setup.merge_fields) burst_phase = 0;*/ + + width = overscan_h ? 240 : 256; + height = overscan_v ? 224 : 240; + out_width = NES_NTSC_OUT_WIDTH(width); + out_height = height; + out_pitch = out_width * sizeof(uint16_t); + gfx += (overscan_v ? ((overscan_h ? 8 : 0) + 256 * 8) : (overscan_h ? 8 : 0)); + + nes_ntsc_blit(&nes_ntsc, (const unsigned char*)gfx, NES_WIDTH, burst_phase, width, height, ntsc_video_out, out_pitch); + +#if 0 /* this doubles the height for proper scaling, disabled for performance reasons */ + out_height <<= 1; + for (y = out_height / 2; --y >= 0;) + { + uint8_t const *in = ntsc_video_out + y * out_pitch; + uint8_t *out = ntsc_video_out + y * 2 * out_pitch; + int n; + for (n = out_width; n; --n) + { + unsigned prev = *(uint16_t*)in; + unsigned next = *(uint16_t*)(in + out_pitch); + /* mix 16-bit rgb without losing low bits */ + unsigned mixed = prev + next + ((prev ^ next) & 0x0821); + /* darken by 12% */ + *(uint16_t*)out = prev; + *(uint16_t*)(out + out_pitch) = (mixed >> 1) - (mixed >> 4 & 0x18E3); + in += 2; + out += 2; + } + } +#endif + + video_cb(ntsc_video_out, out_width, out_height, out_pitch); } else +#endif /* HAVE_NTSC_FILTER */ { - for (y = 0; y < height; y++, gfx += incr) - for ( x = 0; x < width; x++, gfx++) - fceu_video_out[y * width + x] = retro_palette[*gfx]; + incr += (overscan_h ? 16 : 0); + width -= (overscan_h ? 16 : 0); + height -= (overscan_v ? 16 : 0); + pitch -= (overscan_h ? 32 : 0); + gfx += (overscan_v ? ((overscan_h ? 8 : 0) + 256 * 8) : (overscan_h ? 8 : 0)); + + if (use_raw_palette) + { + extern uint8 PPU[4]; + int deemp = (PPU[1] >> 5) << 2; + for (y = 0; y < height; y++, gfx += incr) + for (x = 0; x < width; x++, gfx++) + fceu_video_out[y * width + x] = retro_palette[*gfx & 0x3F] | deemp; + } + else + { + for (y = 0; y < height; y++, gfx += incr) + for (x = 0; x < width; x++, gfx++) + fceu_video_out[y * width + x] = retro_palette[*gfx]; + } + video_cb(fceu_video_out, width, height, pitch); } - video_cb(fceu_video_out, width, height, pitch); #endif } @@ -2185,6 +2331,13 @@ bool retro_load_game(const struct retro_game_info *game) if (environ_cb(RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY, &sav_dir) && sav_dir) FCEUI_SetSaveDirectory(sav_dir); +#ifdef HAVE_NTSC_FILTER + use_ntsc = 0; + memset(base_palette, 0, sizeof(base_palette)); + memset(&nes_ntsc, 0, sizeof(nes_ntsc)); + ntsc_video_out = (uint8_t*)malloc(NES_NTSC_OUT_WIDTH(NES_WIDTH) * (NES_HEIGHT * 2) * sizeof(uint16_t)); +#endif + FCEUI_Initialize(); FCEUI_SetSoundVolume(sndvolume); @@ -2260,7 +2413,7 @@ bool retro_load_game(const struct retro_game_info *game) } } /* This doesn't map in 2004--2007 but those aren't really - * worthwhile to read from on a vblank anyway + * worthwhile to read from on a vblank anyway */ descs[i].flags = 0; descs[i].ptr = PPU; @@ -2340,6 +2493,9 @@ void retro_unload_game(void) #if defined(RENDER_GSKIT_PS2) ps2 = NULL; #endif +#ifdef HAVE_NTSC_FILTER + nes_ntsc_cleanup(); +#endif } unsigned retro_get_region(void) diff --git a/src/drivers/libretro/libretro_core_options.h b/src/drivers/libretro/libretro_core_options.h index 75acd01..35ce4c9 100644 --- a/src/drivers/libretro/libretro_core_options.h +++ b/src/drivers/libretro/libretro_core_options.h @@ -77,6 +77,22 @@ struct retro_core_option_definition option_defs_common[] = { }, "disabled", }, +#ifdef HAVE_NTSC_FILTER + { + "fceumm_ntsc_filter", + "NTSC Filter", + "Enable blargg NTSC filters.", + { + { "disabled", NULL }, + { "composite", NULL }, + { "svideo", NULL }, + { "rgb", NULL }, + { "monochrome", NULL }, + { NULL, NULL }, + }, + "disabled" + }, +#endif { "fceumm_palette", "Color Palette", diff --git a/src/ntsc/changes.txt b/src/ntsc/changes.txt new file mode 100644 index 0000000..d9a9db7 --- /dev/null +++ b/src/ntsc/changes.txt @@ -0,0 +1,139 @@ +nes_ntsc Change Log +------------------- + +nes_ntsc 0.2.3 +-------------- +- Added ability to use a custom RGB palette in place of the NES color +circuitry (with the option of being before color emphasis). When using +this palette with otherwise default settings, RGB colors appear on +screen exactly as in custom palette. + +- Moved configuration options to nes_ntsc_config.h, making it easier to +manage + +- Made color emphasis support configurable in nes_ntsc_config.h (off by +default). Previously, there were separate functions; now there is only +one set of functions and whether they support color emphasis is +configurable. If color emphasis support is OFF, then nes_ntsc_init() and +related behave as before, and the nes_ntsc_init_emph() functionality is +not available. If color emphasis support is ON, then nes_ntsc_init() and +related behave as nes_ntsc_init_emph() and related did before, and +nes_ntsc_init() and related functionality is not available (so you would +need to update any code that uses palette_out and expects only 64 colors +to be written; see the end of demo.c for example). + +- Removed hue_warping for now, due to its obscurity + +- Greatly clarified and improved demo to read any uncompressed BMP image +and write filtered image when done + +- Improved gamma to be properly applied to each RGB channel, and changed +default to compensate for difference between PC monitor and TV gamma + +- Improved contrast to be properly applied to each RGB channel rather +than just luma + +- Improved floating point calculations in library to be more stable and +not need double precision, which was causing problems with the sharpness +control on Windows when the DirectX libraries changed the FPU to single +precision mode + +- Eliminated slight artifacts still visible when using the RGB preset +with field merging off + +- Added extern "C" to header, allowing use in C++ without having to +rename the source file + +- Made internal changes to factor out code common from all my NTSC +filter libraries, greatly simplifying things for me + + +nes_ntsc 0.2.0 +-------------- +- Significantly improved NTSC signal processing to give clearer image +and better sharpness control + +- Added parameters for gamma, resolution, color bleed, artifacts, and +color fringing + +- Added presets for composite video, S-video, RGB, and monochrome + +- Added NES_NTSC_OUT_WIDTH() and NES_NTSC_IN_WIDTH() for calculating +input/output widths + +- Improved default blitter to support emphasis and allow specification +of RGB output bit depth + +- Improved demo with more controls and interpolation and darkening of +scanlines rather than duplicating them + +- Improved documentation + +- Interface changes: nes_ntsc_blit() now takes *input* size rather than +output size. NES_NTSC_BEGIN_ROW now takes two additional pixels. + +- Deprecated: nes_ntsc_x_in/out_width, NES_NTSC_RGBnn_OUT, and +NES_NTSC_RAW_OUT + + +nes_ntsc 0.1.7 +-------------- +- Fixed color emphasis to affect xD colors instead of incorrectly +leaving them as always gray + +- Added ability to generate a 64- or 512-color RGB palette for use when +full NTSC emulation isn't desired + +- Documented more accurate burst_phase handling and included three test +ROMs for verifying proper implementation + +- Moved color emphasis support to new nes_ntsc_emph_t structure, +eliminating the ugly global NES_NTSC_DISABLE_EMPHASIS configuration +macro + +- Extended demo to use optional Sony decoder matrix and write standard +192-byte NES .PAL file using current settings + +- Improved documentation slightly + +- Lowered maximum saturation to avoid overflow of blue when blue color +emphasis is enabled + + +nes_ntsc 0.1.6 +-------------- +- Cleaned up hue, decoder matrix, and hue warping to do transformations +in the proper order and direction + + +nes_ntsc 0.1.5 +-------------- +- Added support for color emphasis/tint bits (can be turned off to +reduce memory usage) + +- Added ability to specify optional decoder matrix + +- Improved documentation + +- Added constants for overscan borders + + +nes_ntsc 0.1.0 +-------------- +- First official version + +- Completely rewrote algorithm to do all NTSC signal processing at +initialization time, putting results into a table for use during +blitting. This increased performance by over 300% and allowed many +improvements in quality and image options. + +- Eliminated multiple output formats and options. Now you can define a +custom blitter for this. + +- Added sharpness and "hue warping" controls + +- Added option to merge even and odd artifacts to reduce flicker when +host monitor's refresh rate doesn't match emulator's frame rate. + +- Added built-in horizontal rescaling. I never realized the old one was +way too wide. diff --git a/src/ntsc/license.txt b/src/ntsc/license.txt new file mode 100644 index 0000000..5faba9d --- /dev/null +++ b/src/ntsc/license.txt @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/src/ntsc/nes_ntsc.c b/src/ntsc/nes_ntsc.c new file mode 100644 index 0000000..004abb6 --- /dev/null +++ b/src/ntsc/nes_ntsc.c @@ -0,0 +1,289 @@ +/* nes_ntsc 0.2.2. http://www.slack.net/~ant/ */ + +#include "nes_ntsc.h" + +/* Copyright (C) 2006-2007 Shay Green. This module is free software; you +can redistribute it and/or modify it under the terms of the GNU Lesser +General Public License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. This +module is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more +details. You should have received a copy of the GNU Lesser General Public +License along with this module; if not, write to the Free Software Foundation, +Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ + +nes_ntsc_setup_t const nes_ntsc_monochrome = { 0,-1, 0, 0,.2, 0,.2,-.2,-.2,-1, 1, 0, 0, 0, 0 }; +nes_ntsc_setup_t const nes_ntsc_composite = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 }; +nes_ntsc_setup_t const nes_ntsc_svideo = { 0, 0, 0, 0,.2, 0,.2, -1, -1, 0, 1, 0, 0, 0, 0 }; +nes_ntsc_setup_t const nes_ntsc_rgb = { 0, 0, 0, 0,.2, 0,.7, -1, -1,-1, 1, 0, 0, 0, 0 }; + +#define alignment_count 3 +#define burst_count 3 +#define rescale_in 8 +#define rescale_out 7 + +#define artifacts_mid 1.0f +#define fringing_mid 1.0f +#define std_decoder_hue -15 + +#define STD_HUE_CONDITION( setup ) !(setup->base_palette || setup->palette) + +#include "nes_ntsc_impl.h" + +/* 3 input pixels -> 8 composite samples */ +pixel_info_t const nes_ntsc_pixels [alignment_count] = { + { PIXEL_OFFSET( -4, -9 ), { 1, 1, .6667f, 0 } }, + { PIXEL_OFFSET( -2, -7 ), { .3333f, 1, 1, .3333f } }, + { PIXEL_OFFSET( 0, -5 ), { 0, .6667f, 1, 1 } }, +}; + +static void merge_kernel_fields( nes_ntsc_rgb_t* io ) +{ + int n; + for ( n = burst_size; n; --n ) + { + nes_ntsc_rgb_t p0 = io [burst_size * 0] + rgb_bias; + nes_ntsc_rgb_t p1 = io [burst_size * 1] + rgb_bias; + nes_ntsc_rgb_t p2 = io [burst_size * 2] + rgb_bias; + /* merge colors without losing precision */ + io [burst_size * 0] = + ((p0 + p1 - ((p0 ^ p1) & nes_ntsc_rgb_builder)) >> 1) - rgb_bias; + io [burst_size * 1] = + ((p1 + p2 - ((p1 ^ p2) & nes_ntsc_rgb_builder)) >> 1) - rgb_bias; + io [burst_size * 2] = + ((p2 + p0 - ((p2 ^ p0) & nes_ntsc_rgb_builder)) >> 1) - rgb_bias; + ++io; + } +} + +static void correct_errors( nes_ntsc_rgb_t color, nes_ntsc_rgb_t* out ) +{ + int n; + for ( n = burst_count; n; --n ) + { + unsigned i; + for ( i = 0; i < rgb_kernel_size / 2; i++ ) + { + nes_ntsc_rgb_t error = color - + out [i ] - out [(i+12)%14+14] - out [(i+10)%14+28] - + out [i + 7] - out [i + 5 +14] - out [i + 3 +28]; + DISTRIBUTE_ERROR( i+3+28, i+5+14, i+7 ); + } + out += alignment_count * rgb_kernel_size; + } +} + +void nes_ntsc_init( nes_ntsc_t* ntsc, nes_ntsc_setup_t const* setup ) +{ + int merge_fields; + int entry; + init_t impl; + float gamma_factor; + + if ( !setup ) + setup = &nes_ntsc_composite; + init( &impl, setup ); + + /* setup fast gamma */ + { + float gamma = (float) setup->gamma * -0.5f; + if ( STD_HUE_CONDITION( setup ) ) + gamma += 0.1333f; + + gamma_factor = (float) pow( (float) fabs( gamma ), 0.73f ); + if ( gamma < 0 ) + gamma_factor = -gamma_factor; + } + + merge_fields = setup->merge_fields; + if ( setup->artifacts <= -1 && setup->fringing <= -1 ) + merge_fields = 1; + + for ( entry = 0; entry < nes_ntsc_palette_size; entry++ ) + { + /* Base 64-color generation */ + static float const lo_levels [4] = { -0.12f, 0.00f, 0.31f, 0.72f }; + static float const hi_levels [4] = { 0.40f, 0.68f, 1.00f, 1.00f }; + int level = entry >> 4 & 0x03; + float lo = lo_levels [level]; + float hi = hi_levels [level]; + + int color = entry & 0x0F; + if ( color == 0 ) + lo = hi; + if ( color == 0x0D ) + hi = lo; + if ( color > 0x0D ) + hi = lo = 0.0f; + + { + /* phases [i] = cos( i * PI / 6 ) */ + static float const phases [0x10 + 3] = { + -1.0f, -0.866025f, -0.5f, 0.0f, 0.5f, 0.866025f, + 1.0f, 0.866025f, 0.5f, 0.0f, -0.5f, -0.866025f, + -1.0f, -0.866025f, -0.5f, 0.0f, 0.5f, 0.866025f, + 1.0f + }; + #define TO_ANGLE_SIN( color ) phases [color] + #define TO_ANGLE_COS( color ) phases [(color) + 3] + + /* Convert raw waveform to YIQ */ + float sat = (hi - lo) * 0.5f; + float i = TO_ANGLE_SIN( color ) * sat; + float q = TO_ANGLE_COS( color ) * sat; + float y = (hi + lo) * 0.5f; + + /* Optionally use base palette instead */ + if ( setup->base_palette ) + { + unsigned char const* in = &setup->base_palette [(entry & 0x3F) * 3]; + static float const to_float = 1.0f / 0xFF; + float r = to_float * in [0]; + float g = to_float * in [1]; + float b = to_float * in [2]; + q = RGB_TO_YIQ( r, g, b, y, i ); + } + + /* Apply color emphasis */ + #ifdef NES_NTSC_EMPHASIS + { + int tint = entry >> 6 & 7; + if ( tint && color <= 0x0D ) + { + static float const atten_mul = 0.79399f; + static float const atten_sub = 0.0782838f; + + if ( tint == 7 ) + { + y = y * (atten_mul * 1.13f) - (atten_sub * 1.13f); + } + else + { + static unsigned char const tints [8] = { 0, 6, 10, 8, 2, 4, 0, 0 }; + int const tint_color = tints [tint]; + float sat = hi * (0.5f - atten_mul * 0.5f) + atten_sub * 0.5f; + y -= sat * 0.5f; + if ( tint >= 3 && tint != 4 ) + { + /* combined tint bits */ + sat *= 0.6f; + y -= sat; + } + i += TO_ANGLE_SIN( tint_color ) * sat; + q += TO_ANGLE_COS( tint_color ) * sat; + } + } + } + #endif + + /* Optionally use palette instead */ + if ( setup->palette ) + { + unsigned char const* in = &setup->palette [entry * 3]; + static float const to_float = 1.0f / 0xFF; + float r = to_float * in [0]; + float g = to_float * in [1]; + float b = to_float * in [2]; + q = RGB_TO_YIQ( r, g, b, y, i ); + } + + /* Apply brightness, contrast, and gamma */ + y *= (float) setup->contrast * 0.5f + 1; + /* adjustment reduces error when using input palette */ + y += (float) setup->brightness * 0.5f - 0.5f / 256; + + { + float r, g, b = YIQ_TO_RGB( y, i, q, default_decoder, float, r, g ); + + /* fast approximation of n = pow( n, gamma ) */ + r = (r * gamma_factor - gamma_factor) * r + r; + g = (g * gamma_factor - gamma_factor) * g + g; + b = (b * gamma_factor - gamma_factor) * b + b; + + q = RGB_TO_YIQ( r, g, b, y, i ); + } + + i *= rgb_unit; + q *= rgb_unit; + y *= rgb_unit; + y += rgb_offset; + + /* Generate kernel */ + { + int r, g, b = YIQ_TO_RGB( y, i, q, impl.to_rgb, int, r, g ); + /* blue tends to overflow, so clamp it */ + nes_ntsc_rgb_t rgb = PACK_RGB( r, g, (b < 0x3E0 ? b: 0x3E0) ); + + if ( setup->palette_out ) + RGB_PALETTE_OUT( rgb, &setup->palette_out [entry * 3] ); + + if ( ntsc ) + { + nes_ntsc_rgb_t* kernel = ntsc->table [entry]; + gen_kernel( &impl, y, i, q, kernel ); + if ( merge_fields ) + merge_kernel_fields( kernel ); + correct_errors( rgb, kernel ); + } + } + } + } +} + +#ifndef NES_NTSC_NO_BLITTERS + +void nes_ntsc_blit( nes_ntsc_t const* ntsc, NES_NTSC_IN_T const* input, long in_row_width, + int burst_phase, int in_width, int in_height, void* rgb_out, long out_pitch ) +{ + int chunk_count = (in_width - 1) / nes_ntsc_in_chunk; + for ( ; in_height; --in_height ) + { + NES_NTSC_IN_T const* line_in = input; + NES_NTSC_BEGIN_ROW( ntsc, burst_phase, + nes_ntsc_black, nes_ntsc_black, NES_NTSC_ADJ_IN( *line_in ) ); + nes_ntsc_out_t* restrict line_out = (nes_ntsc_out_t*) rgb_out; + int n; + ++line_in; + + for ( n = chunk_count; n; --n ) + { + /* order of input and output pixels must not be altered */ + NES_NTSC_COLOR_IN( 0, NES_NTSC_ADJ_IN( line_in [0] ) ); + NES_NTSC_RGB_OUT( 0, line_out [0], NES_NTSC_OUT_DEPTH ); + NES_NTSC_RGB_OUT( 1, line_out [1], NES_NTSC_OUT_DEPTH ); + + NES_NTSC_COLOR_IN( 1, NES_NTSC_ADJ_IN( line_in [1] ) ); + NES_NTSC_RGB_OUT( 2, line_out [2], NES_NTSC_OUT_DEPTH ); + NES_NTSC_RGB_OUT( 3, line_out [3], NES_NTSC_OUT_DEPTH ); + + NES_NTSC_COLOR_IN( 2, NES_NTSC_ADJ_IN( line_in [2] ) ); + NES_NTSC_RGB_OUT( 4, line_out [4], NES_NTSC_OUT_DEPTH ); + NES_NTSC_RGB_OUT( 5, line_out [5], NES_NTSC_OUT_DEPTH ); + NES_NTSC_RGB_OUT( 6, line_out [6], NES_NTSC_OUT_DEPTH ); + + line_in += 3; + line_out += 7; + } + + /* finish final pixels */ + NES_NTSC_COLOR_IN( 0, nes_ntsc_black ); + NES_NTSC_RGB_OUT( 0, line_out [0], NES_NTSC_OUT_DEPTH ); + NES_NTSC_RGB_OUT( 1, line_out [1], NES_NTSC_OUT_DEPTH ); + + NES_NTSC_COLOR_IN( 1, nes_ntsc_black ); + NES_NTSC_RGB_OUT( 2, line_out [2], NES_NTSC_OUT_DEPTH ); + NES_NTSC_RGB_OUT( 3, line_out [3], NES_NTSC_OUT_DEPTH ); + + NES_NTSC_COLOR_IN( 2, nes_ntsc_black ); + NES_NTSC_RGB_OUT( 4, line_out [4], NES_NTSC_OUT_DEPTH ); + NES_NTSC_RGB_OUT( 5, line_out [5], NES_NTSC_OUT_DEPTH ); + NES_NTSC_RGB_OUT( 6, line_out [6], NES_NTSC_OUT_DEPTH ); + + burst_phase = (burst_phase + 1) % nes_ntsc_burst_count; + input += in_row_width; + rgb_out = (char*) rgb_out + out_pitch; + } +} + +#endif diff --git a/src/ntsc/nes_ntsc.h b/src/ntsc/nes_ntsc.h new file mode 100644 index 0000000..6bfa8f1 --- /dev/null +++ b/src/ntsc/nes_ntsc.h @@ -0,0 +1,192 @@ +/* NES NTSC video filter */ + +/* nes_ntsc 0.2.2 */ +#ifndef NES_NTSC_H +#define NES_NTSC_H + +#include "nes_ntsc_config.h" + +#ifdef __cplusplus + extern "C" { +#endif + +/* Image parameters, ranging from -1.0 to 1.0. Actual internal values shown +in parenthesis and should remain fairly stable in future versions. */ +typedef struct nes_ntsc_setup_t +{ + /* Basic parameters */ + double hue; /* -1 = -180 degrees +1 = +180 degrees */ + double saturation; /* -1 = grayscale (0.0) +1 = oversaturated colors (2.0) */ + double contrast; /* -1 = dark (0.5) +1 = light (1.5) */ + double brightness; /* -1 = dark (0.5) +1 = light (1.5) */ + double sharpness; /* edge contrast enhancement/blurring */ + + /* Advanced parameters */ + double gamma; /* -1 = dark (1.5) +1 = light (0.5) */ + double resolution; /* image resolution */ + double artifacts; /* artifacts caused by color changes */ + double fringing; /* color artifacts caused by brightness changes */ + double bleed; /* color bleed (color resolution reduction) */ + int merge_fields; /* if 1, merges even and odd fields together to reduce flicker */ + float const* decoder_matrix; /* optional RGB decoder matrix, 6 elements */ + + unsigned char* palette_out; /* optional RGB palette out, 3 bytes per color */ + + /* You can replace the standard NES color generation with an RGB palette. The + first replaces all color generation, while the second replaces only the core + 64-color generation and does standard color emphasis calculations on it. */ + unsigned char const* palette;/* optional 512-entry RGB palette in, 3 bytes per color */ + unsigned char const* base_palette;/* optional 64-entry RGB palette in, 3 bytes per color */ +} nes_ntsc_setup_t; + +/* Video format presets */ +extern nes_ntsc_setup_t const nes_ntsc_composite; /* color bleeding + artifacts */ +extern nes_ntsc_setup_t const nes_ntsc_svideo; /* color bleeding only */ +extern nes_ntsc_setup_t const nes_ntsc_rgb; /* crisp image */ +extern nes_ntsc_setup_t const nes_ntsc_monochrome;/* desaturated + artifacts */ + +#ifdef NES_NTSC_EMPHASIS + enum { nes_ntsc_palette_size = 64 * 8 }; +#else + enum { nes_ntsc_palette_size = 64 }; +#endif + +/* Initializes and adjusts parameters. Can be called multiple times on the same +nes_ntsc_t object. Can pass NULL for either parameter. */ +typedef struct nes_ntsc_t nes_ntsc_t; +void nes_ntsc_init( nes_ntsc_t* ntsc, nes_ntsc_setup_t const* setup ); + +/* Filters one or more rows of pixels. Input pixels are 6/9-bit palette indicies. +In_row_width is the number of pixels to get to the next input row. Out_pitch +is the number of *bytes* to get to the next output row. Output pixel format +is set by NES_NTSC_OUT_DEPTH (defaults to 16-bit RGB). */ +void nes_ntsc_blit( nes_ntsc_t const* ntsc, NES_NTSC_IN_T const* nes_in, + long in_row_width, int burst_phase, int in_width, int in_height, + void* rgb_out, long out_pitch ); + +/* Number of output pixels written by blitter for given input width. Width might +be rounded down slightly; use NES_NTSC_IN_WIDTH() on result to find rounded +value. Guaranteed not to round 256 down at all. */ +#define NES_NTSC_OUT_WIDTH( in_width ) \ + ((((in_width) - 1) / nes_ntsc_in_chunk + 1) * nes_ntsc_out_chunk) + +/* Number of input pixels that will fit within given output width. Might be +rounded down slightly; use NES_NTSC_OUT_WIDTH() on result to find rounded +value. */ +#define NES_NTSC_IN_WIDTH( out_width ) \ + (((out_width) / nes_ntsc_out_chunk - 1) * nes_ntsc_in_chunk + 1) + + +/* Interface for user-defined custom blitters */ + +enum { nes_ntsc_in_chunk = 3 }; /* number of input pixels read per chunk */ +enum { nes_ntsc_out_chunk = 7 }; /* number of output pixels generated per chunk */ +enum { nes_ntsc_black = 15 }; /* palette index for black */ +enum { nes_ntsc_burst_count = 3 }; /* burst phase cycles through 0, 1, and 2 */ + +/* Begins outputting row and starts three pixels. First pixel will be cut off a bit. +Use nes_ntsc_black for unused pixels. Declares variables, so must be before first +statement in a block (unless you're using C++). */ +#define NES_NTSC_BEGIN_ROW( ntsc, burst, pixel0, pixel1, pixel2 ) \ + char const* const ktable = \ + (char const*) (ntsc)->table [0] + burst * (nes_ntsc_burst_size * sizeof (nes_ntsc_rgb_t));\ + NES_NTSC_BEGIN_ROW_6_( pixel0, pixel1, pixel2, NES_NTSC_ENTRY_, ktable ) + +/* Begins input pixel */ +#define NES_NTSC_COLOR_IN( in_index, color_in ) \ + NES_NTSC_COLOR_IN_( in_index, color_in, NES_NTSC_ENTRY_, ktable ) + +/* Generates output pixel. Bits can be 24, 16, 15, 32 (treated as 24), or 0: +24: RRRRRRRR GGGGGGGG BBBBBBBB (8-8-8 RGB) +16: RRRRRGGG GGGBBBBB (5-6-5 RGB) +15: RRRRRGG GGGBBBBB (5-5-5 RGB) + 0: xxxRRRRR RRRxxGGG GGGGGxxB BBBBBBBx (native internal format; x = junk bits) */ +#define NES_NTSC_RGB_OUT( index, rgb_out, bits ) \ + NES_NTSC_RGB_OUT_14_( index, rgb_out, bits, 0 ) + + +/* private */ +enum { nes_ntsc_entry_size = 128 }; +typedef unsigned long nes_ntsc_rgb_t; +struct nes_ntsc_t { + nes_ntsc_rgb_t table [nes_ntsc_palette_size] [nes_ntsc_entry_size]; +}; +enum { nes_ntsc_burst_size = nes_ntsc_entry_size / nes_ntsc_burst_count }; + +#define NES_NTSC_ENTRY_( ktable, n ) \ + (nes_ntsc_rgb_t const*) (ktable + (n) * (nes_ntsc_entry_size * sizeof (nes_ntsc_rgb_t))) + +/* deprecated */ +/*#define NES_NTSC_RGB24_OUT( x, out ) NES_NTSC_RGB_OUT( x, out, 24 ) +#define NES_NTSC_RGB16_OUT( x, out ) NES_NTSC_RGB_OUT( x, out, 16 ) +#define NES_NTSC_RGB15_OUT( x, out ) NES_NTSC_RGB_OUT( x, out, 15 ) +#define NES_NTSC_RAW_OUT( x, out ) NES_NTSC_RGB_OUT( x, out, 0 ) + +enum { nes_ntsc_min_in_width = 256 }; +enum { nes_ntsc_min_out_width = NES_NTSC_OUT_WIDTH( nes_ntsc_min_in_width ) }; + +enum { nes_ntsc_640_in_width = 271 }; +enum { nes_ntsc_640_out_width = NES_NTSC_OUT_WIDTH( nes_ntsc_640_in_width ) }; +enum { nes_ntsc_640_overscan_left = 8 }; +enum { nes_ntsc_640_overscan_right = nes_ntsc_640_in_width - 256 - nes_ntsc_640_overscan_left }; + +enum { nes_ntsc_full_in_width = 283 }; +enum { nes_ntsc_full_out_width = NES_NTSC_OUT_WIDTH( nes_ntsc_full_in_width ) }; +enum { nes_ntsc_full_overscan_left = 16 }; +enum { nes_ntsc_full_overscan_right = nes_ntsc_full_in_width - 256 - nes_ntsc_full_overscan_left };*/ + +/* common 3->7 ntsc macros */ +#define NES_NTSC_BEGIN_ROW_6_( pixel0, pixel1, pixel2, ENTRY, table ) \ + unsigned const nes_ntsc_pixel0_ = (pixel0);\ + nes_ntsc_rgb_t const* kernel0 = ENTRY( table, nes_ntsc_pixel0_ );\ + unsigned const nes_ntsc_pixel1_ = (pixel1);\ + nes_ntsc_rgb_t const* kernel1 = ENTRY( table, nes_ntsc_pixel1_ );\ + unsigned const nes_ntsc_pixel2_ = (pixel2);\ + nes_ntsc_rgb_t const* kernel2 = ENTRY( table, nes_ntsc_pixel2_ );\ + nes_ntsc_rgb_t const* kernelx0;\ + nes_ntsc_rgb_t const* kernelx1 = kernel0;\ + nes_ntsc_rgb_t const* kernelx2 = kernel0 + +#define NES_NTSC_RGB_OUT_14_( x, rgb_out, bits, shift ) {\ + nes_ntsc_rgb_t raw_ =\ + kernel0 [x ] + kernel1 [(x+12)%7+14] + kernel2 [(x+10)%7+28] +\ + kernelx0 [(x+7)%14] + kernelx1 [(x+ 5)%7+21] + kernelx2 [(x+ 3)%7+35];\ + NES_NTSC_CLAMP_( raw_, shift );\ + NES_NTSC_RGB_OUT_( rgb_out, bits, shift );\ +} + +/* common ntsc macros */ +#define nes_ntsc_rgb_builder ((1L << 21) | (1 << 11) | (1 << 1)) +#define nes_ntsc_clamp_mask (nes_ntsc_rgb_builder * 3 / 2) +#define nes_ntsc_clamp_add (nes_ntsc_rgb_builder * 0x101) +#define NES_NTSC_CLAMP_( io, shift ) {\ + nes_ntsc_rgb_t sub = (io) >> (9-(shift)) & nes_ntsc_clamp_mask;\ + nes_ntsc_rgb_t clamp = nes_ntsc_clamp_add - sub;\ + io |= clamp;\ + clamp -= sub;\ + io &= clamp;\ +} + +#define NES_NTSC_COLOR_IN_( index, color, ENTRY, table ) {\ + unsigned color_;\ + kernelx##index = kernel##index;\ + kernel##index = (color_ = (color), ENTRY( table, color_ ));\ +} + +/* x is always zero except in snes_ntsc library */ +#define NES_NTSC_RGB_OUT_( rgb_out, bits, x ) {\ + if ( bits == 16 )\ + rgb_out = (raw_>>(13-x)& 0xF800)|(raw_>>(8-x)&0x07E0)|(raw_>>(4-x)&0x001F);\ + if ( bits == 24 || bits == 32 )\ + rgb_out = (raw_>>(5-x)&0xFF0000)|(raw_>>(3-x)&0xFF00)|(raw_>>(1-x)&0xFF);\ + if ( bits == 15 )\ + rgb_out = (raw_>>(14-x)& 0x7C00)|(raw_>>(9-x)&0x03E0)|(raw_>>(4-x)&0x001F);\ + if ( bits == 0 )\ + rgb_out = raw_ << x;\ +} + +#ifdef __cplusplus + } +#endif + +#endif diff --git a/src/ntsc/nes_ntsc.txt b/src/ntsc/nes_ntsc.txt new file mode 100644 index 0000000..f075e50 --- /dev/null +++ b/src/ntsc/nes_ntsc.txt @@ -0,0 +1,218 @@ +nes_ntsc 0.2.2: NES NTSC Video Filter +------------------------------------- +Author : Shay Green +Website : http://www.slack.net/~ant/ +Forum : http://groups.google.com/group/blargg-sound-libs +License : GNU Lesser General Public License (LGPL) +Language: C or C++ + + +Overview +-------- +To perform NTSC filtering, first allocate memory for a nes_ntsc_t object +and call nes_ntsc_init(), then call nes_ntsc_blit() to perform +filtering. You can call nes_ntsc_init() at any time to change image +parameters. + +nes_ntsc_blit() reads NES pixels and writes RGB pixels (16-bit by +default). The NES pixels are 6-bit raw palette values (0 to 0x3F). Edit +nes_ntsc_config.h to change this. + + +Color Emphasis Support +---------------------- +Support for the three color emphasis bits in PPU register $2001 can be +enabled in nes_ntsc_config.h. By default, support is disabled and a +64-color palette is used. If enabled, a 512-color palette is used and +the three color emphasis bits from PPU $2001 are stored in bits 6-8 (bit +mask 0x1C0) of the input pixels to the blitter. Form the index as +follows: + + index = (ppu_2001 << 1 & 0x1C0) | (palette_index & 0x3F). + + +RGB Palettes +------------ +An RGB palette can be generated for use in a normal blitter. If color +emphasis is disabled, it's 64 colors (192 bytes); if enabled, it's 512 +colors (1536 bytes). In your nes_ntsc_setup_t structure, point +palette_out to a buffer to hold the palette, then call nes_ntsc_init(). +If you only need the palette and aren't going to be using the NTSC +filter, pass 0 for the first parameter. + +A custom source RGB palette can also be used to replace the standard NES +color generation hardware. See the palette and base_palette members of +nes_ntsc_setup_t in nes_ntsc.h for more. + + +Image Parameters +---------------- +Many image parameters can be adjusted and presets are provided for +composite video, S-video, RGB, and monochrome. Most are floating-point +values with a general range of -1.0 to 1.0, where 0 is normal. The +ranges are adjusted so that one parameter at an extreme (-1 or +1) and +the rest at zero shouldn't result in any internal overflow (garbage +pixels). Setting multiple parameters to their extreme can produce +garbage. Put another way, the state space defined by all parameters +within the range -1 to +1 is not fully usable, but some extreme corners +are very useful so I don't want to reduce the parameter ranges. + +The sharpness and resolution parameters have similar effects. Resolution +affects how crisp pixels are. Sharpness merely enhances the edges by +increasing contrast, which makes things brighter at the edges. Artifacts +sets how much "junk" is around the edges where colors and brightness +change in the image, where -1 completely eliminates them. (Color) bleed +affects how much colors blend together and the artifact colors at the +edges of pixels surrounded by black. (Color) fringing affects how much +color fringing occurs around the edges of bright objects, especially +white text on a black background. + +When using custom settings, initialize your nes_ntsc_setup_t using one +of the standard setups before customizing it. This will ensure that all +fields are properly initialized, including any added in future releases +of the library that your current code can't even know about. + + nes_ntsc_setup_t setup; + setup = nes_ntsc_composite; /* do this first */ + setup.sharpness = custom_sharpness; + nes_ntsc_init( ntsc, &setup ); + + +Image Size +---------- +For proper aspect ratio, the image generated by the library must be +doubled vertically. + +Use the NES_NTSC_OUT_WIDTH() and NES_NTSC_IN_WIDTH() macros to convert +between input and output widths that the blitter uses. For example, if +you are blitting an image 256 pixels wide, use NES_NTSC_OUT_WIDTH( 256 ) +to find out how many output pixels are written per row. Another example, +use NES_NTSC_IN_WIDTH( 640 ) to find how many input pixels will fit +within 640 output pixels. The blitter rounds the input width down in +some cases, so the requested width might not be possible. Use +NES_NTSC_IN_WIDTH( NES_NTSC_OUT_WIDTH( in_width ) ) to find what a given +in_width would be rounded down to. + + +Burst Phase +----------- +The burst_phase parameter to nes_ntsc_blit() should generally toggle +values between frames, i.e. 0 on first call to nes_ntsc_blit(), 1 on +second call, 0 on third call, 1 on fourth, etc. If merge_fields is +enabled (see below), you should always pass 0. Read further for more +detailed operation. + +If you're using nes_ntsc_blit() to do partial screen updates, +burst_phase should be calculated as (burst_phase + row) % 3, where row +is the starting row (0 through 239). For example, if burst_phase is 1 +for the current frame and you make two calls to nes_ntsc_blit() to blit +rows 0 to 100, then rows 101 to 239, for the first call you should pass +1 for burst_phase, and for the second call you should pass 0 for +burst_phase: (1 + 101) % 3 = 0. Do the same regardless of the +merge_fields setting. + +For more accurate burst_phase operation, it should be adjusted at the +beginning of a frame based on the length of scanline 20: if 341 clocks +(normal), burst_phase = (burst_phase + 1) % 3, otherwise burst_phase = +(burst_phase + 2) % 3 (for shorter 340 clock scanline). + +The included test ROMs verify proper burst_phase implementation. They +must pass in order; an earlier failing test means that later tests will +give meaningless results. The first two tests will pass with either +method of burst_phase handling described above; the third will only pass +with the more accurate handling. The tests flash sets of dots quickly +with the dot color being the only important aspect. + +1.line_phase.nes - Tests for proper burst_phase on each scanline. All +dots on screen should be the same color. + +2.frame_phase.nes - Tests for proper burst_phase toggling between +frames. Each row of dots should alternate between the same two colors +(if merge_fields is set to 1, they should all be the same color). + +3.special_frame_phase.nes - Tests for proper burst_phase incrementing +between frames when $2001 rendering is enabled late in the frame. Each +rectangle of dots should be one color, and there should be three +different colors of rectangles (if merge_fields is set to 1, each +rectangle should be made of three colors of dots). There is a visual +glitch near the top of the screen for the first line of dots; this is +unrelated the test and should be ignored. + + +Flickering +---------- +The displayed image toggles between two different pixel artifact +patterns at a steady rate, making it appear stable. For an emulator to +duplicate this effect, its frame rate must match the host monitor's +refresh rate, it must be synchronizing to the refresh (vsync), and it +must not be skipping any frames. If any of these don't hold, the image +will probably flicker much more than it would on a TV. It is important +that you play around with these factors to get a good feel for the +issue, and document it clearly for end-users, otherwise they will have +difficulty getting an authentic image. + +The library includes a partial workaround for this issue, for the cases +where all the conditions can't be met. When merge_fields is set to 1, +nes_ntsc_blit() does the equivalent of blitting the image twice with the +two different phases and then mixes them together, but without any +performance impact. The result is similar to what you'd see if the +monitor's refresh rate were the same as the emulator's. It does reduce +the shimmer effect when scrolling, so it's not a complete solution to +the refresh rate issue. + +The merge_fields option is also useful when taking a screenshot. If you +capture without merge_fields set to 1, you'll only get the even or odd +artifacts, which will make the image look more grainy than when the +emulator is running. Again, play around with this to get an idea of the +difference. It might be best to simply allow the user to choose when to +enable this option. + +Note that when you have merge_fields set to 1, you should always pass 0 +for the burst_phase parameter to nes_ntsc_blit() (unless doing partial +screen updates). If you don't, you'll still get some flicker. + + +Custom Blitter +-------------- +You can write your own blitter, allowing customization of how input +pixels are obtained, the format of output pixels (15, 16, or 32-bit +RGB), optimizations for your platform, and additional effects like +efficient scanline doubling during blitting. + +Macros are included in nes_ntsc.h for writing your blitter so that your +code can be carried over without changes to improved versions of the +library. The default blitter at the end of nes_ntsc.c shows how to use +the macros. Contact me for further assistance. + +The NES_NTSC_BEGIN_ROW macro allows starting up to three pixels. The +first pixel is cut off; its use is in specifying a background color +other than black for the sliver on the left edge. The next two pixels +can be used to handle the extra one or two pixels not handled by the +main chunks of three pixels. For example if you want to blit 257 input +pixels on a row (for whatever odd reason), you would start the first two +with NES_NTSC_BEGIN_ROW( ... nes_ntsc_black, line_in [0], line_in [1] ), +then do the remaining 255 in chunks of three (255 is divisible by 3). + + +Limitations +----------- +The library's horizontal rescaling is too wide by about 3% in order to +allow a much more optimal implementation. This means that a 256 pixel +wide input image should appear as 581 output pixels, but with this +library appears as 602 output pixels. TV aspect ratios probably vary by +this much anyway. If you really need unscaled output, contact me and +I'll see about adding it. + + +Thanks +------ +Thanks to NewRisingSun for his original code and explanations of NTSC, +which was a starting point for me learning about NTSC video and +decoding. Thanks to the Nesdev forum for feedback and encouragement. +Thanks to Martin Freij (Nestopia author) and Charles MacDonald (SMS Plus +author) for significant ongoing testing and feedback as the library has +improved. Thanks to byuu (bsnes author) and pagefault (ZSNES team) for +feedback about the SNES version. + +-- +Shay Green diff --git a/src/ntsc/nes_ntsc_config.h b/src/ntsc/nes_ntsc_config.h new file mode 100644 index 0000000..ed5942b --- /dev/null +++ b/src/ntsc/nes_ntsc_config.h @@ -0,0 +1,27 @@ +/* Configure library by modifying this file */ + +#ifndef NES_NTSC_CONFIG_H +#define NES_NTSC_CONFIG_H + +/* Uncomment to enable emphasis support and use a 512 color palette instead +of the base 64 color palette. */ +#define NES_NTSC_EMPHASIS 1 + +/* The following affect the built-in blitter only; a custom blitter can +handle things however it wants. */ + +/* Bits per pixel of output. Can be 15, 16, 32, or 24 (same as 32). */ +#define NES_NTSC_OUT_DEPTH 16 + +/* Type of input pixel values. You'll probably use unsigned short +if you enable emphasis above. */ +#define NES_NTSC_IN_T unsigned char + +/* Each raw pixel input value is passed through this. You might want to mask +the pixel index if you use the high bits as flags, etc. */ +#define NES_NTSC_ADJ_IN( in ) (in & 0x3F) + +/* For each pixel, this is the basic operation: +output_color = color_palette [NES_NTSC_ADJ_IN( NES_NTSC_IN_T )] */ + +#endif diff --git a/src/ntsc/nes_ntsc_impl.h b/src/ntsc/nes_ntsc_impl.h new file mode 100644 index 0000000..de3672b --- /dev/null +++ b/src/ntsc/nes_ntsc_impl.h @@ -0,0 +1,439 @@ +/* nes_ntsc 0.2.2. http://www.slack.net/~ant/ */ + +/* Common implementation of NTSC filters */ + +#include +#include + +/* Copyright (C) 2006 Shay Green. This module is free software; you +can redistribute it and/or modify it under the terms of the GNU Lesser +General Public License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. This +module is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more +details. You should have received a copy of the GNU Lesser General Public +License along with this module; if not, write to the Free Software Foundation, +Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ + +#define DISABLE_CORRECTION 0 + +#undef PI +#define PI 3.14159265358979323846f + +#ifndef LUMA_CUTOFF + #define LUMA_CUTOFF 0.20 +#endif +#ifndef gamma_size + #define gamma_size 1 +#endif +#ifndef rgb_bits + #define rgb_bits 8 +#endif +#ifndef artifacts_max + #define artifacts_max (artifacts_mid * 1.5f) +#endif +#ifndef fringing_max + #define fringing_max (fringing_mid * 2) +#endif +#ifndef STD_HUE_CONDITION + #define STD_HUE_CONDITION( setup ) 1 +#endif + +#define ext_decoder_hue (std_decoder_hue + 15) +#define rgb_unit (1 << rgb_bits) +#define rgb_offset (rgb_unit * 2 + 0.5f) + +enum { burst_size = nes_ntsc_entry_size / burst_count }; +enum { kernel_half = 16 }; +enum { kernel_size = kernel_half * 2 + 1 }; + +typedef struct init_t +{ + float to_rgb [burst_count * 6]; + float to_float [gamma_size]; + float contrast; + float brightness; + float artifacts; + float fringing; + float kernel [rescale_out * kernel_size * 2]; +} init_t; + +#define ROTATE_IQ( i, q, sin_b, cos_b ) {\ + float t;\ + t = i * cos_b - q * sin_b;\ + q = i * sin_b + q * cos_b;\ + i = t;\ +} + +static void init_filters( init_t* impl, nes_ntsc_setup_t const* setup ) +{ +#if rescale_out > 1 + float kernels [kernel_size * 2]; +#else + float* const kernels = impl->kernel; +#endif + + /* generate luma (y) filter using sinc kernel */ + { + /* sinc with rolloff (dsf) */ + float const rolloff = 1 + (float) setup->sharpness * (float) 0.032; + float const maxh = 32; + float const pow_a_n = (float) pow( rolloff, maxh ); + float sum; + int i; + /* quadratic mapping to reduce negative (blurring) range */ + float to_angle = (float) setup->resolution + 1; + to_angle = PI / maxh * (float) LUMA_CUTOFF * (to_angle * to_angle + 1); + + kernels [kernel_size * 3 / 2] = maxh; /* default center value */ + for ( i = 0; i < kernel_half * 2 + 1; i++ ) + { + int x = i - kernel_half; + float angle = x * to_angle; + /* instability occurs at center point with rolloff very close to 1.0 */ + if ( x || pow_a_n > (float) 1.056 || pow_a_n < (float) 0.981 ) + { + float rolloff_cos_a = rolloff * (float) cos( angle ); + float num = 1 - rolloff_cos_a - + pow_a_n * (float) cos( maxh * angle ) + + pow_a_n * rolloff * (float) cos( (maxh - 1) * angle ); + float den = 1 - rolloff_cos_a - rolloff_cos_a + rolloff * rolloff; + float dsf = num / den; + kernels [kernel_size * 3 / 2 - kernel_half + i] = dsf - (float) 0.5; + } + } + + /* apply blackman window and find sum */ + sum = 0; + for ( i = 0; i < kernel_half * 2 + 1; i++ ) + { + float x = PI * 2 / (kernel_half * 2) * i; + float blackman = 0.42f - 0.5f * (float) cos( x ) + 0.08f * (float) cos( x * 2 ); + sum += (kernels [kernel_size * 3 / 2 - kernel_half + i] *= blackman); + } + + /* normalize kernel */ + sum = 1.0f / sum; + for ( i = 0; i < kernel_half * 2 + 1; i++ ) + { + int x = kernel_size * 3 / 2 - kernel_half + i; + kernels [x] *= sum; + assert( kernels [x] == kernels [x] ); /* catch numerical instability */ + } + } + + /* generate chroma (iq) filter using gaussian kernel */ + { + float const cutoff_factor = -0.03125f; + float cutoff = (float) setup->bleed; + int i; + + if ( cutoff < 0 ) + { + /* keep extreme value accessible only near upper end of scale (1.0) */ + cutoff *= cutoff; + cutoff *= cutoff; + cutoff *= cutoff; + cutoff *= -30.0f / 0.65f; + } + cutoff = cutoff_factor - 0.65f * cutoff_factor * cutoff; + + for ( i = -kernel_half; i <= kernel_half; i++ ) + kernels [kernel_size / 2 + i] = (float) exp( i * i * cutoff ); + + /* normalize even and odd phases separately */ + for ( i = 0; i < 2; i++ ) + { + float sum = 0; + int x; + for ( x = i; x < kernel_size; x += 2 ) + sum += kernels [x]; + + sum = 1.0f / sum; + for ( x = i; x < kernel_size; x += 2 ) + { + kernels [x] *= sum; + assert( kernels [x] == kernels [x] ); /* catch numerical instability */ + } + } + } + + /* + printf( "luma:\n" ); + for ( i = kernel_size; i < kernel_size * 2; i++ ) + printf( "%f\n", kernels [i] ); + printf( "chroma:\n" ); + for ( i = 0; i < kernel_size; i++ ) + printf( "%f\n", kernels [i] ); + */ + + /* generate linear rescale kernels */ + #if rescale_out > 1 + { + float weight = 1.0f; + float* out = impl->kernel; + int n = rescale_out; + do + { + float remain = 0; + int i; + weight -= 1.0f / rescale_in; + for ( i = 0; i < kernel_size * 2; i++ ) + { + float cur = kernels [i]; + float m = cur * weight; + *out++ = m + remain; + remain = cur - m; + } + } + while ( --n ); + } + #endif +} + +static float const default_decoder [6] = + { 0.956f, 0.621f, -0.272f, -0.647f, -1.105f, 1.702f }; + +static void init( init_t* impl, nes_ntsc_setup_t const* setup ) +{ + impl->brightness = (float) setup->brightness * (0.5f * rgb_unit) + rgb_offset; + impl->contrast = (float) setup->contrast * (0.5f * rgb_unit) + rgb_unit; + #ifdef default_palette_contrast + if ( !setup->palette ) + impl->contrast *= default_palette_contrast; + #endif + + impl->artifacts = (float) setup->artifacts; + if ( impl->artifacts > 0 ) + impl->artifacts *= artifacts_max - artifacts_mid; + impl->artifacts = impl->artifacts * artifacts_mid + artifacts_mid; + + impl->fringing = (float) setup->fringing; + if ( impl->fringing > 0 ) + impl->fringing *= fringing_max - fringing_mid; + impl->fringing = impl->fringing * fringing_mid + fringing_mid; + + init_filters( impl, setup ); + + /* generate gamma table */ + if ( gamma_size > 1 ) + { + float const to_float = 1.0f / (gamma_size - (gamma_size > 1)); + float const gamma = 1.1333f - (float) setup->gamma * 0.5f; + /* match common PC's 2.2 gamma to TV's 2.65 gamma */ + int i; + for ( i = 0; i < gamma_size; i++ ) + impl->to_float [i] = + (float) pow( i * to_float, gamma ) * impl->contrast + impl->brightness; + } + + /* setup decoder matricies */ + { + float hue = (float) setup->hue * PI + PI / 180 * ext_decoder_hue; + float sat = (float) setup->saturation + 1; + float const* decoder = setup->decoder_matrix; + if ( !decoder ) + { + decoder = default_decoder; + if ( STD_HUE_CONDITION( setup ) ) + hue += PI / 180 * (std_decoder_hue - ext_decoder_hue); + } + + { + float s = (float) sin( hue ) * sat; + float c = (float) cos( hue ) * sat; + float* out = impl->to_rgb; + int n; + + n = burst_count; + do + { + float const* in = decoder; + int n = 3; + do + { + float i = *in++; + float q = *in++; + *out++ = i * c - q * s; + *out++ = i * s + q * c; + } + while ( --n ); + if ( burst_count <= 1 ) + break; + ROTATE_IQ( s, c, 0.866025f, -0.5f ); /* +120 degrees */ + } + while ( --n ); + } + } +} + +/* kernel generation */ + +#define RGB_TO_YIQ( r, g, b, y, i ) (\ + (y = (r) * 0.299f + (g) * 0.587f + (b) * 0.114f),\ + (i = (r) * 0.596f - (g) * 0.275f - (b) * 0.321f),\ + ((r) * 0.212f - (g) * 0.523f + (b) * 0.311f)\ +) + +#define YIQ_TO_RGB( y, i, q, to_rgb, type, r, g ) (\ + r = (type) (y + to_rgb [0] * i + to_rgb [1] * q),\ + g = (type) (y + to_rgb [2] * i + to_rgb [3] * q),\ + (type) (y + to_rgb [4] * i + to_rgb [5] * q)\ +) + +#define PACK_RGB( r, g, b ) ((r) << 21 | (g) << 11 | (b) << 1) + +enum { rgb_kernel_size = burst_size / alignment_count }; +enum { rgb_bias = rgb_unit * 2 * nes_ntsc_rgb_builder }; + +typedef struct pixel_info_t +{ + int offset; + float negate; + float kernel [4]; +} pixel_info_t; + +#if rescale_in > 1 + #define PIXEL_OFFSET_( ntsc, scaled ) \ + (kernel_size / 2 + ntsc + (scaled != 0) + (rescale_out - scaled) % rescale_out + \ + (kernel_size * 2 * scaled)) + + #define PIXEL_OFFSET( ntsc, scaled ) \ + PIXEL_OFFSET_( ((ntsc) - (scaled) / rescale_out * rescale_in),\ + (((scaled) + rescale_out * 10) % rescale_out) ),\ + (1.0f - (((ntsc) + 100) & 2)) +#else + #define PIXEL_OFFSET( ntsc, scaled ) \ + (kernel_size / 2 + (ntsc) - (scaled)),\ + (1.0f - (((ntsc) + 100) & 2)) +#endif + +extern pixel_info_t const nes_ntsc_pixels [alignment_count]; + +/* Generate pixel at all burst phases and column alignments */ +static void gen_kernel( init_t* impl, float y, float i, float q, nes_ntsc_rgb_t* out ) +{ + /* generate for each scanline burst phase */ + float const* to_rgb = impl->to_rgb; + int burst_remain = burst_count; + y -= rgb_offset; + do + { + /* Encode yiq into *two* composite signals (to allow control over artifacting). + Convolve these with kernels which: filter respective components, apply + sharpening, and rescale horizontally. Convert resulting yiq to rgb and pack + into integer. Based on algorithm by NewRisingSun. */ + pixel_info_t const* pixel = nes_ntsc_pixels; + int alignment_remain = alignment_count; + do + { + /* negate is -1 when composite starts at odd multiple of 2 */ + float const yy = y * impl->fringing * pixel->negate; + float const ic0 = (i + yy) * pixel->kernel [0]; + float const qc1 = (q + yy) * pixel->kernel [1]; + float const ic2 = (i - yy) * pixel->kernel [2]; + float const qc3 = (q - yy) * pixel->kernel [3]; + + float const factor = impl->artifacts * pixel->negate; + float const ii = i * factor; + float const yc0 = (y + ii) * pixel->kernel [0]; + float const yc2 = (y - ii) * pixel->kernel [2]; + + float const qq = q * factor; + float const yc1 = (y + qq) * pixel->kernel [1]; + float const yc3 = (y - qq) * pixel->kernel [3]; + + float const* k = &impl->kernel [pixel->offset]; + int n; + ++pixel; + for ( n = rgb_kernel_size; n; --n ) + { + float i = k[0]*ic0 + k[2]*ic2; + float q = k[1]*qc1 + k[3]*qc3; + float y = k[kernel_size+0]*yc0 + k[kernel_size+1]*yc1 + + k[kernel_size+2]*yc2 + k[kernel_size+3]*yc3 + rgb_offset; + if ( rescale_out <= 1 ) + k--; + else if ( k < &impl->kernel [kernel_size * 2 * (rescale_out - 1)] ) + k += kernel_size * 2 - 1; + else + k -= kernel_size * 2 * (rescale_out - 1) + 2; + { + int r, g, b = YIQ_TO_RGB( y, i, q, to_rgb, int, r, g ); + *out++ = PACK_RGB( r, g, b ) - rgb_bias; + } + } + } + while ( alignment_count > 1 && --alignment_remain ); + + if ( burst_count <= 1 ) + break; + + to_rgb += 6; + + ROTATE_IQ( i, q, -0.866025f, -0.5f ); /* -120 degrees */ + } + while ( --burst_remain ); +} + +static void correct_errors( nes_ntsc_rgb_t color, nes_ntsc_rgb_t* out ); + +#if DISABLE_CORRECTION + #define CORRECT_ERROR( a ) { out [i] += rgb_bias; } + #define DISTRIBUTE_ERROR( a, b, c ) { out [i] += rgb_bias; } +#else + #define CORRECT_ERROR( a ) { out [a] += error; } + #define DISTRIBUTE_ERROR( a, b, c ) {\ + nes_ntsc_rgb_t fourth = (error + 2 * nes_ntsc_rgb_builder) >> 2;\ + fourth &= (rgb_bias >> 1) - nes_ntsc_rgb_builder;\ + fourth -= rgb_bias >> 2;\ + out [a] += fourth;\ + out [b] += fourth;\ + out [c] += fourth;\ + out [i] += error - (fourth * 3);\ + } +#endif + +#define RGB_PALETTE_OUT( rgb, out_ )\ +{\ + unsigned char* out = (out_);\ + nes_ntsc_rgb_t clamped = (rgb);\ + NES_NTSC_CLAMP_( clamped, (8 - rgb_bits) );\ + out [0] = (unsigned char) (clamped >> 21);\ + out [1] = (unsigned char) (clamped >> 11);\ + out [2] = (unsigned char) (clamped >> 1);\ +} + +/* blitter related */ + +#ifndef restrict + #if defined (__GNUC__) + #define restrict __restrict__ + #elif defined (_MSC_VER) && _MSC_VER > 1300 + #define restrict __restrict + #else + /* no support for restricted pointers */ + #define restrict + #endif +#endif + +#include + +#if NES_NTSC_OUT_DEPTH <= 16 + #if USHRT_MAX == 0xFFFF + typedef unsigned short nes_ntsc_out_t; + #else + #error "Need 16-bit int type" + #endif + +#else + #if UINT_MAX == 0xFFFFFFFF + typedef unsigned int nes_ntsc_out_t; + #elif ULONG_MAX == 0xFFFFFFFF + typedef unsigned long nes_ntsc_out_t; + #else + #error "Need 32-bit int type" + #endif + +#endif diff --git a/src/ntsc/readme.txt b/src/ntsc/readme.txt new file mode 100644 index 0000000..219622f --- /dev/null +++ b/src/ntsc/readme.txt @@ -0,0 +1,61 @@ +nes_ntsc 0.2.2: NES NTSC Video Filter +------------------------------------- +This library filters a NES image to match what a TV would show, allowing +an authentic image in an emulator. It uses a highly optimized algorithm +to perform the same signal processing as an NTSC decoder in a TV, giving +very similar pixel artifacts and color bleeding. The usual picture +controls can be adjusted: hue, saturation, contrast, brightness, and +sharpness. Additionally, the amount of NTSC chroma and luma artifacts +can be reduced, allowing an image that corresponds to composite video +(artifacts), S-video (color bleeding only), RGB (clean pixels), or +anywhere inbetween. + +The output is scaled to the proper horizontal width, leaving it up the +emulator to simply double the height. An optional even/odd field merging +feature is provided to reduce flicker when the host display's refresh +rate isn't 60 Hz. Specialized blitters can be easily written using a +special interface, allowing customization of input and output pixel +formats, optimization for the host platform, and efficient scanline +doubling. + +Blitting a 256x240 source image to a 602x240 pixel 16-bit RGB memory +buffer at 60 frames per second uses 8% CPU on a 2.0 GHz Athlon 3500+ and +40% CPU on a 10-year-old 400 MHz G3 PowerMac. + +Author : Shay Green +Website : http://www.slack.net/~ant/ +Forum : http://groups.google.com/group/blargg-sound-libs +License : GNU Lesser General Public License (LGPL) +Language: C or C++ + + +Getting Started +--------------- +Build a program from demo.c, nes_ntsc.c, and the SDL multimedia library +(see http://libsdl.org/). Run it with "test.bmp" in the same directory +and it should show the filtered image. See demo.c for more. + +See nes_ntsc.txt for documentation and nes_ntsc.h for reference. Post to +the discussion forum for assistance. + + +Files +----- +readme.txt Essential information +nes_ntsc.txt Library documentation +changes.txt Changes made since previous releases +license.txt GNU Lesser General Public License + +benchmark.c Measures frame rate and processor usage of library +demo.c Displays and saves NTSC filtered image +demo_impl.h Internal routines used by demo +test.bmp Test image for demo +tests/ Test ROMs to verify burst phase operation + +nes_ntsc_config.h Library configuration (modify as needed) +nes_ntsc.h Library header and source +nes_ntsc.c +nes_ntsc_impl.h + +-- +Shay Green