Guía: Como mejorar la imagen por software y hardware

Por cierto, ¿influye ponerlo en pre-resize o en post-resize? Y si es así, en cuál se deben poner estos dos(Vibrance y Luma)?

oye se hace complicado encontrar algo ya en este hilo, pq no se unifica la informacion interesante en el primer mensaje???

Iniciado por onizuka26

oye se hace complicado encontrar algo ya en este hilo, pq no se unifica la informacion interesante en el primer mensaje???

Que presión jajaja ueeeeno voy a actualizar el primer post.

PD: ACTUALIZADO

Podríais probar el pack completo con el shader curves que comenté en el post del Darbee:

Iniciado por Delfin_

Yo no he visto el Darbee en acción así que no puedo opinar, pero en base a lo que decís que hace (contraste, gammas, sharpen ...) ¿habeis probado con esta combinación de shaders?:

En pre-resize:

Curves, para jugar con el contraste y s-curves (hace un efecto parecido a lo que comentais de "quitar neblina").

Código:

/* --- Curves settings --- */
#define Curves_contrast 0.30  //[-1.0 to 1.0] The amount of contrast you want

// -- Advanced curve settings --
#define Curves_formula 3      //[1 to 7] The constrast s-curve you want to use. 
/* --- End of settings --- */

/* ---  Defining Constants --- */

sampler s0 : register(s0);


/* --- Curves --- */
/*
  by Christian Cann Schuldt Jensen ~ CeeJay.dk
  
  Curves, uses S-curves to increase contrast, without clipping highlights and shadows.
*/

float4 CurvesPass( float4 colorInput )
{
  float3 color = colorInput.rgb; //original input color
  float3 lumCoeff = float3(0.2126, 0.7152, 0.0722);  //Values to calculate luma with
  float Curves_contrast_blend = Curves_contrast;
  float PI = acos(-1); //3.14159265

  //calculate luma (grey)
  float luma = dot(lumCoeff, color);
	
  //calculate chroma
	float3 chroma = color - luma;
	
	//Apply curve to luma
	
	// -- Curve 1 --
  #if Curves_formula == 1
    luma = sin(PI * 0.5 * luma); // Sin - 721 amd fps, +vign 536 nv
    luma *= luma;  
  #endif
  
  // -- Curve 2 --
  #if Curves_formula == 2
    luma = ( (luma - 0.5) / (0.5 + abs(luma-0.5)) ) + 0.5;
  #endif

	// -- Curve 3 --
  #if Curves_formula == 3
    //luma = smoothstep(0.0,1.0,luma); //smoothstep
    luma = luma*luma*(3.0-2.0*luma); //faster smoothstep alternative
  #endif

	// -- Curve 4 --
  #if Curves_formula == 4
    luma = 1.1048 / (1.0 + exp(-3.0 * (luma * 2.0 - 1.0))) - (0.1048 / 2.0); //exp formula
  #endif

	// -- Curve 5 --
  #if Curves_formula == 5
    luma = 0.5 * (luma + 3.0 * luma * luma - 2.0 * luma * luma * luma); //a simple catmull-rom (0,0,1,1)
    Curves_contrast_blend = Curves_contrast * 2.0; //I multiply by two to give it a strength closer to the other curves.
  #endif

 	// -- Curve 6 --
  #if Curves_formula == 6
    luma = luma*luma*luma*(luma*(luma*6.0 - 15.0) + 10.0); //Perlins smootherstep
	#endif
	
	// -- Curve 7 --
  #if Curves_formula == 7
    luma = ((luma-0.5) / ((0.5/(4.0/3.0)) + abs((luma-0.5)*1.25))) + 0.5;
  #endif
	
  
	//Add back the chroma
	color = luma + chroma;
	
	//Blend by Curves_contrast
	colorInput.rgb = lerp(colorInput.rgb, color, Curves_contrast_blend);
	
  //Return the result
  return colorInput;
}

/* --- Main --- */

float4 main(float2 tex : TEXCOORD0) : COLOR {
	float4 FinalColor = tex2D(s0, tex);

	FinalColor = CurvesPass(FinalColor);

	return FinalColor;
}

