Darbee Video Procesador

A mi no me habia quedado claro si lo habia probado o no. Entonces bajo tu punto de vista son totalmente diferentes. Eso esta bien.

Ya seria la releche que nos dieras alguna referencia al filtro esebde avisinth, basicamente por cacharrear y de paso unas fotillos jeje del darbee vs filtro

Esta es la función pero como ya he dicho no tira al vuelo.


a = last
b = a.medianblur(12,8,8)
c = a.repair(a.repair(a.repair(a.repair(a.repair(a.rep air(a.repair(a.repair(b,1),1),1),1),1),1),1),1)
d = mt_lutxy(a,c,"x x y - abs 1.62 2 ^ / 1 1.62 / ^ 1.62 3 ^ * x y - x y - abs 1.62 + / * +",U=3,V=3)
interleave(a,d)
return(last)

Prometo no hacer ningún offtopic más, lo prometo lo prometo!

Pero si el pot player es una chusta, necesito saber que reproductor es mejor. Así de paso lo incluyo en mi post de software y hardware

Perdón, perdón!

Iniciado por Gn0m4

Esta es la función pero como ya he dicho no tira al vuelo.


a = last
b = a.medianblur(12,8,8)
c = a.repair(a.repair(a.repair(a.repair(a.repair(a.rep air(a.repair(a.repair(b,1),1),1),1),1),1),1),1)
d = mt_lutxy(a,c,"x x y - abs 1.62 2 ^ / 1 1.62 / ^ 1.62 3 ^ * x y - x y - abs 1.62 + / * +",U=3,V=3)
interleave(a,d)
return(last)

Seguramente algún bucle está descontrolado

Pena no estar en la uni para que lo revisará algún profesor.

El svp para mi es el que mejor resultados da de largo, pero el problema es que necesitas un pepino de pc,aun así con un I5 y una gráfica decente mejora muchísimo la imagen.

Iniciado por jordim23

El svp para mi es el que mejor resultados da de largo, pero el problema es que necesitas un pepino de pc,aun así con un I5 y una gráfica decente mejora muchísimo la imagen.

Que i5? porque hay algunos que son una bestia parda.

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.

Sí, yo lo he probado pero curves (yo utilizo otra función) no permite cortar por pixeles o extensión de luz su uso así que es parecido a aumentar contraste y bajar brillo. No se parece.

¿Ni jugando con "#define Curves_formula 3 //[1 to 7] The constrast s-curve you want to use." supongo no?

Iniciado por Gn0m4

Esta es la función pero como ya he dicho no tira al vuelo.


a = last
b = a.medianblur(12,8,8)
c = a.repair(a.repair(a.repair(a.repair(a.repair(a.rep air(a.repair(a.repair(b,1),1),1),1),1),1),1),1)
d = mt_lutxy(a,c,"x x y - abs 1.62 2 ^ / 1 1.62 / ^ 1.62 3 ^ * x y - x y - abs 1.62 + / * +",U=3,V=3)
interleave(a,d)
return(last)

Para el que sienta curiosidad del antes y despues de aplicar eso:





Si las abrís en una pestaña nueva y alternais entre pestañas se ve mas obvio.

Pero por lo visto tendría sus problemas:

This is only a torchlight, in practice things shouldn't be done that simple. A particular problem is chroma handling, which must be done different. It would be needed to isolate a saturation layer, and work on that. When done directly like in this little script, nasty things will happen. Against a green background, a grey line will turn into purple, and such.

Aunque como es de hace casi dos años quizá Didée ha avanzado algo en este tiempo ¿?

Fuente: Good sharpening method for Blu-Ray content - Doom9's Forum

Yo no soy de aplicar shaders y tal, pero me ha picado la curiosidad XD

al que le a picado es ami , que ya estoy mirando precios para la ati 7790 que me menee el compiuter pero para ser sincero no para los saders y tol rollo sino para el svp NENE GUTA FI

Didée no es partidario de ese Sharpen, prefiere otros que actuan más finos como casi todos los Shaders que han cogido sin pedir permiso a sus dueños y los han plantado en el PotPlayer a golpe de ratón, para la gente que no quiere complicarse. Curioso que los que suelen usarlos suele ser esa misma gente que detesta el Darbee por su sencillez de pulsar 2 botones o porque es un gasto innecesario teniendo un PC como reproductor.
Por eso Didée no lo ha tocado nada y porque que es imposible hacerlo andar en tiempo real, es un filtro para recodificar vídeo.

Pero por lo que ya hemos leído todos aquí seguro que hay gente que sabe más que el Gurú.
De esos que abren PotPlayer, pican en un shader precargado y se piensan que ya tienen la máquina definitiva. Y si les hace falta más nitidez, pues pican dos veces !

Me da solo a mi o en verdad os estais poniendo cansinos con el chiste de Gila , "aqui alguien a matado a alguien"

para lo que ha servido el post es para que despues de gastarme la pasta en el darbee ,me la tenga que gastar en una grafica , mira que me escape de la pintura yanky .... si es que no aprendo

Ya lo he dicho Jaiport, HTPC + Darbee son las máquinas definitivas para redescubrir al visualizador que utilices.

Iniciado por Gn0m4

Didée no es partidario de ese Sharpen, prefiere otros que actuan más finos ...

Por eso lo del FineSharp XD

Iniciado por Gn0m4

Curioso que los que suelen usarlos suele ser esa misma gente que detesta el Darbee por su sencillez de pulsar 2 botones o porque es un gasto innecesario teniendo un PC como reproductor.

Supongo que a la gente que le gusta crearse perfiles en ffdshow y aplicar shaders en función de la resolución y tal vean esto una debilidad en el Darbee (presupongo que no se puede con Darbee hacer esto).

Apunto el Darbee entre las cosas que tengo que ver junto al Backlight scanning.