/* * video-color.c - Video implementation of YUV, YIQ, YCbCr and RGB colors * * Written by * John Selck * Groepaz * * This file is part of VICE, the Versatile Commodore Emulator. * See README for copyright notice. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA * 02111-1307 USA. * */ /* #define DEBUG_VIDEO */ /* use all neutral settings in the color calculations */ /* #define DEBUG_NEUTRAL_SETTINGS */ #ifdef DEBUG_VIDEO #define DBG(_x_) log_printf _x_ #else #define DBG(_x_) #endif #include "vice.h" #include #include #include /* needed for pow function */ #include "videoarch.h" #include "lib.h" #include "log.h" #include "machine.h" #include "palette.h" #include "resources.h" #include "viewport.h" #include "video-canvas.h" #include "video-color.h" #include "video.h" #define RMIN(x,min) (((x) < (min)) ? (min) : (x)) #define RMAX(x,max) (((x) > (max)) ? (max) : (x)) #define RMINMAX(x,min,max) RMIN(RMAX(x,max),min) #define MATH_PI 3.141592653589793238462643383279 typedef struct video_ycbcr_color_s { float y; float cb; float cr; } video_ycbcr_color_t; typedef struct video_ycbcr_palette_s { unsigned int num_entries; video_ycbcr_color_t *entries; } video_ycbcr_palette_t; void video_render_setrawrgb(video_render_color_tables_t *color_tab, unsigned int index, uint32_t r, uint32_t g, uint32_t b) { color_tab->color_red[index] = r; color_tab->color_grn[index] = g; color_tab->color_blu[index] = b; } void video_render_setrawalpha(video_render_color_tables_t *color_tab, uint32_t a) { color_tab->alpha = a; } static video_ycbcr_palette_t *video_ycbcr_palette_create(unsigned int num_entries) { video_ycbcr_palette_t *p; p = lib_malloc(sizeof(video_ycbcr_palette_t)); p->num_entries = num_entries; p->entries = lib_calloc(num_entries, sizeof(video_ycbcr_color_t)); return p; } static void video_ycbcr_palette_free(video_ycbcr_palette_t *p) { if (p == NULL) { return; } lib_free(p->entries); lib_free(p); } /******************************************************************************* * color space conversion functions ******************************************************************************/ /* formulas for color space conversion: RGB to YCbCr: y = 0.299 * R + 0.587 * G + 0.114 * B Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B Y = 0.2989 * R + 0.5866 * G + 0.1145 * B Cb = B - Y Cr = R - Y RGB to YUV Y = 0,299 * R + 0,587 * G + 0,114 * B U = -0,147 * R - 0,289 * G + 0,436 * B (B-Y;Cr) V = 0,615 * R - 0,515 * G - 0,100 * B (R-Y;Cb) U = 0.493 * (B - Y) V = 0.877 * (R - Y) RGB to YIQ Y = 0,299 * R + 0,587 * G + 0,114 * B I = 0,596 * R - 0,274 * G + 0,322 * B Q = 0,212 * R - 0,523 * G - 0,311 * B I = -0.27 * (B - Y) + 0.74 * (R - Y) Q = 0.41 * (B - Y) + 0.48 * (R - Y) YCbCr to RGB: R = Y + Cr G = Y - (0.1145/0.5866) * Cb - (0.2989/0.5866) * Cr G = Y - 0.195192 * Cb - 0.509546 * Cr B = Y + Cb YCbCr to YUV: U = 0.493111 * Cb V = 0.877283 * Cr YCbCr to YIQ: I = -0.27 * Cb + 0.74 * Cr Q = 0.41 * Cb + 0.48 * Cr YUV to RGB R = Y + V G = Y - (0.1953 * U + 0.5078 * V) B = Y + U YUV to YCbCr Cb = U / 0.493111 Cr = V / 0.877283 YIQ to YUV U = -0.546512701 * I + 0.842540416 * Q V = 0.830415704 * I + 0.546859122 * Q YIQ to YCbCr Cb = (-0.546512701 * I + 0.842540416 * Q) / 0.493111 Cr = ( 0.830415704 * I + 0.546859122 * Q) / 0.877283 YIQ->RGB (Sony CXA2025AS US decoder matrix) R = Y + 1,630 * I + 0,317 * Q G = Y - 0,378 * I - 0,466 * Q B = Y - 1,089 * I + 1,677 * Q YUV is the PAL colorspace. It's just a slightly modified YCbCr for better broadcasting. YIQ is the NTSC colorspace, its very similar - basically 33 degrees rotated. the PAL renderer does a bit of cheating and uses YCbCr instead of YUV for speed reasons. the NTSC renderer uses YIQ as defined by the SONY matrix. */ #ifdef DEBUG_VIDEO static inline void video_convert_ycbcr_to_yuv(video_ycbcr_color_t *src, video_ycbcr_color_t *dst) { dst->y = src->y; dst->cb = src->cb * 0.493111f; dst->cr = src->cr * 0.877283f; } /* currently unused */ #if 0 static inline void video_convert_ycbcr_to_yiq(video_ycbcr_color_t *src, video_ycbcr_color_t *dst) { float cb = src->cb; float cr = src->cr; dst->y = src->y; dst->cb = -0.27f * cb + 0.74f * cr; dst->cr = 0.41f * cb + 0.48f * cr; } #endif #endif static inline void video_convert_yuv_to_ycbcr(video_ycbcr_color_t *src, video_ycbcr_color_t *dst) { dst->y = src->y; dst->cb = src->cb / 0.493111f; dst->cr = src->cr / 0.877283f; } /* currently unused */ #if 0 static inline void video_convert_yiq_to_ycbcr(video_ycbcr_color_t *src, video_ycbcr_color_t *dst) { float i = src->cb; float q = src->cr; dst->y = src->y; dst->cb = (-0.546512701f * i + 0.842540416f * q) / 0.493111f; dst->cr = ( 0.830415704f * i + 0.546859122f * q) / 0.877283f; } #endif /* YPbPr (ITU-R BT.601) ========================================================== R' = Y + 1.402 * Pr G' = Y - 0.344136 * Pb - 0.714136 * Pr B' = Y + 1.772 * Pb .......................................................... Y' in [0; 1] Pb in [-0.5; 0.5] Pr in [-0.5; 0.5] R', G', B' in [0; 1] */ static inline void video_convert_ycbcr_to_rgb(const video_ycbcr_color_t *src, int *r, int *g, int *b) { float rf, gf, bf; #if 0 bf = src->cb + src->y; rf = src->cr + src->y; gf = src->y - (0.1145f / 0.5866f) * src->cb - (0.2989f / 0.5866f) * src->cr; #else /* gives better reverse-conversion results than the above */ rf = src->y + 1.402f * src->cr; gf = src->y - 0.344136f * src->cb - 0.714136f * src->cr; bf = src->y + 1.772f * src->cb; #endif *r = RMINMAX(((int)(rf + 0.5f)), 0, 255); *g = RMINMAX(((int)(gf + 0.5f)), 0, 255); *b = RMINMAX(((int)(bf + 0.5f)), 0, 255); } static inline void video_convert_yiq_to_rgb(video_ycbcr_color_t *src, int *r, int *g, int *b) { float rf, gf, bf; /* SONY matrix */ rf = src->y + 1.630f * src->cb + 0.317f * src->cr; gf = src->y - 0.378f * src->cb - 0.466f * src->cr; bf = src->y - 1.089f * src->cb + 1.677f * src->cr; *r = RMINMAX(((int)(rf + 0.5f)), 0, 255); *g = RMINMAX(((int)(gf + 0.5f)), 0, 255); *b = RMINMAX(((int)(bf + 0.5f)), 0, 255); } static inline void video_convert_rgb_to_yiq(const palette_entry_t *src, video_ycbcr_color_t *dst) { /* inverse of SONY matrix */ dst->y = 0.23485876230514601561f * src->red + 0.63350073880774681230f * src->green + 0.13164049888710717208f * src->blue; dst->cb = 0.44095947679118953500f * src->red - 0.27984362502847306001f * src->green - 0.16111585176271647499f * src->blue; /* I */ dst->cr = 0.14630060102591496005f * src->red - 0.55948148268560165453f * src->green + 0.41318088165968669449f * src->blue; /* Q */ } /* YPbPr (ITU-R BT.601) ======================================================== Y' = + 0.299 * R' + 0.587 * G' + 0.114 * B' Pb = - 0.168736 * R' - 0.331264 * G' + 0.5 * B' Pr = + 0.5 * R' - 0.418688 * G' - 0.081312 * B' ........................................................ R', G', B' in [0; 1] Y' in [0; 1] Pb in [-0.5; 0.5] Pr in [-0.5; 0.5] */ static inline void video_convert_rgb_to_ycbcr(const palette_entry_t *src, video_ycbcr_color_t *dst) { /* convert RGB to YCbCr */ dst->y = 0.2989f * src->red + 0.5866f * src->green + 0.1145f * src->blue; dst->cb = -0.168736f * src->red - 0.331264f * src->green + 0.5f * src->blue; dst->cr = 0.5f * src->red - 0.418688f * src->green - 0.081312f * src->blue; } /******************************************************************************/ /* conversion of VIC/VIC-II/TED colors to YCbCr used by video_cbm_palette_to_ycbcr (internal palette/CRT emu) */ #define INT_LUMA_ADJ (1.00f) #define INT_SAT_ADJ (1.75f) static void video_convert_cbm_to_ycbcr(const video_cbm_color_t *src, float phase, video_ycbcr_color_t *dst, int video) { float basesat = src->saturation / INT_SAT_ADJ; /* DBG(("video_convert_cbm_to_ycbcr sat:%f phase:%f", basesat, phase)); */ dst->y = src->luminance; /* FIXME: this is a hack to adjust the output of the internal color generator somewhat to align with the pepto palette when all neutral parameters are used */ dst->y /= INT_LUMA_ADJ; /* chrominance (U and V) of color */ if (video) { /* PAL */ dst->cb = (float)(basesat * cos((src->angle + phase) * (MATH_PI / 180.0))); /* U */ dst->cr = (float)(basesat * sin((src->angle + phase) * (MATH_PI / 180.0))); /* V */ /* convert UV to CbCr */ video_convert_yuv_to_ycbcr(dst, dst); } else { /* NTSC */ dst->cb = (float)(basesat * sin((src->angle + phase - (100.0f / 3.0f)) * (MATH_PI / 180.0))); /* I */ dst->cr = (float)(basesat * cos((src->angle + phase - (100.0f / 3.0f)) * (MATH_PI / 180.0))); /* Q */ } /* direction of color vector (-1 = inverted vector, 0 = grey vector) */ if (src->direction == 0) { dst->cb = 0.0f; dst->cr = 0.0f; } if (src->direction < 0) { dst->cb = -dst->cb; dst->cr = -dst->cr; } } /* gamma correction */ static float video_gamma(float value, double factor, float gamma, float bri, float con) { float ret; value += bri; value *= con; if (value <= 0.0f) { return 0.0f; } ret = (float)(factor * pow(value, gamma)); if (ret < 0.0f) { ret = 0.0f; } return ret; } #ifdef DEBUG_VIDEO static void video_convert_renderer_to_rgb(video_ycbcr_color_t *src, palette_entry_t *dst, int video) { int r, g, b; /* DBG(("video_convert_renderer_to_rgb")); */ if (video) { /* PAL */ video_convert_ycbcr_to_rgb(src, &r, &g, &b); } else { /* NTSC */ video_convert_yiq_to_rgb(src, &r, &g, &b); } dst->red = (uint8_t)r; dst->green = (uint8_t)g; dst->blue = (uint8_t)b; dst->name = NULL; } #endif /* conversion of YCbCr to RGB used by video_calc_palette (internal palette) (not used by CRT emu) */ static void video_convert_renderer_to_rgb_gamma(video_ycbcr_color_t *src, float sat, float bri, float con, float gam, float tin, palette_entry_t *dst, int video) { float rf, bf, gf; double factor; int r, g, b; video_ycbcr_color_t tmp; /* DBG(("video_convert_renderer_to_rgb_gamma")); */ tmp.cb = src->cb; tmp.cr = src->cr; tmp.y = src->y; if (video) { tmp.cr += tin; /* apply tint */ /* apply saturation */ tmp.cb *= sat; tmp.cr *= sat; video_convert_ycbcr_to_rgb(&tmp, &r, &g, &b); } else { /* FIXME: tint for ntsc */ tmp.cr += tin; /* apply tint */ /* apply saturation */ tmp.cb *= sat; tmp.cr *= sat; video_convert_yiq_to_rgb(&tmp, &r, &g, &b); } /* do gamma correction */ factor = pow(255.0f, 1.0f - gam); rf = video_gamma((float)r, factor, gam, bri, con); gf = video_gamma((float)g, factor, gam, bri, con); bf = video_gamma((float)b, factor, gam, bri, con); /* convert to int and clip to 8 bit boundaries */ r = (int)(rf + 0.5f); g = (int)(gf + 0.5f); b = (int)(bf + 0.5f); dst->red = (uint8_t)RMAX(r,255); dst->green = (uint8_t)RMAX(g,255); dst->blue = (uint8_t)RMAX(b,255); dst->name = NULL; } /* conversion of RGB to YCbCr * (custom palette, RGB color modes) */ static void video_convert_rgb_to_renderer(const palette_entry_t *src, video_ycbcr_color_t *dst, int video) { /* DBG(("video_convert_rgb_to_renderer")); */ if (video) { /* PAL */ video_convert_rgb_to_ycbcr(src, dst); } else { /* NTSC */ video_convert_rgb_to_yiq(src, dst); } } /* FIXME: handle gamma for CRT emulation (CGA and Monochrom video) too */ static float video_get_gamma(video_resources_t *video_resources, int video) { /* doing the distinction for pal/ntsc here is weird, we should have * different sets of video adjust settings for each video mode instead */ #if 0 float mgam, vgam; if (video) { vgam = 2.8f; /* PAL gamma */ } else { vgam = 2.2f; /* NTSC gamma */ } mgam = ((float)(video_resources->color_gamma)) / 1000.0f; return mgam / vgam; #endif return ((float)(video_resources->color_gamma)) / 1000.0f; } /* gammatable calculation */ static void video_calc_gammatable(video_render_color_tables_t *color_tab, video_resources_t *video_resources, int video) { int i; float bri, con, gam, scn, v; double factor; uint32_t vi; DBG(("video_calc_gammatable")); #ifdef DEBUG_NEUTRAL_SETTINGS scn = 1.0; bri = 0.0; con = 1.0; gam = 1.0; #else /* default: bri:0,000000 con:1,250000 gam:0,785714 scn:0,750000 */ bri = ((float)(video_resources->color_brightness - 1000)) * (128.0f / 1000.0f); con = ((float)(video_resources->color_contrast )) / 1000.0f; gam = video_get_gamma(video_resources, video); scn = ((float)(video_resources->pal_scanlineshade)) / 1000.0f; #endif factor = pow(255.0f, 1.0f - gam); DBG((" bri:%f con:%f gam:%f scn:%f", bri, con, gam, scn)); for (i = 0; i < (256 * 3); i++) { v = video_gamma((float)(i - 256), factor, gam, bri, con); vi = (uint32_t)v; if (vi > 255) { vi = 255; } color_tab->gamma_red[i] = color_tab->color_red[vi]; color_tab->gamma_grn[i] = color_tab->color_grn[vi]; color_tab->gamma_blu[i] = color_tab->color_blu[vi]; vi = (uint32_t)(v * scn); if (vi > 255) { vi = 255; } color_tab->gamma_red_fac[i * 2] = color_tab->color_red[vi]; color_tab->gamma_grn_fac[i * 2] = color_tab->color_grn[vi]; color_tab->gamma_blu_fac[i * 2] = color_tab->color_blu[vi]; v = video_gamma((float)(i - 256) + 0.5f, factor, gam, bri, con); vi = (uint32_t)(v * scn); if (vi > 255) { vi = 255; } color_tab->gamma_red_fac[i * 2 + 1] = color_tab->color_red[vi]; color_tab->gamma_grn_fac[i * 2 + 1] = color_tab->color_grn[vi]; color_tab->gamma_blu_fac[i * 2 + 1] = color_tab->color_blu[vi]; } } /* FIXME: this is a hack to adjust the output of the internal color generator somewhat to align with the pepto palette when all neutral parameters are used */ #define CRT_SAT_MUL (1.5f+0.25f) /* ycbcr table calculation */ /* called by video_color_update_palette, internal and external palette */ static void video_calc_ycbcrtable(video_resources_t *video_resources, const video_ycbcr_palette_t *p, video_render_color_tables_t *color_tab, int video) { video_ycbcr_color_t *primary; unsigned int i, lf, hf; float sat, tin, bri, con, gam; float yf, uf, vf; int y, u, v; double factor, len; #ifdef DEBUG_VIDEO palette_entry_t temp; #endif DBG(("video_calc_ycbcrtable")); lf = 64 * video_resources->pal_blur / 1000; hf = 255 - (lf << 1); #ifdef DEBUG_NEUTRAL_SETTINGS sat = 256.0; tin = 0.0; bri = 0.0; con = 1.0; gam = 1.0; #else /* default: sat:320,000000 bri:0,000000 con:1,250000 gam:0,785714 tin:0,000000 */ sat = ((float)(video_resources->color_saturation)) * (256.0f / 1000.0f) * CRT_SAT_MUL; tin = (((float)(video_resources->color_tint)) * (50.0f / 2000.0f)) - 25.0f; bri = ((float)(video_resources->color_brightness - 1000)) * (112.0f / 1000.0f); con = ((float)(video_resources->color_contrast )) / 1000.0f; gam = video_get_gamma(video_resources, video); #endif factor = pow(256.0f, 1.0f - gam); DBG((" sat:%f bri:%f con:%f gam:%f tin:%f", sat, bri, con, gam, tin)); for (i = 0; i < p->num_entries; i++) { int32_t val; /* create primary table */ primary = &p->entries[i]; if (video) { val = (int32_t)(primary->y * 256.0f); color_tab->ytablel[i] = val * lf; color_tab->ytableh[i] = val * hf; /* tint, add to cr in odd lines */ val = (int32_t)(tin); color_tab->cbtable[i] = (int32_t)((primary->cb) * sat); color_tab->crtable[i] = (int32_t)((primary->cr + val) * sat); color_tab->cutable[i] = (int32_t)(0.493111f * primary->cb * 256.0); /* convert Cb to U */ color_tab->cvtable[i] = (int32_t)(0.877283f * (primary->cr + val) * 256.0); /* convert Cr to V */ } else { /* for NTSC use one bit less for the fraction in the tables to avoid integer overflows in the CRT renderer */ val = (int32_t)(primary->y * 128.0f); color_tab->ytablel[i] = (val * lf); color_tab->ytableh[i] = (val * hf); /* FIXME: tint for NTSC */ val = (int32_t)(tin); color_tab->cbtable[i] = (int32_t)((primary->cb) * sat) >> 1; color_tab->crtable[i] = (int32_t)((primary->cr + val) * sat) >> 1; /* FIXME: convert IQ to UV (used by YUV renderers) */ color_tab->cutable[i] = (int32_t)(primary->cb * 256.0); color_tab->cvtable[i] = (int32_t)((primary->cr + val) * 256.0); } #ifdef DEBUG_VIDEO video_convert_renderer_to_rgb(primary, &temp, video); DBG((" %2u 'Cb':%4d 'Cr':%4d 'Cr':%6d 'Cb':%6d R:%4d G:%4d B:%4d", i, (int)primary->cb, (int)primary->cr, (int)color_tab->cbtable[i], (int)color_tab->crtable[i], temp.red, temp.green, temp.blue )); #endif yf = (float)(video_gamma(primary->y, factor, gam, bri, con) * 224.0 / 256.0 + 16.5); if (video) { /* PAL: convert CbCr to UV */ uf = (float)(0.493111f * primary->cb * sat * con * 224.0 / 256.0 / 256.0 + 128.5); vf = (float)(0.877283f * (primary->cr + tin) * sat * con * 224.0 / 256.0 / 256.0 + 128.5); } else { /* FIXME: convert IQ to UV (used by YUV renderers) */ uf = (float)(0.493111f * primary->cb * sat * con * 224.0 / 256.0 / 256.0 + 128.5); vf = (float)(0.877283f * (primary->cr + tin) * sat * con * 224.0 / 256.0 / 256.0 + 128.5); } /* sanity check: cbtable and crtable must be kept in 16 bit range or we might get overflows in eg the CRT renderer */ /* FIXME: we need to check more and clamp the values accordingly - it is still possible to "overdrive" the renderer in NTSC mode */ len = sqrt(((double)color_tab->cbtable[i] * (double)color_tab->cbtable[i]) + ((double)color_tab->crtable[i] * (double)color_tab->crtable[i])); if (len >= (double)0x10000) { log_error(LOG_DEFAULT, "video_calc_ycbcrtable: color %u cbcr vector too long, use lower base saturation.", i); } y = (int)RMINMAX(yf, 16, 240); u = (int)RMINMAX(uf, 16, 240); v = (int)RMINMAX(vf, 16, 240); /* YCbCr to YUV, scale [0, 256] to [0, 255] (used by YUV renderers) */ color_tab->yuv_table[i] = (y << 16) | (u << 8) | v; } color_tab->yuv_updated = 0; } static void video_calc_ycbcrtable_oddlines(video_resources_t *video_resources, const video_ycbcr_palette_t *p, video_render_color_tables_t *color_tab, int video) { video_ycbcr_color_t *primary; unsigned int i; float sat, tin; DBG(("video_calc_ycbcrtable_oddlines")); #ifdef DEBUG_NEUTRAL_SETTINGS sat = 256.0; tin = 0.0; #else /* default: sat:560,000000 tin:0,000000 */ sat = ((float)(video_resources->color_saturation)) * (256.0f / 1000.0f) * CRT_SAT_MUL; tin = (((float)(video_resources->color_tint)) * (50.0f / 2000.0f)) - 25.0f; #endif DBG((" sat:%f tin:%f", sat, tin)); for (i = 0; i < p->num_entries; i++) { int32_t val; /* create primary table */ primary = &p->entries[i]; /* tint, substract from cr in odd lines */ val = (int32_t)(tin); color_tab->cbtable_odd[i] = -(int32_t)((primary->cb) * sat); color_tab->crtable_odd[i] = -(int32_t)((primary->cr - val) * sat); color_tab->cutable_odd[i] = -(int32_t)(0.493111f * primary->cb * 256); /* PAL: convert Cb to U */ color_tab->cvtable_odd[i] = -(int32_t)(0.877283f * (primary->cr - val) * 256); /* PAL: convert Cr to V */ } } /* Convert an RGB palette to YCbCr. (used when custom palette is loaded) */ static void video_palette_to_ycbcr(const palette_t *p, video_ycbcr_palette_t* ycbcr, int video) { unsigned int i; #ifdef DEBUG_VIDEO int r, g, b; palette_entry_t temp; #endif DBG(("video_palette_to_ycbcr")); for (i = 0; i < p->num_entries; i++) { if (video) { video_convert_rgb_to_renderer(&p->entries[i], &ycbcr->entries[i], video); #ifdef DEBUG_VIDEO video_convert_renderer_to_rgb(&ycbcr->entries[i], &temp, video); DBG((" %2u R:%3d G:%3d B:%3d Y:%4d Cb:%4d Cr:%4d R:%3d G:%3d B:%3d", i, p->entries[i].red, p->entries[i].green, p->entries[i].blue, (int)ycbcr->entries[i].y, (int)ycbcr->entries[i].cb, (int)ycbcr->entries[i].cr, temp.red, temp.green, temp.blue )); #endif } else { video_convert_rgb_to_yiq(&p->entries[i], &ycbcr->entries[i]); #ifdef DEBUG_VIDEO video_convert_yiq_to_rgb(&ycbcr->entries[i], &r, &g, &b); DBG((" %2u R:%3d G:%3d B:%3d Y:%4d I:%4d Q:%4d R:%3d G:%3d B:%3d", i, p->entries[i].red, p->entries[i].green, p->entries[i].blue, (int)ycbcr->entries[i].y, (int)ycbcr->entries[i].cb, (int)ycbcr->entries[i].cr, r, g, b )); #endif } } } /* Convert an RGB palette to YCbCr. (used when custom palette is loaded) */ static void video_palette_to_ycbcr_oddlines(const palette_t *p, video_ycbcr_palette_t* ycbcr, int video) { unsigned int i; DBG(("video_palette_to_ycbcr_oddlines")); for (i = 0; i < p->num_entries; i++) { video_convert_rgb_to_renderer(&p->entries[i], &ycbcr->entries[i], video); ycbcr->entries[i].cr = -ycbcr->entries[i].cr; ycbcr->entries[i].cb = -ycbcr->entries[i].cb; } } /* Convert the internal videochip palette to YCbCr. */ static void video_cbm_palette_to_ycbcr(const video_cbm_palette_t *p, video_ycbcr_palette_t* ycbcr, int video) { unsigned int i; #ifdef DEBUG_VIDEO int cb, cr; #endif DBG(("video_cbm_palette_to_ycbcr (even)")); if (p->type == CBM_PALETTE_RGB) { /* special case for handling chips that output RGB (such as the VDC), admittedly slightly ugly but simple and effective :) */ palette_entry_t src; for (i = 0; i < p->num_entries; i++) { src.red = (uint8_t)p->entries[i].luminance; src.green = (uint8_t)p->entries[i].angle; src.blue = (uint8_t)p->entries[i].saturation; video_convert_rgb_to_renderer(&src, &ycbcr->entries[i], video); } } else { for (i = 0; i < p->num_entries; i++) { if ((p->entries_even != NULL) && (p->entries_odd != NULL)) { /* we have seperate palettes for odd and even lines */ video_convert_cbm_to_ycbcr(&p->entries_even[i], p->phase, &ycbcr->entries[i], video); } else { /* common palette for odd and even lines */ video_convert_cbm_to_ycbcr(&p->entries[i], p->phase, &ycbcr->entries[i], video); } #ifdef DEBUG_VIDEO cb = ycbcr->entries[i].cb; cr = ycbcr->entries[i].cr; if (video) { video_convert_ycbcr_to_yuv(&ycbcr->entries[i], &ycbcr->entries[i]); DBG((" %2u: Luma:%4d Angle:%4d Sat:%4d Dir:%2d Y:%4d Cb:%4d Cr:%4d Y:%4d U:%4d V:%4d", i, (int)p->entries[i].luminance, (int)p->entries[i].angle, (int)p->entries[i].saturation, (int)p->entries[i].direction, (int)ycbcr->entries[i].y, cb, cr, (int)ycbcr->entries[i].y, (int)ycbcr->entries[i].cb, (int)ycbcr->entries[i].cr )); } else { /* video_convert_ycbcr_to_yiq(&ycbcr->entries[i], &ycbcr->entries[i]); */ DBG((" %2u: Luma:%4d Angle:%4d Sat:%4d Dir:%2d Y:%4d Cb:%4d Cr:%4d Y:%4d I:%4d Q:%4d", i, (int)p->entries[i].luminance, (int)p->entries[i].angle, (int)p->entries[i].saturation, (int)p->entries[i].direction, (int)ycbcr->entries[i].y, cb, cr, (int)ycbcr->entries[i].y, (int)ycbcr->entries[i].cb, (int)ycbcr->entries[i].cr )); } ycbcr->entries[i].cb = cb; ycbcr->entries[i].cr = cr; #endif } } } /* offsets between +45.0 and -45.0 kinda make sense (ie the colors will not look terribly wrong.) a "perfect" c64 setup will use +/- 0 (and thus the colorshifting caused by the phase differences will not be visible), however such thing doesn't exist in the real world, and infact gfx people are (ab)using this "feature" in their pictures. - my c64 seems to use ~ +20.0 (gpz) */ static void video_cbm_palette_to_ycbcr_oddlines(video_resources_t *video_resources, const video_cbm_palette_t *p, video_ycbcr_palette_t* ycbcr, int video) { unsigned int i; float offs = (((float)(video_resources->pal_oddlines_phase)) / (2000.0f / 90.0f)) + (180.0f - 45.0f); DBG(("video_cbm_palette_to_ycbcr_oddlines")); for (i = 0; i < p->num_entries; i++) { if ((p->entries_even != NULL) && (p->entries_odd != NULL)) { /* we have seperate palettes for odd and even lines */ offs = 180.0f; video_convert_cbm_to_ycbcr(&p->entries_odd[i], (p->phase + offs), &ycbcr->entries[i], video); } else { /* common palette for odd and even lines */ video_convert_cbm_to_ycbcr(&p->entries[i], (p->phase + offs), &ycbcr->entries[i], video); } } } /* Calculate a RGB palette out of VIC/VIC-II/TED colors (in ycbcr format), apply saturation, brightness, contrast, tint and gamma settings. this palette will be used for screenshots and by renderers if CRT emulation is disabled. */ static palette_t *video_calc_palette(struct video_canvas_s *canvas, const video_ycbcr_palette_t *p, int video) { palette_t *prgb; unsigned int i; float sat, bri, con, gam, tin; video_resources_t *video_resources = &(canvas->videoconfig->video_resources); DBG(("video_calc_palette (no crt)")); #ifdef DEBUG_NEUTRAL_SETTINGS sat = 1.0; tin = 0.0; bri = 0.0; con = 1.0; gam = 1.0; #else sat = ((float)(video_resources->color_saturation)) / 1000.0f; bri = ((float)(video_resources->color_brightness - 1000)) * (128.0f / 1000.0f); con = ((float)(video_resources->color_contrast)) / 1000.0f; gam = video_get_gamma(video_resources, video); tin = (((float)(video_resources->color_tint)) / (2000.0f / 50.0f)) - 25.0f; #endif /* create RGB palette with the base colors of the video chip */ prgb = palette_create(p->num_entries, NULL); if (prgb == NULL) { return NULL; } DBG((" sat:%f bri:%f con:%f gam:%f tin:%f", sat, bri, con, gam, tin)); for (i = 0; i < p->num_entries; i++) { video_convert_renderer_to_rgb_gamma(&p->entries[i], sat, bri, con, gam, tin, &prgb->entries[i], video); DBG((" %2u: Y:%4d Cb:%4d Cr:%4d R:%2x G:%2x B:%2x", i, (int)p->entries[i].y, (int)p->entries[i].cb, (int)p->entries[i].cr, (int)prgb->entries[i].red, (int)prgb->entries[i].green, (int)prgb->entries[i].blue)); } return prgb; } /* Load RGB palette. */ static palette_t *video_load_palette(const video_cbm_palette_t *p, const char *name) { palette_t *palette; palette = palette_create(p->num_entries, NULL); if (palette == NULL) { return NULL; } if (!video_disabled_mode && palette_load(name, machine_name, palette) < 0) { /* log_message(vicii.log, "Cannot load palette file `%s'.", name); */ palette_free(palette); return NULL; } return palette; } /* Calculate or load a palette, depending on configuration. */ int video_color_update_palette(struct video_canvas_s *canvas) { palette_t *palette; video_ycbcr_palette_t *ycbcr; video_resources_t *video_resources; int video; DBG(("video_color_update_palette canvas: %p", (void*)canvas)); if (canvas == NULL) { return 0; } canvas->videoconfig->color_tables.updated = 1; DBG(("video_color_update_palette cbm palette:%d extern: %d", canvas->videoconfig->cbm_palette ? 1 : 0, canvas->videoconfig->external_palette ? 1 : 0)); if (canvas->videoconfig->cbm_palette == NULL) { return 0; } /*resources_get_int("MachineVideoStandard", &video);*/ video = canvas->viewport->crt_type; video_resources = &(canvas->videoconfig->video_resources); #if 0 /* setup the palette params so we get 100% the same as in peptos calculations */ video_resources->color_saturation = 1000; video_resources->color_brightness = 1000; video_resources->color_contrast = 1000; video_resources->color_tint = 1000; canvas->videoconfig->cbm_palette->saturation = 34.0081334493f; canvas->videoconfig->cbm_palette->phase = 0; DBG(("sat:%d bri:%d con:%d tin:%d", video_resources->color_saturation, video_resources->color_brightness, video_resources->color_contrast, video_resources->color_tint )); #endif if (canvas->videoconfig->external_palette) { palette = video_load_palette(canvas->videoconfig->cbm_palette, canvas->videoconfig->external_palette_name); if (!palette) { /* loading the external palette did not work (file not found?), so disable the external palette and use the internal palette instead */ canvas->videoconfig->external_palette = 0; } else { video_calc_gammatable(&canvas->videoconfig->color_tables, video_resources, video); ycbcr = video_ycbcr_palette_create(palette->num_entries); video_palette_to_ycbcr(palette, ycbcr, video); video_calc_ycbcrtable(video_resources, ycbcr, &canvas->videoconfig->color_tables, video); /* if (canvas->videoconfig->filter == VIDEO_FILTER_CRT) */ { palette_free(palette); palette = video_calc_palette(canvas, ycbcr, video); } /* additional table for odd lines */ video_palette_to_ycbcr_oddlines(palette, ycbcr, video); video_calc_ycbcrtable_oddlines(video_resources, ycbcr, &canvas->videoconfig->color_tables, video); } } /* Use calculated internal palette. Don't put this into an "else" block, so it can be used as fallback when the above fails. */ if (canvas->videoconfig->external_palette == 0) { video_calc_gammatable(&canvas->videoconfig->color_tables, video_resources, video); ycbcr = video_ycbcr_palette_create(canvas->videoconfig->cbm_palette->num_entries); video_cbm_palette_to_ycbcr(canvas->videoconfig->cbm_palette, ycbcr, video); video_calc_ycbcrtable(video_resources, ycbcr, &canvas->videoconfig->color_tables, video); palette = video_calc_palette(canvas, ycbcr, video); /* additional table for odd lines */ video_cbm_palette_to_ycbcr_oddlines(video_resources, canvas->videoconfig->cbm_palette, ycbcr, video); video_calc_ycbcrtable_oddlines(video_resources, ycbcr, &canvas->videoconfig->color_tables, video); } video_ycbcr_palette_free(ycbcr); if (palette != NULL) { return video_canvas_palette_set(canvas, palette); } return -1; } void video_color_palette_internal(struct video_canvas_s *canvas, struct video_cbm_palette_s *cbm_palette) { canvas->videoconfig->cbm_palette = cbm_palette; canvas->videoconfig->color_tables.updated = 0; } void video_color_palette_free(struct palette_s *palette) { palette_free(palette); } /* called by archdep code for first initial setup */ void video_render_initraw(struct video_render_config_s *videoconfig) { int video; resources_get_int("MachineVideoStandard", &video); video_calc_gammatable(&videoconfig->color_tables, &videoconfig->video_resources, video); }