Post-resize:

Lumasharpen, si está muy fuerte podeis probar con un valor 0.5 en define sharp_strength y 0.035 en define sharp_clamp.
Tambien podeis probarlo en pre-resize en fnción del algoritmo de escalado que useis (supongo).

Código:

/*
   _____________________
     
     LumaSharpen 1.3.10
   _____________________ 

  by Christian Cann Schuldt Jensen ~ CeeJay.dk
  
  It blurs the original pixel with the surrounding pixels and then subtracts this blur to sharpen the image.
  It does this in luma to avoid color artifacts and allows limiting the maximum sharpning to avoid or lessen halo artifacts.
  
  This is similar to using Unsharp Mask in Photoshop.
    
  Compiles with 3.0
*/

// .----------------------------------------------------._User settings_.---------------------------------------------------. 

// -- Sharpening --
#define sharp_strength 1.0 // Strength of the sharpening - You should probably use something between 0.2 and 2.0 - default is 1.0
#define sharp_clamp 0.050  // Limits maximum amount of sharpening a pixel recieves - Default is 0.050

// -- Advanced sharpening settings --
#define pattern 2          // Choose a sample pattern ( 1, 2, 3 or 4 ) - I suggest 2
#define offset_bias 1.0    // Offset bias adjusts the radius of the sampling pattern.
                           // I designed the pattern for offset_bias 1.0, but feel free to experiment.

// .----------------------------------------------------._Debug settings_.--------------------------------------------------. 

#define splitscreen 0      // Enables the before-and-after splitscreen comparison mode. Left side is before.
#define show_sharpen 0     // Visualize the strength of the sharpen (multiplied by 4 to see it better)

// .--------------------------------------------------._Developer settings_.------------------------------------------------. 

#define CoefLuma float4(0.2126, 0.7152, 0.0722,0)      // BT.709 & sRBG luma coefficient (Monitors and HD Television)
//#define CoefLuma float4(0.299, 0.587, 0.114,0)       // BT.601 luma coefficient (SD Television)
//#define CoefLuma float4(1.0/3.0, 1.0/3.0, 1.0/3.0,0) // Equal weight coefficient

#define sharp_strength_luma (CoefLuma * sharp_strength)

// .--------------------------------------------------._Defining constants_.------------------------------------------------. 

#ifndef s0
  sampler s0 : register(s0);
  #define s1 s0
//sampler s1 : register(s1);

//float4 p0 : register(c0);
  float4 p1 : register(c1);

//  #define width (p0[0])
//  #define height (p0[1])
//  #define counter (p0[2])
//  #define clock (p0[3])
//  #define px (p1[0]) //one_over_width 
//  #define py (p1[1]) //one_over_height

  #define px (p1.x) //one_over_width 
  #define py (p1.y) //one_over_height

  //#define pxy float2(p1.xy)

  //#define PI acos(-1)
  #define target 1 
#endif


// .------------------------------------------------------._Main code_.-----------------------------------------------------. 

