On va essayer : DVD vers WMV avec LimitedSharpen

[ptiJean]

Bonjour TLM,

Je suis en train de me faire un petit tutorial pour transformer un DVD en WMV, le tout avec avisynth pour appliquer le fameux LimitedSharpen2 (en post-process).

Lorsque tout sera au point, je mettrai le tutorial avec photos d'écrans des softs en ligne ici.

Le principe :
A partir d'un DVD, obtenir un seul fichier encodé en WMV9 (VBR) avec une seule piste audio (VO si possible) et les sous-titres français incrustés.
L'idée est que étant donné que celà va être du post-traitement, on peut appliquer n'importe quels algos avec avisynth, seul le temps de réencodage changera.
A priori je ne pense pas intégrer le resize dans le post-processing, mais plutôt à la relecture du WMV en temps-réel lors du visionnage final.

Softs utilisés :
DVD2AVI pour démuxer la vidéo des audios
Script avisynth pour le post-processing, dans VirtualDub Mod

J'ai fait un premier test sans audio pour voir si le principe est viable, et j'ai obtenu un fichier .wmv de très haute qualité à partir d'un .vob
Au passage on gagne en place, d'un facteur 2 à la louche.

Mais plusieurs problèmes persistent :
- Je n'ai pas encore essayé de remuxer une piste audio dans le fichier final
- La gestion des sous-titres, je n'y ai pas encore réfléchi.
- Concaténer tous les fichiers .wmv, car pour l'instant j'en ai autant que de .vob sur le DVD
- Automatiser la procédure.

Je essayer de recenser le call avisynth"de la morkitue".
Pour l'instant j'utilise celui-ci

SetMemoryMax(96)
Import("C:\Program Files\AviSynth 2.5\plugins\LimitedSharpen2.avs")
LoadPlugin("C:\Program Files\AviSynth 2.5\plugins\MaskTools.dll")
LoadPlugin("C:\Program Files\AviSynth 2.5\plugins\UnDot.dll")
LoadPlugin("C:\Program Files\AviSynth 2.5\plugins\asharp.dll")
LoadPlugin("C:\Program Files\AviSynth 2.5\plugins\aWarpSharp.dll")
LoadPlugin("C:\Program Files\AviSynth 2.5\plugins\Dnr2_for_25.dll")
LimitedSharpen2(ss_x=1,ss_y=1,Smode=4,asharpS=0.4,aWthresh=0.5)

Toute remarque est la bienvenue.
J'enrichirai ce post avec les liens vers les softs, les résultats, le tout au fur et à mesure de mes tests (je ne fais pas que ça non plus ).

Ceci restant pour le "fun", je ne compte pas faire ça pour chaque film visionné.
A+

