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?:
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;
}
Vibrance para jugar con la saturación, satura cada pixel independientemente en función de lo saturado que esté en origen.
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.
LinkBack URL
About LinkBacks
Re: Guía: Como mejorar la imagen por software y hardware
Iniciado por baseq2
Siguiendo con mi búsqueda incansable y después de haber pasado buenos ratos con el Avisynth (Muy potente por cierto, pero tragón de CPU que lo hace inviable) parece que he encontrado la madre del cordero en esto de mejorar la nitidez y la profundidad por software.
Citar
.
.