#if target == 1
float4 main( float2 tex : TEXCOORD0 ) : COLOR  // Use with Shaderanalyzer and MPC-HC
#else
float4 LumaSharpenPass( float2 tex ) 
#endif
{

  // -- Get the original pixel --
  float4 ori = tex2D(s1, tex);       // ori = original pixel



// .--------------------------------------------------._Sampling patterns_.-------------------------------------------------. 

  //   [ NW,   , NE ] Each texture lookup (except ori)
  //   [   ,ori,    ] samples 4 pixels
  //   [ SW,   , SE ]

  // -- Pattern 1 -- A (fast) 7 tap gaussian using only 2+1 texture fetches.
  #if pattern == 1

	// -- Gaussian filter --
	//   [ 1/9, 2/9,    ]     [ 1 , 2 ,   ]
	//   [ 2/9, 8/9, 2/9]  =  [ 2 , 8 , 2 ]
 	//   [    , 2/9, 1/9]     [   , 2 , 1 ]

    float4 blur_ori = tex2D(s0, tex + (float2(px,py) / 3) * offset_bias);  // North West
    blur_ori += tex2D(s0, tex + (float2(-px,-py) / 3) * offset_bias); // South East

    //blur_ori += tex2D(s0, tex + float2(px,py) / 3 * offset_bias); // North East
    //blur_ori += tex2D(s0, tex + float2(-px,-py) / 3 * offset_bias); // South West

    blur_ori /= 2;  //Divide by the number of texture fetches
    
    sharp_strength_luma *= 1.5; // Adjust strength to aproximate the strength of pattern 2

  #endif
  
  // -- Pattern 2 -- A 9 tap gaussian using 4+1 texture fetches.
  #if pattern == 2

	// -- Gaussian filter --
	//   [ .25, .50, .25]     [ 1 , 2 , 1 ]
	//   [ .50,   1, .50]  =  [ 2 , 4 , 2 ]
 	//   [ .25, .50, .25]     [ 1 , 2 , 1 ]


    float4 blur_ori = tex2D(s0, tex + float2(px,-py) * 0.5 * offset_bias); // South East
    blur_ori += tex2D(s0, tex + float2(-px,-py) * 0.5 * offset_bias);  // South West    
    blur_ori += tex2D(s0, tex + float2(px,py) * 0.5 * offset_bias); // North East
    blur_ori += tex2D(s0, tex + float2(-px,py) * 0.5 * offset_bias); // North West

    blur_ori *= 0.25;  // ( /= 4) Divide by the number of texture fetches

  #endif 

  // -- Pattern 3 -- An experimental 17 tap gaussian using 4+1 texture fetches.
  #if pattern == 3

	// -- Gaussian filter --
	//   [   , 4 , 6 ,   ,   ]
	//   [   ,16 ,24 ,16 , 4 ]
	//   [ 6 ,24 ,   ,24 , 6 ]
	//   [ 4 ,16 ,24 ,16 ,   ]
	//   [   ,   , 6 , 4 ,   ]

    float4 blur_ori = tex2D(s0, tex + float2(0.4*px,-1.2*py)* offset_bias);  // South South East
    blur_ori += tex2D(s0, tex + float2(-1.2*px,-0.4*py) * offset_bias); // West South West
    blur_ori += tex2D(s0, tex + float2(1.2*px,0.4*py) * offset_bias); // East North East
    blur_ori += tex2D(s0, tex + float2(-0.4*px,1.2*py) * offset_bias); // North North West

    blur_ori *= 0.25;  // ( /= 4) Divide by the number of texture fetches
    
    sharp_strength_luma *= 0.51;
  #endif

  // -- Pattern 4 -- A 9 tap high pass (pyramid filter) using 4+1 texture fetches.
  #if pattern == 4

	// -- Gaussian filter --
	//   [ .50, .50, .50]     [ 1 , 1 , 1 ]
	//   [ .50,    , .50]  =  [ 1 ,   , 1 ]
 	//   [ .50, .50, .50]     [ 1 , 1 , 1 ]

    half4 blur_ori = tex2D(s0, tex + float2(0.5 * px,-py * offset_bias));  // South South East
    blur_ori += tex2D(s0, tex + float2(offset_bias * -px,0.5 * -py)); // West South West
    blur_ori += tex2D(s0, tex + float2(offset_bias * px,0.5 * py)); // East North East
    blur_ori += tex2D(s0, tex + float2(0.5 * -px,py * offset_bias)); // North North West

    //blur_ori += (2 * ori); // Probably not needed. Only serves to lessen the effect.
	
    blur_ori /= 4;  //Divide by the number of texture fetches

    sharp_strength_luma *= 0.666; // Adjust strength to aproximate the strength of pattern 2
  #endif

  // -- Pattern 8 -- A (slow) 9 tap gaussian using 9 texture fetches.
  #if pattern == 8

	// -- Gaussian filter --
	//   [ 1 , 1 , 1 ]
	//   [ 1 , 1 , 1 ]
 	//   [ 1 , 1 , 1 ]

    half4 blur_ori = tex2D(s0, tex + float2(-px,py) * offset_bias); // North West
    blur_ori += tex2D(s0, tex + float2(px,-py) * offset_bias);     // South East
    blur_ori += tex2D(s0, tex + float2(-px,-py)  * offset_bias);  // South West
    blur_ori += tex2D(s0, tex + float2(px,py) * offset_bias);    // North East
    
    half4 blur_ori2 = tex2D(s0, tex + float2(0,py) * offset_bias); // North
    blur_ori2 += tex2D(s0, tex + float2(0,-py) * offset_bias);    // South
    blur_ori2 += tex2D(s0, tex + float2(-px,0) * offset_bias);   // West
    blur_ori2 += tex2D(s0, tex + float2(px,0) * offset_bias);   // East
    blur_ori2 *= 2;

    blur_ori += blur_ori2;
    blur_ori += (ori * 4); // Probably not needed. Only serves to lessen the effect.

    // dot()s with gaussian strengths here?

    blur_ori /= 16;  //Divide by the number of texture fetches

    //sharp_strength_luma *= 0.75; // Adjust strength to aproximate the strength of pattern 2
  #endif

  // -- Pattern 9 -- A (slow) 9 tap high pass using 9 texture fetches.
  #if pattern == 9

	// -- Gaussian filter --
	//   [ 1 , 1 , 1 ]
	//   [ 1 , 1 , 1 ]
 	//   [ 1 , 1 , 1 ]

    half4 blur_ori = tex2D(s0, tex + float2(-px,py) * offset_bias); // North West
    blur_ori += tex2D(s0, tex + float2(px,-py) * offset_bias);     // South East
    blur_ori += tex2D(s0, tex + float2(-px,-py)  * offset_bias);  // South West
    blur_ori += tex2D(s0, tex + float2(px,py) * offset_bias);    // North East
    
    blur_ori += ori; // Probably not needed. Only serves to lessen the effect.
    
    blur_ori += tex2D(s0, tex + float2(0,py) * offset_bias);    // North
    blur_ori += tex2D(s0, tex + float2(0,-py) * offset_bias);  // South
    blur_ori += tex2D(s0, tex + float2(-px,0) * offset_bias); // West
    blur_ori += tex2D(s0, tex + float2(px,0) * offset_bias); // East

    blur_ori /= 9;  //Divide by the number of texture fetches

    //sharp_strength_luma *= (8.0/9.0); // Adjust strength to aproximate the strength of pattern 2
  #endif
  
// .-----------------------------------------------._Sharpen_.-------------------------------------------------------. 
  
  // -- Calculate the sharpening --  
  float4 sharp = ori - blur_ori;  //Subtracting the blurred image from the original image
  
  // -- Adjust strength of the sharpening --
  float sharp_luma = dot(sharp, sharp_strength_luma); //Calculate the luma and adjust the strength

  // -- Clamping the maximum amount of sharpening to prevent halo artifacts --
  sharp_luma = clamp(sharp_luma, -sharp_clamp, sharp_clamp);  //TODO Try a curve function instead of a clamp

  // -- Combining the values to get the final sharpened pixel	--
  float4 done = ori + sharp_luma;    // Add the sharpening to the original.
 
// .------------------------------------------._Returning the output_.-----------------------------------------------. 

  #if show_sharpen == 1
    //float3 chroma = ori - luma;
    //done = abs(sharp * 4).rrr;
    done = saturate(0.5 + (sharp_luma * 4)).rrrr;
  #endif

  #if splitscreen == 1
    if (tex.x < 0.5)
      done = ori;
  #endif

  return done;

}

