[MPC] Filtre(s) Pixels shaders ...

[Seb.26]

Reclock est avant le render vidéo, et il n'est pas DirectX ... il ne peut donc pas savoir ce qui se passe "en vrai" dans le render vidéo ...

[Edit] Oui, c'est bien ce qu'il faut faire : choisir un render vidéo qui sait faire un resize avancé via shaders ( les presenters D3D inclus dans MPC, ou encore Haali-Render )

[Proline90]

Je t'aime

(Plein d'autres questions, mais je vais farfouiller un peu - sinon c'est pas drôle (?))

[Olivier C.]

Bonsoir,

Exusez-moi de vous déranger en pleine déclaration d'amour

Je remercie Seb.26 pour m'avoir gentiment aidé d'avoir modéré le sharpening du shader "sharpen complex" , donc le code est maintenant celui-ci :

Code: Tout sélectionner

sampler s0 : register(s0);
float4 p0 : register(c0);
float4 p1 : register(c1);

#define width (p0[0])
#define height (p0[1])

#define coef 0.6
#define dx (coef*p1[0])
#define dy (coef*p1[1])

float4 main( float2 tex : TEXCOORD0 ) : COLOR
{
// definition des pixels : original, flouté, corigé, final
float4 ori;
float4 flou;
float4 cori;
float4 final;

////////////////////////////////////////////////////
// récuppération de la matrice de 9 points
//   [ 1, 2 , 3 ]
//   [ 4,ori, 5 ]
//   [ 6, 7 , 8 ]

   ori = tex2D(s0, tex);
   float4 c1 = tex2D(s0, tex + float2(-dx,-dy));
   float4 c2 = tex2D(s0, tex + float2(0,-dy));
   float4 c3 = tex2D(s0, tex + float2(dx,-dy));
   float4 c4 = tex2D(s0, tex + float2(-dx,0));
   float4 c5 = tex2D(s0, tex + float2(dx,0));
   float4 c6 = tex2D(s0, tex + float2(-dx,dy));
   float4 c7 = tex2D(s0, tex + float2(0,dy));
   float4 c8 = tex2D(s0, tex + float2(dx,dy));

////////////////////////////////////////////////////
// calcul image floue (filtre gaussien)
   // pour normaliser les valeurs, il faut diviser par la somme des coef
   // 1/(1+2+1+2+4+2+1+2+1) = 1/ 16 = .0625
   flou = (c1+c3+c6+c8 + 2*(c2+c4+c5+c7)+ 4*ori)*0.0625;

// soustraction de l'image flou à l'image originale
   cori = 2*ori - flou;

////////////////////////////////////////////////////
// détection des contours
float delta1;
float delta2;
float value;

// par filtre de sobel
   // Gradient horizontal
   //   [ -1, 0 ,1 ]
   //   [ -2, 0, 2 ]
   //   [ -1, 0 ,1 ]
   delta1 =  (c3 + 2*c5 + c8)-(c1 + 2*c4 + c6);

   // Gradient vertical
   //   [ -1,- 2,-1 ]
   //   [  0,  0, 0 ]
   //   [  1,  2, 1 ]
   delta2 = (c6 + 2*c7 + c8)-(c1 + 2*c2 + c3);

   // calcul
   value = sqrt( mul(delta1,delta1) + mul(delta2,delta2) ) ;

   if( value >.3 )
   {
////////////////////////////////////////////////////
// si contour, sharpen
#define Sharpen_val0       2.0
#define Sharpen_val1       0.125
      final = ori*2 - (c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 ) * 0.125 ;
//      final= float4(1,0,0,0);
      return final;
   }
   else
   {
////////////////////////////////////////////////////
// sinon, image corrigée
      return cori;
   }
}

Ou pour ceux qui souhaitent modifier le code existant, il suffit de remplacer :

Code: Tout sélectionner

#define dx (p1[0])
#define dy (p1[1])

par :

Code: Tout sélectionner

#define coef 0.6
#define dx (coef*p1[0])
#define dy (coef*p1[1])