['Z]

Juste une question : quel intérêt ? Parce que pour moi tu dégradera toujours l'image, peut importe les filtres, tu n'obtiendra jamais une meilleur image que celle d'origine, enfin je pense.

[ptiJean]

Celà fonctionne exactement sur le principe du call avisynth fait en temps-réel comme décrit en long, large et travers dans le thread "combo avisynth + ffdshow".

L'application d'algorithmes de "sharpen" et de "denoise" permettent de rendre l'image plus nette et de gommer l'éventuel fourmillement.

Au final l'image visionnée paraît plus propre et avec plus de relief et de piqué.

Nous sommes nombreux à utiliser ces algos en temps-réel lors de la lecture des DVD (grâce à avisynth et ffdshow), mais toujours dans la limite de nos machines (CPU).

L'idée présentée ici est de voir ce qu'un call avisynth "toutes options", cad avec les meilleurs algorithmes de traitement, peut donner, même chez ceux qui n'ont pas un PIV 3.2 GHz.

Mais le "réel" intérêt pour du long terme est quasi nul, on ne va pas réencoder les films à chaque fois avant de les voir, je te l'accorde.

A+

['Z]

ok je comprends mieux Mais c'est clair que c'est plus pour le fun
a+

[Lansing]

Quitte à faire des essais tu pourrais peut-être essayé le script iiP, apparement c'est ce qui se fait de mieux en post-processing, par contre il est extrêmement lent.
Pourquoi tu ne veux pas faire le resize en même temps ?

[ptiJean]

Ben je ne le trouve pas, le script iip , ni le fichier à importer, ni la syntaxe du call !
Si tu l'as, peux-tu me le donner ?

Concernant le resize :
Je me dis que de toute façon le CPU sera disponible, lors de la relecture, et aura tout le loisir d'effectuer un Lanczos 4 (par exemple), alors que si je fais le resize dans le script avisynth, le fichier .wmv encodé est beaucoup plus gros.

[cricridam]

pourquoi le choix du wmv ? as tu testé le x264 il y a de fortes chances que tu obtiennes une meilleure qualité avec la possibilité de muxer direct dans vdubmod !
Comme c'est un avi qui est créé il suffit d'extraire les sous titres avec les logs avec les couettes.
Pour le devobisateur il suffit de faire un append segment

Je pense que tu connais le fameux http://www.doom9.org ou on trouve tous ces outils

un bon tuto ou il suffit de remplacer l'xvid par x264

http://www.short-media.com/review.php?r=267&p=1

[Lansing]

Ben je ne le trouve pas, le script iip , ni le fichier à importer, ni la syntaxe du call !
Si tu l'as, peux-tu me le donner ?

Concernant le resize :
Je me dis que de toute façon le CPU sera disponible, lors de la relecture, et aura tout le loisir d'effectuer un Lanczos 4 (par exemple), alors que si je fais le resize dans le script avisynth, le fichier .wmv encodé est beaucoup plus gros.

Je te donne le script:

# iip : Integrated Image Processor, v.0.5a
#
#
# ---------------
# | It is slow. |
# ---------------
#
# New in v.0.5 :
#
# EQ [int] : Edge quality. 0=deaktivated (don't do that!!!), 1=standard (as formerly), 2=better'n'slower, 3=evenbetter'n'evenslower
# Note: when using EQ = 2|3, then it's a good idea to *DEACTIVATE* deringing in iiP (don't hit the dog twice).
#
# warp_Y, warp_UV [bool] additional Luma & Chroma Warping.
#
# Luma warping should make the picture more 'gracile' when upsizing to bigger resolution, e.g. DVD -> HDTV.
# For same resolution or downsizing, it may (?) help for sources with distorted detail. Or it may not - YMMV.
#
# Chroma warping helps on sources with bleeding colors (e.g. Enterprise: on the uniforms, the red stripes are bleeding into
# the blue cloth, which looks *very* ugly [like an aquarell that's gotten wet]. It looks much better with chroma warping.)
# On clean sources, chroma warping is a waste of CPU cycles.
#
# exborder [bool] : exclude outmost 8-pixel-border from sharpening (gradient masked)
#
# dering: old method: called with positive values for "dering"
# new method: called with negative values for "dering" (better, but slower)
#
# detail_floor [int] : was formerly hardcoded, now user-definable. default 20.
#

function Ylevels(clip clp, int a, float gamma, int b, int c, int d)
{ wicked="x "+string(a)+" - "+string(b)+" "+string(a)+" - / 1 "+string(gamma)+" / ^ "+string(d)+" "+string(c)+" - * "+string(c)+" +"
# Reminder: Yexpr = "x a - b a - / 1 gamma / ^ d c - * c +"
# return( clp.subtitle(wicked) )
return( clp.YV12LUT(Yexpr = wicked) )
}

function FineEdge( clip clp, int "div" )
{
logic( clp.DEdgeMask(0,255,0,255,"5 10 5 0 0 0 -5 -10 -5", setdivisor=true, divisor=div)
\ ,clp.DEdgeMask(0,255,0,255,"5 0 -5 10 0 -10 5 0 -5", setdivisor=true, divisor=div), "max", Y=3,U=1,V=1 )
}

function iip( clip clp,
\ int "dest_x", int "dest_y",
\ int "duststr", float "dustweight",
\ float "ss1_x", float "ss1_y",
\ int "detailcontr1", int "detailcontr2",
\ int "contr_radius", float "PixSharp",
\ float "ss2_x", float "ss2_y",
\ int "Xstren", int "Xlimit",
\ float "subpelstren", int "flatweight",
\ bool "antiflicker1", bool "antiflicker2",
\ int "protect_floor",int "protect_bias",
\ int "dering", float "dering_weight",
\ int "dering_floor", float "dering_bias",
\ int "detail_floor",
\ int "EQ", bool "exborder",
\ bool "warp_Y", bool "warp_UV",
\ string "debug",
\ int "cropx", int "cropy"
\ )
{
ox = clp.width
oy = clp.height
xcorr=(int(ox/16.0+.9999)*16)-ox
ycorr=(int(oy/ 8.0+.9999)* -oy
dest_x = default(dest_x, clp.width)
dest_y = default(dest_y, clp.height)
ss1_x = default(ss1_x, 1.414)
ss1_y = default(ss1_y, 1.414)
ss2_x = default(ss2_x, 3.5)
ss2_y = default(ss2_y, 3.5)
duststr = default(duststr, 2)
dustweight = default(dustweight, 1.0)
antiflicker1= default(antiflicker1, true)
antiflicker2= default(antiflicker2, true)
Xlimit = default(Xlimit, 255) # SS<3 ? 23 : 255
Xstren = default(Xstren, 255) # SS<3 ? 216 : 255
detailcontr1= default(detailcontr1, 104)
detailcontr2= default(detailcontr2, 208)
contr_radius= default(contr_radius, 2)
PixSharp = default(PixSharp, 0.4)
subpelstren = default(subpelstren, 1.58)
flatweight = default(flatweight, 0)
protect_floor=default(protect_floor, 0)
protect_bias= default(protect_bias, 16)
dering = default(dering, -80)
dering_floor= default(dering_floor,
dering_floor= dering<0 ? dering_floor*2 : dering_floor
dering_bias = default(dering_bias, 16)
dering_weight=default(dering_weight, 1.0)
detail_floor= default(detail_floor, 20)
EQ = default(EQ, 2)
EQ = (EQ>3) ? 3 : EQ
exborder = default(exborder, false)
warp_Y = default(warp_Y, false)
warp_UV = default(warp_UV, false)
debug = default(debug, "Mickey Mouse")
cropx = default(cropx, 40)
cropy = default(cropy, 20)

cropx=int(cropx/4)*4
cropy=int(cropy/4)*4
xx_ss1 = int(ox*ss1_x/16+.5)*16
yy_ss1 = int(oy*ss1_y/16+.5)*16
xx_ss2 = int(ox*ss2_x/16+.5)*16
yy_ss2 = int(oy*ss2_y/16+.5)*16
xx_small = int(ox/(abs(dering)/80+1.0)/16+.5)*16 + 32
yy_small = int(oy/(abs(dering)/80+1.0)/16+.5)*16 + 16

# Now I have the other idea - but it's too slow, yet
clp = antiflicker1 == true ? clp.temporalsoften(2,2,3,23,2) : clp

#---------------------------------------------------------------------------------------------------------------------
# Base denoising by PixieDust
#
dusted = clp.addborders(0,0,xcorr,ycorr).converttoyuy2().PixieDust(limit=duststr).converttoyv12().crop(0,0,-xcorr,-ycorr)
dusted = (dustweight==0.0) ? clp
\ : ( dustweight<1.00 ? Overlay(clp, dusted, opacity=dustweight)
\ : dusted )

soft=dusted.bicubicresize(xx_small,yy_small,.2,.4).bicubicresize(xx_ss1,yy_ss1,1.0,.0)

#---------------------------------------------------------------------------------------------------------------------
# Build EdgeMask to protect already sharp detail from oversharpening
#
YV12subtract( dusted.sharpen(0.6).sharpen(0.6), dusted.blur(1.0).blur(1.0) )

edge00 = bicubicResize(xx_ss1,yy_ss1,-1.0,1.0)
edge0=edge00
\ .YV12LUT(Yexpr="x 128 - abs "+string(protect_floor)+" - "+string(protect_bias)+" *")
\ .deflate(Y=3,U=1,V=1).inflate(Y=3,U=1,V=1).blur(1.58)
edge00 = edge00.yv12lut(yexpr="x 128 - 2 *").expand(Y=3,U=1,V=1).blur(1.58)

#---------------------------------------------------------------------------------------------------------------------
# Build DeRing'ing Mask: +++ OLD ROUTINE +++
#
dering > 0 ? expand(Y=3,U=1,V=1) : NOP
edge1b = dering > 0
\ ? yv12subtract( expand(Y=3,U=1,V=1).blur(1.58),
\ inpand(Y=3,U=1,V=1),tol=1,wideRange=true )
\ .bicubicResize(xx_ss1,yy_ss1,-1.0,1.0)
\ .yv12LUT(Yexpr="x 128 - abs "+string(dering_floor)+" - "+string(dering_bias)+" *")
\ .deflate(Y=3,U=1,V=1).blur(1.58)
\ : last
# .Ylevels(0,3.0,255,0,255)
#---------------------------------------------------------------------------------------------------------------------
# 1st supersampling stage to perform sharpening at
#

(ss1_x > 1.0 || ss1_y > 1.0) ? dusted.Lanczosresize(xx_ss1,yy_ss1)
\ : dusted

#---------------------------------------------------------------------------------------------------------------------
# Build DeRing'ing Mask & perform dering'ing: +++ NEW ROUTINE (Pre-processor) +++
#
tmpp = string(dering_floor)
edge1b = dering < 0
\ ? yv12subtract( last, last.xsharpen(255,255),tol=1,wideRange=true )
\ .yv12lut(yexpr="x 128 - abs "+tmpp+" *")
\ .expand().inflate().expand().inflate().FineEdge(dering_bias).blur(1.58)
\ .greyscale.Ylevels(19,1.6,208,0,255)
\ : edge1b
dering < 0 ? maskedmerge( last, soft, edge1b, Y=3,U=1,V=1, useMMX=true ) : NOP

#-------- iterative sharpening, currently only 3-fold: its slow enough ... --------

temp = last
shrpcnt = 0
mskcnt = 0
shrpcnt = (PixSharp != 0) ? shrpcnt + 1 : shrpcnt
shrpcnt = (detailcontr2 != 0) ? shrpcnt + 1 : shrpcnt
shrpcnt = (detailcontr1 != 0) ? shrpcnt + 1 : shrpcnt
mskcnt = (EQ>shrpcnt) ? shrpcnt : EQ

# Stage 1 : UnsharpMasking, wide radius -----------------------
detailcontr1 != 0
\ ? unsharpmask(detailcontr1,contr_radius,0)
\ : NOP
detailcontr1 != 0 && (shrpcnt==1 || mskcnt>1 && shrpcnt>=mskcnt) && (EQ>0)
\ ? MaskedMerge(last,temp,edge0.expand.inflate.inflate, Y=3,U=1,V=1,useMMX=true)
\ : NOP
mskcnt = (detailcontr1 != 0 && (shrpcnt==1 || mskcnt>1 && shrpcnt>=mskcnt))
\ ? mskcnt - 1
\ : mskcnt
shrpcnt = detailcontr1 != 0 ? shrpcnt - 1 : shrpcnt

# Stage 2 : UnsharpMasking, small radius ----------------------
detailcontr2 != 0
\ ? unsharpmask(detailcontr2, 1,0)
\ : NOP
detailcontr2 != 0 && (shrpcnt==1 || mskcnt>1&&shrpcnt>=mskcnt) && (EQ>0)
\ ? MaskedMerge(last,temp,edge0.inflate.inflate,Y=3,U=1,V=1,useMMX=true)
\ : NOP
mskcnt = (detailcontr2 != 0 && (shrpcnt==1 || mskcnt>1&&shrpcnt>=mskcnt))
\ ? mskcnt - 1
\ : mskcnt
shrpcnt = detailcontr2 != 0 ? shrpcnt - 1 : shrpcnt

# Stage 3 : per-pixel sharpening ------------------------------
PixSharp != 0.0
\ ? sharpen( PixSharp )
\ : NOP
PixSharp != 0.0 && shrpcnt > 0 && EQ>0
\ ? MaskedMerge(last,temp,edge0, Y=3,U=1,V=1,useMMX=true)
\ : NOP
undot()

#---------------------------------------------------------------------------------------------------------------------
# DeRing'ing of sharpen'ed clip: +++ OLD ROUTINE (Post-processor) +++
#
dering > 0 ? MaskedMerge(last,last.unfilter(-dering,-dering),edge1b.bicubicresize(xx_ss1,yy_ss1),Y=3,U=1,V=1,useMMX=true)
\ : NOP

# Now I have the other idea - but it's too slow, yet
antiflicker2 == true ? temporalsoften(1,2,3,23,2) : NOP

#---------------------------------------------------------------------------------------------------------------------
# 2nd supersampling stage to perform SubPel operation & XSharpening at
#
# Notes: Luma Warping - may help for sources that are hard to get a "clean" picure from.
# - Should help making the picture a little more "gracile" when doing DVD -> HDTV upsizing

xx_ss2 != ox || yy_ss2 != oy ? LanczosResize(xx_ss2,yy_ss2) : NOP

subpelstren != 0.0 ? blur(subpelstren) : NOP

warp_Y ? awarpsharp(depth=(ss2_x+ss2_y)/2*3,thresh=0.5,blurlevel=2,cm=0) : NOP

Xstren != 0 && Xlimit !=0 ? xsharpen(Xstren,Xlimit) : NOP

LanczosResize(dest_x,dest_y).undot()

#---------------------------------------------------------------------------------------------------------------------
# Build new EdgeMask of the enhanced clip
#
edge2 = bicubicresize(int(dest_x/1.75/16+.5)*16,int(dest_y/1.75/16+.5)*16,1.0,.0)
\ .DEdgeMask(0,255,0,255,"-5 -7 -5 -7 48 -7 -5 -7 -5",Y=3,U=1,V=1,useMMX=true,setdivisor=true,divisor=1)
bordermask = blankclip(edge2,width=dest_x-16,height=dest_y-16,color=$FFFFFF)
\ .addborders(2,2,2,2,color=$8F8F8F).addborders(2,2,2,2,color=$6F6F6F)
\ .addborders(2,2,2,2,color=$202020).addborders(2,2,2,2,color=$000000)
edge2 = edge2
\ .levels( (detail_floor+int(detailcontr1/15+detailcontr2/30+PixSharp*15)), 4.0,128,flatweight,255,false)
\ .bicubicResize(dest_x,dest_y,1.0,0)
edge2 = exborder ? edge2.logic(bordermask,"min") : edge2
edge2 = edge2
\ .inflate(Y=3,U=1,V=1).inflate(Y=3,U=1,V=1)
\ .blur(1.58).greyscale()
\ .inflate(Y=3,U=1,V=1).inflate(Y=3,U=1,V=1)
\ .temporalsoften(1,63,63,255,2)

#---------------------------------------------------------------------------------------------------------------------
# Put original de-noised & not-sharpened clip into areas still appearing flat, after all that sharpening
#
MaskedMerge(dusted.lanczosresize(dest_x,dest_y),last,edge2,Y=3,U=1,V=1,useMMX=true)

#---------------------------------------------------------------------------------------------------------------------
# Chroma Warping - often useful for sources where colors are "bleeding". Superfluid for clean sources.
#
warp_UV ? MergeChroma( aWarpSharp(depth = 8.5 * (dest_x/ox + dest_y/oy), thresh=0.5, cm=1, blurlevel=2) ) : NOP

#---------------------------------------------------------------------------------------------------------------------
# Visualizations
#
debug == "dering" ? overlay(last,blankclip(last,color=$00A000),mask=edge1b.bicubicresize(dest_x,dest_y),mode="blend",opacity=dering_weight)
\ : NOP
debug == "protect" ? overlay(last,blankclip(last,color=$00A000),mask=edge0.bicubicresize(dest_x,dest_y),mode="blend",opacity=0.75)
\ : NOP
debug == "detail" ? overlay(last,blankclip(last,color=$00A000),mask=edge2.bicubicresize(dest_x,dest_y),mode="blend",opacity=0.75)
\ : NOP
debug == "compareH" ? stackhorizontal(clp.lanczosresize(dest_x,dest_y).crop(cropx,0,-cropx,-0).addborders(0,0,4,0,color=$800000).subtitle("Original"),
\ last.crop(cropx,0,-cropx,-0).subtitle("iiP") )
\ : NOP
debug == "compareV" ? stackvertical(clp.lanczosresize(dest_x,dest_y).crop(0,cropy,-0,-cropy).addborders(0,0,0,4,color=$800000).subtitle("Original"),
\ last .crop(0,cropy,-0,-cropy).subtitle("iiP") )
\ : NOP
debug == "showall" ? stackvertical( stackhorizontal( edge0 .greyscale().lanczosresize(dest_x,dest_y).crop(cropx,cropy,-cropx,-cropy)
\ .addborders(0,0,4,4,color=$800000).subtitle("Protection of sharp edges"),
\ edge1b.greyscale().lanczosresize(dest_x,dest_y).crop(cropx,cropy,-cropx,-cropy)
\ .addborders(0,0,0,4,color=$800000).subtitle("DeRing'ing") ),
\ stackhorizontal( edge2 .greyscale().lanczosresize(dest_x,dest_y).crop(cropx,cropy,-cropx,-cropy)
\ .addborders(0,0,4,0,color=$800000).subtitle("Detail areas"),
\ last .crop(cropx,cropy,-cropx,-cropy).subtitle("iiP") ) )
\ : NOP

return(last)
}

#


le call est le suivant:
SetMemoryMax(256)

Import("C:\Program File\AviSynth 2.5\plugins\IIP.avs")

LoadPlugin("C:\Program file\AviSynth 2.5\plugins\undot.dll")
LoadPlugin("C:\Program file\AviSynth 2.5\plugins\MaskTools.dll")
LoadPlugin("C:\Program file\AviSynth 2.5\plugins\WarpSharp.dll")
LoadPlugin("C:\Program file\AviSynth 2.5\plugins\LoadPluginEx.dll")
LoadPlugin("C:\Program file\AviSynth 2.5\plugins\dustv5.dll")

mpeg2source("C:\Document\video\test.d2v")

iip( dest_x= XXX, dest_y= YYY,
\ ss1_x = 1.414, ss1_y = 1.414,
\ duststr = 2, dustweight = 1.0, antiflicker1= true, antiflicker2= true,
\ detailcontr1= 104, detailcontr2 = 208, contr_radius = 2, PixSharp=0.38,
\ ss2_x = 3.5, ss2_y = 3.5,
\ Xstren = 255, Xlimit = 255,
\ subpelstren= 1.58, flatweight = 0,
\ protect_floor = 0, protect_bias = 16,
\ dering = -80, dering_weight= 1.0, dering_floor = 8, dering_bias=12,
\ detail_floor = 10, EQ = 2,
\ warp_Y = false, warp_UV = false, exborder = false,
\ debug= "protect | dering | compareH|V | showall",
\ cropx=64, cropy=32
\ )

pour le resize, chui con, j'avais "un peu" oublié la taille du fichier !

[ptiJean]

Merci !

J'ai essayé d'encoder en H264, oui c'est bien aussi.

Pour l'instant je cherche à trouver les paramètres de réencodage (WM9 et H264) pour ne pas re-dégrader l'image après avoir tellement souffert pour l'améliorer
J'ai par exemple remarqué que le paramètre de "quality" dans WM9 ne doit pas être en dessous de 90 (VBR quality 1 passe, faudrait d'ailleurs que je teste le double passe CBR)

Pour l'instant j'utilise un "simple" LimitedSharpen2 (ah si les PCHCistes m'entendaient ), une fois que la procédure sera stable, j'implémenterai le IIP.

La prochaine étape sera de bien comprendre comment extraire et remuxer l'audio et les sous-titres que je veux, puis de coller bout à bout les .vob réencodés.

A+

[aldo]

des personnes on fait ceci avec iip sur avs et doom je pense notament avec socio et didée, il serais bien de rentré en contact avec eux ils on fait de bien beau encodage dans ce style, meme en 720P
pour les soft ils en n'on utilisé plusieur, dvdrebuilder, CCE, avisynth etc...
Aldo

[ptiJean]

Oui merci, je suis en train de regarder ça.

Je me disais qu'une fois que je suis au point, je peux publier ici un petit tutorial sympathique, car sur HCFR il n'y a encore rien là dessus.

Mais c'est vraiment "just for fun"
A+

[Lansing]

J'avais oublié de préciser que didée (petit génie allemand) est l'auteur du script iip ainsi que du LimitedSharpen d'ailleurs.
Pour voir ce que ça donne, ici.

[aldo]

J'avais oublié de préciser que didée (petit génie allemand) est l'auteur du script iip ainsi que du LimitedSharpen d'ailleurs.
Pour voir ce que ça donne, ici.

a la limite un peut moins piqué et c'etait parfait, celà reste impressionnant tout de meme
Aldo

[Danam]

Mais plusieurs problèmes persistent :
- Je n'ai pas encore essayé de remuxer une piste audio dans le fichier final
- La gestion des sous-titres, je n'y ai pas encore réfléchi.
- Concaténer tous les fichiers .wmv, car pour l'instant j'en ai autant que de .vob sur le DVD
- Automatiser la procédure.

à part les sous-titres, tu ne devrais pas avoir de problème pour gérer le remux et la concaténation (enfin avec 2 fichiers ça marche, plus je ne sais pas, jamais essayé) avec virtualdubmod

mais bon c'est vraiment pour le fun ton truc, parce que vu le temps de ré-encodage nécessaire, mieux vaut le faire en direct live AMHA

amusez-vous bien

[aldo]

ptiJean au niveau des encodeur tu compte utilisé quoi?
j'ai lu par ci par là que QuEnc serais meilleur que CCE
Avisyth peut etre géré par CCE par contre pour QuEnc je ne sait pas
Aldo