Pre-resize:

Vibrance para jugar con la saturación, satura cada pixel independientemente en función de lo saturado que esté en origen.

Código:

/* --- Vibrance settings --- */

#define Vibrance 0.18  //Intelligently saturates (or desaturates if you use negative values) the pixels depending on their original saturation.


/* ---  Defining Constants --- */

sampler s0 : register(s0);


/* --- Vibrance --- */
/*
  by Christian Cann Schuldt Jensen ~ CeeJay.dk
  
  Vibrance intelligently boosts the saturation of pixels
  so pixels that had little color get a larger boost than pixels that had a lot.
  
  This avoids oversaturation of pixels that were already very saturated.
*/

float4 VibrancePass( float4 colorInput )
{
	float4 color = colorInput; //original input color
  float3 lumCoeff = float3(0.2126, 0.7152, 0.0722);  //Values to calculate luma with

	float luma = dot(lumCoeff, color.rgb); //calculate luma (grey) 

	float max_color = max(max(colorInput.r,colorInput.g),colorInput.b); //Find the strongest color
	float min_color = min(min(colorInput.r,colorInput.g),colorInput.b); //Find the weakest color
	
  float color_saturation = max_color - min_color; //The difference between the two is the saturation

  //color = lerp(luma, color, (1.0 + (Vibrance * (1.0 - color_saturation)))); //extrapolate between luma and original by 1 + (1-saturation)
  
  color = lerp(luma, color, (1.0 + (Vibrance * (1.0 - (sign(Vibrance) * color_saturation))))); //extrapolate between luma and original by 1 + (1-saturation)

	return color; //return the result
	//return color_saturation.xxxx; //Visualize the saturation
}

