Selur's Little Message Board

macOS Montery (Version 12.7.6 (21H1320)).
Problem as in Subject title.

Steps I took:

I start Hybrid.
I go to Filtering -> (De-)Interlace/Telescene
I set the "Auto deintelacing handling" to None (to disable it)
I go to Base
Open my input file (an interlaced capture)
I go to Filtering -> (De-)Interlace/Telescene
I check "Filter View" and click the VPY FILTER icon
VSVIEWER window opens and shows both Original & Filtered videos (same as I have not applied any filters yet)
I set the "Auto deintelacing handling" to QTGMC (Vapoursynth)
change the settings to custom and change the parameters
I click the VPY FILTER icon
The VSVIEWER refreshes.

now the Original video window shows the deinterlaced video and NOT the Original.

It does not matter which filter is applied as the Original video windows always shows the Filtered video (same as the Filtered video)

See screenshots below

[attachment=3342]

[attachment=3343]

Enabled QTGMC:

[attachment=3344]

vsviewer result:

[attachment=3345]

Debug outputs in the attached archive
[attachment=3346]

I cannot attach the VPY file as I reached my maximum 5 files attachments limit

This was the script that hybrid was using above (which I could not attached)

This behaviour is correct.
Since there are a few filters which affect both sides (original/filtered).
(everything that can change the frame count or frame size)
Deinterlacing is one of these filters.
Deinterlacing (or ivtc) will be applied, if:
a. the detected scan order is not progressive
and
b. the output is not interlaced.
This is necessary to check both sides in sync. (deinterlacing, ivtc, .. can influence the frame count)

Quote:It does not matter which filter is applied as the Original video windows always shows the Filtered video (same as the Filtered video)

That is not the case here and according to the debug output you shared, the Vapoursynth script used for the preview:

Code:
# Imports

import os

import sys

import vapoursynth as vs

# getting Vapoursynth core

core = vs.core

# Import scripts folder

scriptPath = '/Applications/Hybrid.app/Contents/MacOS/vsscripts'

sys.path.insert(0, os.path.abspath(scriptPath))

# Import scripts

import havsfunc

# source: '/Users/macnb/Movies/Hybrid/Test/TRV-230E-MX-Test-Huff-06-no-crop-mask2.avi'

# current color space: YUV422P8, bit depth: 8, resolution: 720x540, fps: 25, color matrix: 470bg, yuv luminance scale: limited, scanorder: bottom field first

# Loading source using FFMS2

clip = core.ffms2.Source(source="/Users/macnb/Movies/Hybrid/Test/TRV-230E-MX-Test-Huff-06-no-crop-mask2.avi",cachefile="/private/var/folders/j_/kxqyfg3d7y91rnv_bq2bm27m0000gp/T/avi_4c259630c71c3f22630a5983223f207b_853323747.ffindex",format=vs.YUV422P8,alpha=False)

# Setting color matrix to 470bg.

clip = core.std.SetFrameProps(clip, _Matrix=5)

clip = clip if not core.text.FrameProps(clip,'_Transfer') else core.std.SetFrameProps(clip, _Transfer=5)

clip = clip if not core.text.FrameProps(clip,'_Primaries') else core.std.SetFrameProps(clip, _Primaries=5)

# Setting color range to TV (limited) range.

clip = core.std.SetFrameProp(clip=clip, prop="_ColorRange", intval=1)

# making sure frame rate is set to 25

clip = core.std.AssumeFPS(clip=clip, fpsnum=25, fpsden=1)

original = clip

# converting interlaced to half-height progressive for filtering (vsMCT) (separate fields)

clip = core.std.SeparateFields(clip, tff=False) # clip is half-height now

clipEven = clip[::2]

clipOdd = clip[1::2]

clipEven = core.std.SetFrameProp(clip=clipEven, prop="_FieldBased", intval=0)

clipOdd = core.std.SetFrameProp(clip=clipOdd, prop="_FieldBased", intval=0)

# denoising using MCTemporalDenoise

clipEven = havsfunc.MCTemporalDenoise(i=clipEven, settings="very high", ncpu=1)

# denoising using MCTemporalDenoise

clipOdd = havsfunc.MCTemporalDenoise(i=clipOdd, settings="very high", ncpu=1)

# converting progressive to interlaced for 'progressive to interlaced'

clip = core.std.Interleave([clipOdd, clipEven])

clip = core.std.DoubleWeave(clip=clip, tff=False)  # clip is full-height now

clip = core.std.SelectEvery(clip, 2, 0)

clip = core.std.SetFrameProp(clip=clip, prop="_FieldBased", intval=1)

# adjusting output color from: YUV422P8 to YUV420P8 for x264Model

original = core.resize.Bicubic(clip=original, format=vs.YUV420P8, range_s="limited")

# adjusting output color from: YUV422P8 to YUV420P8 for x264Model

clip = core.resize.Bicubic(clip=clip, format=vs.YUV420P8, range_s="limited")

original = core.text.Text(clip=original,text="Original",scale=1)

clip = core.text.Text(clip=clip,text="Filtered",scale=1)

stacked = core.std.StackHorizontal([original,clip])

# set output frame rate to 25.000fps

stacked = core.std.AssumeFPS(clip=stacked, fpsnum=25, fpsden=1)

# Output

stacked.set_output()

only applied MCTemporalDenoise to the filtered (clip) not the original version.

Cu Selur

Ps.: even if there was a bug, I wouldn't try to fix it since I don't have a the setup to create a build for such an old OS.

OK understood.

I always understood "Original" as being original and untouched, unaltered and same as the inout.
That's why I was thrown when it was rendered as deinterlaced.

Clearly the denoise filter output was not obvious in the filtered preview and I thought both windows were showing the same.
I played with more filters and now I can see the difference in both the windows.

BTW, why is the MCTemporalDenoise filter working on the EVEN & ODD fields instead of one deinterlaced field ???
i.e.:

PHP Code:
# converting interlaced to half-height progressive for filtering (vsMCT) (separate fields)
clip = core.std.SeparateFields(clip, tff=False) # clip is half-height now 

Should the QTGMC filter deinterlace first then everything else simply works on the progressive frame ?

MacNB

Selur

MacNB

MacNB