LinkBack URL
About LinkBacks
Gracias. Ese es el camino a seguir. Provarlo y despues opinar. Decir que no lo hace, sin mas, no sirve.Iniciado por onizuka26
Re: Darbee Video Procesador
1.- Claro que es el camino a seguir.
2.- He visto que han puesto una foto donde baseq2 puso unas cartulinas
para comprobar si había mejoras.
Para esto estamos en los foros,asi aprendemos unos de otros.
3.- Yo mismo he cambiado mi configuración del pot player,no hay color con
los 3 pixels shaders que tengo configurados ahora.
Otra cosa,os dejo este hilo donde vereís cómo ganar contraste en una pantalla hum,
añadiendo al blanco satinado tinte acrilico magenta puro:
pantalla del maestro en imagen goran05 jeje
Saludos y nos vemos a la noche.....
Subwoofer HUM de 12"http://www.forodvd.com/tema/107577-s...e-12-hemiutut/
Re: Darbee Video Procesador
jajjajajaa que grande el Baseq con eso del sharpen globle troterssss!!!!! jajajjjaaaaa ya me joderíaaaa!!!!!!!
Chas gracias esta de PM eso del Sharpen!!!!!!
Re: Darbee Video Procesador
Pero vosotros leeis lo se escribe porque es eso o es que os gusta cabrear a la gente.
Ya he dicho varias veces que he probado casi todo el software de pc, escaladores, renders, postpro...
Incluido evidentemente la chusta del Potplayer y sus shaders predefinidos. Solo logré algo parecido modificando un shader que encontré por internet pero generaba muchísimo artefacto.
Creo que también he dicho que el único filtro que conozco real parecido al Darbee funciona con avisynth y no lo hace en tiempo real.
Sois peor que los crios de verdad.
Re: 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
Re: Darbee Video Procesador
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)
Re: Darbee Video Procesador
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!
Re: Darbee Video Procesador
Seguramente algún bucle está descontrolado
Pena no estar en la uni para que lo revisará algún profesor.
Re: Darbee Video Procesador
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.
Re: Darbee Video Procesador
Que i5? porque hay algunos que son una bestia parda.
Re: Darbee Video Procesador
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".
Post-resize: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; }
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).
Pre-resize: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.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; }
Podéis personalizarlos en las primeras lineas de cada código.
Re: Darbee Video Procesador
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:
Aunque como es de hace casi dos años quizá Didée ha avanzado algo en este tiempo ¿?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.
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
Re: Darbee Video Procesador
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
PHILIPH Oled 65 803
Samsung PC50C7000,
Benq W-1070
Darbee Dablet
Zidoo s9x
Popcorn Vten
Playstation 3-pa jugar
Pioneer 924 - Magnat Monitor Supreme central252,Monitor202,Sub 302 .traseros dinavoice magic s4
Re: Darbee Video Procesador
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 !
Re: Darbee Video Procesador
Haya paz...
Partiendo de la base de que no tengo ni htpc ni darbee, ni he visto ninguno de los dos funcionando, tanto los que defienden una opción como la otra tienen su punto de razón y no necesariamente los razonamientos se contradicen.
Partimos de la base que cualquiera de los métodos supone una alteración de la imagen, y que esta no esté dentro de norma. Pero no todo el mundo dispone de una sala dedicada, un procesador de señal, un proyector de 5000 euros y el equipo y conocimientos para calibrar, por lo que estas soluciones te pueden dar un plus en la percepción de la imagen que a mucha gente le guste más que la imagen original, aunque no esté en norma. Las normas sirven para homogeneizar las cosas, pero no siempre el resultado gusta a todo el mundo y a veces también se quedan obsoletas.
Que el principio de funcionamiento de los diferentes realzadores (hardware o software) sea el mismo no significa que el resultado que se obtiene con ellos sea el mismo, bien porque utilizan algoritmos distintos, bien porque la implementación del algoritmo es distinta (los algoritmos no siempre son cerrado), la parametrización, el hardware (la implementación de la salida de video simplemente puede hacer que dos tarjetas de video distintas se generen una imagen diferente).
Por poner un ejemplo absurdo y un poco exagerado todas las lavadoras hace lo mismo, metes la ropa sucia y la sacas limpia, pero el resultado aunque pueda ser similar no es el mismo el todas: ropa más limpia, menos arrugada,...
Es decir, que aunque los filtros de los diferentes software y el darbee tengan la misma funcionalidad no significa que el resultado de ambos tenga que ser exactamente el mismo, y puede ser que la imagen percibida con uno u otro sea mejor (que también habrá gustos).
Por otro lado, y aunque el resultado fuera exactamente igual, hay otros factores a tener en cuenta que pueden hacer decantarse frente a una u otra opción. Volviendo al ejemplo de las lavadoras aunque dos saquen la ropa igual de limpia hay otros factores a tener en cuenta como el consumo de agua, electricidad, desgaste de la ropa,...
En este sentido la solución de darbee tiene una ventaja indiscutible que para muchos usuarios es fundamental, la sencillez. Por lo leído es un aparato minúsculo, que consume una birria comparado con un pc, que sacas de la caja, lo conectas, configuras cuatro cosas y a funcionar, y te olvidas para siempre. Luego tiene otras desventajas, entre ellas el precio desorbitado.
Como dije al principio no he tenido la oportunidad de verlo funcionando, pero si la gente de oppo (referencia en reproductores), que algo debe saber de esto de la imagen, ha decidido integrar la solución en sus equipos es que algo tendrá (aparte del marketing).
Saludos
LUMAGEN VISION HDP video procesador
Video procesador DVDO EDGE
Permisos de publicación
Citar