/* --- Main --- */

float4 main(float2 tex : TEXCOORD0) : COLOR {
	float4 c0 = tex2D(s0, tex);

	c0 = VibrancePass(c0);

	return c0;
}

No sé si este último, el vibrance, sería necesario. Los que hayais visto el Darbee en acción probara activar y desactivar este shader aver si ayuda o no.

Podéis personalizarlos en las primeras lineas de cada código.

Habría que mirar si hay una versión mas nueva como ocurre con el LumaSharpen. Están optimizados para el mpc hc por lo que no se si funcionará Curves en Potplayer pero por probarlo (si funciona LumaSharpen y Vibrance podría ser que curves tambien).

Fuente: Ficheros TXT

Iniciado por kawito

Por cierto, ¿influye ponerlo en pre-resize o en post-resize? Y si es así, en cuál se deben poner estos dos(Vibrance y Luma)?

Los de nitidez es mejor en post-resize porque si no el poco o mucho ringing/aliasing que generen se verá escalado tambien. CeeJay.dk recomienda LumaSharpen en post-resize:

I suggest you add it to the list of Post-resize shaders though, but it also works as pre-resize shader. You can even use both.
I just use it as a post-resize shader though.

Guru3D.com Forums - View Single Post - nVidia's FXAA mode (anti-aliasing)

Edito: Se me olvidaba (tengo la cabeza hoy peor que de costumbre), CeeJay.dk ha dicho en el foro doom9 que pasaría algunos de los shaders de sweetfx a mpc hc por si quereis seguirle el rastro:

Originally Posted by turbojet
A bit off topic but speaking of competitive products, would you have interest in starting a thread about your pixel shaders in the software player forum? I ask because they are kind of difficult to track down and also I don't feel it's appropriate for anyone but you to start the thread since you are a member.

Okay. I'll look into that later this week then when I have more time.

I need to first create an updated package with all the filters from SweetFX that might be interesting for MPC users (are there other players that support shaders?) and perhaps a .reg file that will install them - it's annoying that MPC has no easy way to install new shader filter or options to control them, but I'll try to make the process as painless as possible.

DivX now ships with malware. - Doom9's Forum

Si veo que abre hilo nuevo sobre el tema lo comento aquí.

Iniciado por Delfin_

Podríais probar el pack completo con el shader curves que comenté en el post del Darbee:



Habría que mirar si hay una versión mas nueva como ocurre con el LumaSharpen. Están optimizados para el mpc hc por lo que no se si funcionará Curves en Potplayer pero por probarlo (si funciona LumaSharpen y Vibrance podría ser que curves tambien).

Fuente: Ficheros TXT



Los de nitidez es mejor en post-resize porque si no el poco o mucho ringing/aliasing que generen se verá escalado tambien. CeeJay.dk recomienda LumaSharpen en post-resize:



Guru3D.com Forums - View Single Post - nVidia's FXAA mode (anti-aliasing)

Gracias, gran aporte. El curves funciona también en pot pero he trasteado poco con el. Los shaders funcionan en todos los reproductores que los soporten. Pot/Mpc/KM...