et jouer sur le paramètre "coef" (1 étant la valeur du shader d'origine). Perso, je le trouve un peu fort d'origine (double contours).

Je le préfère personnellement au shader "sharpen" mais à vous d'essayer et d'en juger

Encore merci à Seb.

[Seb.26]

[tobal]

Tiens Seb, on ne te voit plus dans le coin !

@+,
Xavier.

[Seb.26]

Tiens Seb, on ne te voit plus dans le coin !
@+,
Xavier.

Ouais, j'ai plus le temps ... mais je passe vous lire de temps à autre quand même ...

[jim.ro]

Hello !
Bon, j'ai eu un (très) peu de temps pour rejetter un coup d'oeil surtout que j'ai maintenant une carte vidéo plus "up-to-date" .
La première version de Sharpen complex était limité par les shader d'ou cette nouvelle version qui nécessite au moins PS_2_a ou PS_3_0 :

Code: Tout sélectionner

////////////////////////////////////////////////////
// Sharpen complex v2 (nécessite ps >=2a)
////////////////////////////////////////////////////
sampler s0 : register(s0);
float4 p0 : register(c0);
float4 p1 : register(c1);

// résolution de l'image
#define width (p0[0])
#define height (p0[1])
// "largeur" d'un pixel
#define px (p1[0])
#define py (p1[1])


////////////////////////////////////////////////////
// Paramètres
////////////////////////////////////////////////////
  // pour le calcul du flou
#define moyenne 0.6
#define dx (moyenne*px)
#define dy (moyenne*py)

#define CoefFlou 2
#define CoefOri (1+ CoefFlou)

  // pour le sharpen
#define SharpenEdge       0.2
#define Sharpen_val0       2.0
#define Sharpen_val1       (Sharpen_val0/8)


////////////////////////////////////////////////////
float4 main( float2 tex : TEXCOORD0 ) : COLOR
{
  // recup du pixel original
   float4 ori = tex2D(s0, tex); ;

////////////////////////////////////////////////////
// calcul image floue (filtre gaussien)
////////////////////////////////////////////////////
   float4 c1 = tex2D(s0, tex + float2(-dx,-dy));
   float4 c2 = tex2D(s0, tex + float2(0,-dy));
   float4 c3 = tex2D(s0, tex + float2(dx,-dy));
   float4 c4 = tex2D(s0, tex + float2(-dx,0));
   float4 c5 = tex2D(s0, tex + float2(dx,0));
   float4 c6 = tex2D(s0, tex + float2(-dx,dy));
   float4 c7 = tex2D(s0, tex + float2(0,dy));
   float4 c8 = tex2D(s0, tex + float2(dx,dy));

  // filtre gaussien
  //   [ 1, 2 , 1 ]
  //   [ 2, 4 , 2 ]
  //   [ 1, 2 , 1 ]
  // pour normaliser les valeurs, il faut diviser par la somme des coef
  // 1 / (1+2+1+2+4+2+1+2+1) = 1 / 16 = .0625
   float4 flou = (c1+c3+c6+c8 + 2*(c2+c4+c5+c7)+ 4*ori)*0.0625;

  // soustraction de l'image flou à l'image originale
   float4 cori = CoefOri*ori - CoefFlou*flou;

////////////////////////////////////////////////////
// détection des contours
////////////////////////////////////////////////////
  // récuppération des 9 voisins
  //   [ c1, c2 , c3 ]
  //   [ c4,ori , c5 ]
  //   [ c6, c7 , c8 ]
   c1 = tex2D(s0, tex + float2(-px,-py));
   c2 = tex2D(s0, tex + float2(0,-py));
   c3 = tex2D(s0, tex + float2(px,-py));
   c4 = tex2D(s0, tex + float2(-px,0));
   c5 = tex2D(s0, tex + float2(px,0));
   c6 = tex2D(s0, tex + float2(-px,py));
   c7 = tex2D(s0, tex + float2(0,py));
   c8 = tex2D(s0, tex + float2(px,py));

// par filtre de sobel
   // Gradient horizontal
   //   [ -1, 0 ,1 ]
   //   [ -2, 0, 2 ]
   //   [ -1, 0 ,1 ]
   float delta1 =  (c3 + 2*c5 + c8)-(c1 + 2*c4 + c6);

   // Gradient vertical
   //   [ -1,- 2,-1 ]
   //   [  0,  0, 0 ]
   //   [  1,  2, 1 ]
   float delta2 = (c6 + 2*c7 + c8)-(c1 + 2*c2 + c3);

   // calcul
   if( sqrt( mul(delta1,delta1) + mul(delta2,delta2) ) >SharpenEdge )
   {
////////////////////////////////////////////////////
// si contour, sharpen
      //   return  float4(1,0,0,0);
      return ori*Sharpen_val0 - (c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 ) * Sharpen_val1 ; 
   }
   else
   {
////////////////////////////////////////////////////
// sinon, image corrigée
      return cori;
   }
}

Les coeff modifiables sont bien repérés.
Vous pouvez notamment tester des valeurs pour SharpenEdge en vérifiant le résultat en enlevant les // de la ligne

Code: Tout sélectionner

return  float4(1,0,0,0);

Bon tests (sur de la HD c'est pas mal) et dites moi ce que vous en pensez
Edit : petite correction et mise en avant du PS 2a minimum !!

[svp2015]

Je viends de me mater Max Payne avec ton pixel shader et rien à dire c'est tout simplement éblouissant Quel piqué, quel relief et ce sans fourmillement, il faut que je teste avec d'autre film que j'ai déjà vu avec le premier sharpen complex mais pour l'instant que du tout bon, bravo

[tobal]

Effectivement, marche bien ce sharpen complex !
Quelles sont les diff par rapport au premier ?

@+,
Xavier.

[jim.ro]

Hello !
En fait, dans la première version, on était limité par le nombre max d'instructions des shader donc utilisation de la même matrice source pour le flou et le sharpen.
Hors pour que le flou soit "correct", il fallait moyenner les pixel voisins du pixel à traiter (d'où le 0,6dx ). Mais du coup le sharpen ne s'effectuait plus entre des pixel "réel" .
C'est ce qui est corrigé en v2 . Pour la suite, je vais pouvoir tester des algo plus "puissant" que le sobel

[tobal]

L'équivalent du deband ffdshow (gradfun2db) c'est toujours pas possible en shader ?


http://forum.doom9.org/showthread.php?t=108681&page=1

@+,
Xavier.

[AlexScan]

Je vais demander ici pour mes problèmes de tearing en VMR9 avec ma ATI 4670 puisque les spécialiste de MPC sont là , comment faire pour le supprimer ? (j'aimerai bien me faire une config avec les shaders)

J'ai essayer de cocher "Fullscreen 3D" , que dalle tout bug , Reclock marche plus et le tearing est toujours là !

[Akari]

Tu as quoi comme marque de CM et de CG ?

[AlexScan]

La CG c'est une 4670 de Powercolor modèle PCS+ et la CM je voit pas en quoi elle intervient ici ?

[Akari]

Ben... l'association ASUS en CM avec Sapphire en CG me conduit en permanence à du tearing... quoique je fasse...

C'était une piste...