A mi me mata el ringing que introducen los Sharpen. Fíjate en la imagen original:



Con Sharpen muy poco delicado:



Fijate en el halo que tiene la cabeza de él (por ejemplo).

Y la misma imagen con FineSharp:



Mas obvio el ringing en la zona de las barras metálicas del carrito.

Fuente: http://forum.doom9.org/showthread.ph...63#post1568963

Para verlo mas claro:

Escalado sin filtro antiringing:



Escalado con filtro antirringing:



O en una imagen real, muy escalada para que sea mas obvio el ringing:

Sin filtro antiringing:



Con filtro antiringing:



Fíjate en la palabra "meter" por ejemplo, o en los bordes de los escudos.

[Abrir cada imagen en una pestaña y alternar entre pestañas].

Quien tenga la suerte de no molestarle este artefacto podrá aumentar el efecto del Sharpen, lo contrario para el que sí le afecte.

Yo por esto no los uso, pero entiendo que según qué dispositivos para visualizar pueden venir bien, en algunas fuentes en concreto tambien, el gusto personal de cada uno (en mi entorno todos meten sharpen muy fuerte), etc. Al final, la imagen tiene que estar a tu gusto.

Según he leído últimamente por doom9 (principalmente en el hilo del madvr) de los mas usados por tener especial cuidado del ringing son LumaSharpen y, en avisynth, FineSharp.

Como ponemos un antiringing al Lumasharpen? por que por lo que he visto es un efecto secundario que no se puede corregir. Y es un precio a pagar. Pero si tienes una forma de evitarlo.... Seria genial!

A mi gusto personal me compensa el ringing que comentas por la cantidad de detalle que se gana. Me parece justo tener algunos artefactos a cambio de una calidad general óptima.

De todas formas me parece que no has probado el lumasharpen. ¿o me equivoco? es que en tus screens solo veo sharpen asecas.

Iniciado por baseq2

Como ponemos un antiringing al Lumasharpen?

Lo desconozco baseq2. Ese filtro antiringing es del madvr y quita el ringing que introducen los algoritmos de escalado.

Iniciado por baseq2

De todas formas me parece que no has probado el lumasharpen. ¿o me equivoco? es que en tus screens solo veo sharpen asecas.

Claro que lo he probado, de hecho lo tengo metido en el MPC HC. Los sharpen que tienen esos pantallazos de "El libro de Eli" son limitedsharpenfaster mod (lsfmod) y finesharp. En las imágenes escaladas los algoritmos son jinc en el test pattern (sin y con antiringing) y lanczos en el parquímetro (sin y con AR).

Muchas gracias baseq2 por la ayuda,ya estan activados los pixel shaders.
Se ve que tenía que tener el Video Renderer en automático.

Saludos.........

El Dia de Mañana.Las 2 capturas incluyen el Vibrance a 0.39 en Pre-Resize Pixel Shaders.

LumaSharpen 1.4.1 en Post Resize Pixel Shaders.
#define sharp_strength 0.80
#define sharp_clamp 0.035
#define pattern 1
#define offset_bias 6.0
#define show_sharpen 0

Sin Lumasharpen.

Con Lumasharpen .



Saludos...

Iniciado por Delfin_

... CeeJay.dk ha dicho en el foro doom9 que pasaría algunos de los shaders de sweetfx a mpc hc por si quereis seguirle el rastro:

DivX now ships with malware. - Doom9's Forum

Si veo que abre hilo nuevo sobre el tema lo comento aquí.

Como lo prometido es deuda y me acaban de avisar que CeeJay.dk acaba de abrir el hilo en doom9 con todo el tema shaders sweetfx ahí va:

SweetFX Video Shaders

No he tenido tiempo de mirarlo.

El Splash PRO también se ve de maravilla para no llevar filtros.

Los Vengadores en 1080p ( MKV de 17 gbs ) .


Saludos............

Ya ves se ve de WOW

El Splash PRO me da un viraje al azul muy exagerado y el lightboost lo tengo que bajar al minimo, por lo demas muy bien