Search options

I managed to make it work but it is not a walkover
Basically : 3D blurays are not side by side or top/bottom streams but packed frames. The codec name is H264 MVC
This means that for each frame : the left picture is encoded in H264 format, whereas the right picture rebuilt from the left picture + the differential part stored apart in the same (packed) frame.
Unfortunately, ffmpeg (used by mpv, itself used by SVP transcoder) does not support H264 MVC, so the decoding process will give only 2D frames (and ignore the diff part).

To make it work, I used a tool named BD3D2MK3D : this tool is a wrapper of a set of tools (tsmuxer, mkvmerge, x264/x265 for encoding) and most of all the FRIMSource library that is able to decode H264 MVC properly.
- Decode the video and unmux it (I guess that the encoder needs to be fed then with 1 file per stream) : 1 file for video stream, 1 file per audio/subtitle streams
- The tool will generate an avisynth script file that will be used in the next step in the encoder command line : the script just grabs the left/right pictures given by the FRIMSource decoder and put them together (horizontally or vertically. I made sure to uncheck "half" because it will divide by 2 the resolutions. You will get a full HD x2 resolution stream, eg. 3840x1080

This procedure is not easy though because I had to manually modify the avisynth script to incorporate the call to SVP library: this script is located in the subfolder where all the unmuxed files are. Its name is __ENCODE_3D_MOVIE.avs
Add at script beginning (built from base.avs script in SVP4 programs folder + the generated script by SVP when using SVP transcoder) :

LoadPlugin("C:\Program Files (x86)\SVP 4\plugins64\svpflow2.dll")
stereo_type = 1
src_fps = 23.976
function interpolate(clip)
{
    input_um = clip #clip.resize.Point(format=vs.YUV420P8,dither_type="random")
    input_m = input_um
    input_m8 = input_m
    super_params     = "{scale:{up:0},gpu:1,rc:true}"
    analyse_params   = "{block:{w:8,overlap:0},main:{search:{coarse:{distance:-8,bad:{sad:2000},width:530},type:2}},refine:[{thsad:250}]}"
    smoothfps_params = "{gpuid:11,gpu_qn:1,rate:{num:11,den:5},algo:23,mask:{area:100,cover:80},scene:{mode:0}}"
    threads=3
    demo_mode=0
    nvof=1
    rife = 0
    nvof==1 ? eval("""
        smooth = SVSmoothFps_NVOF(input_m, smoothfps_params, vec_src=input_m8, mt=threads, src=input_um)
    """) : rife==1 ? eval("""
        input_rife = input_m.ConvertBits(32,fulls=false,fulld=true).ConvertToPlanarRGB(matrix="709")
        smooth = RIFE(input_rife,factor_num=rife_num,factor_den=rife_den,model_path=rife_mpath,gpu_id=rife_gpu,gpu_thread=rife_threads,sc=rife_sc,sc_threshold=rife_scth,yv12=input_m8)
        smooth = smooth.ConvertToYUV420(matrix="709").ConvertBits(input_um.BitsPerComponent)
        smooth = SVSmoothFps_RIFE(input_m, smoothfps_params, rife_out=smooth, vec_src=vec_src, src=input_um, mt=threads)
    """) : eval("""
        super = SVSuper(input_m8, super_params)
        vectors = SVAnalyse(super, analyse_params, src=input_m8)
        smooth = SVSmoothFps(input_m, super, vectors, smoothfps_params, mt=threads, src=input_um)
    """)

    return demo_mode==0 ? smooth : demo(input_m,smooth)
}

And at the end of the script : quote or delete this line"Return(last)#.Info()" and replace with :

input=last


    stereo_type==0 ? eval(""" interpolate(input)
""") :     stereo_type==1 ? eval("""
        lf = interpolate(input.crop(0,0,input.width/2,0))
        rf = interpolate(input.crop(input.width/2,0,0,0))
        StackHorizontal(lf, rf)
""") :     stereo_type==2 ? Eval("""
        lf = interpolate(input.crop(0,0,0,input.height/2))
        rf = interpolate(input.crop(0,input.height/2,0,0))
        StackVertical(lf, rf)""") : input

Return(input)

Now I have a MKV 3D at full resolution (2x FullHD) and smooth (60FPS in my case) that I can ready with my 3D projector (I used Zidoo device for playback)
No need to plug my PC anymore and configure MPC-BE for smooth 3D playback.

This procedure should be industrialized, I will see if I can put my hand on this tool and upgrade it with SVP options

I don't use RIFE engine. I just selected in SVP options GPU acceleration on Nvidia + optical flow enabled instead of my integrated Intel GPU.
Also check that HDR is enabled in windows. I have Windows 11 and the native windows player render the video correctly
At least this one : http://media.developer.dolby.com/DolbyV … 00kbps.mp4
OK with MPV / native windows player (which relies on windows media foundation not directshow so not compatible with SVP)
Purplish with VLC, MPC-HC, MPC-BE

and wether I play it on a HDR screen (integrated laptop panel) or a dolby vision Oled TV

You can check the colorspace and output info by pressing "I" while playing the video from MPV
I can see that I have bt2020 output for instance

Hi, great news it works great with MPV
I have a couple of questions though :
1/ Is this real dolby vision decoding and converted on the fly to standard hdr with preserved dynamic metadata ? because the previous solution with madvr wasn't able to decode dolby vision, it was "just" an hdr optimization with frame by frame analysis and static hdr metadata. Also full dolby vision support requires an additional hevc decoder to decode the FEL layer (full enhancement layer) but very few movies carry it.
2/ Is MPC-HC compatible with this solution ? I have read that it requires to use the new libplacebo from ffmpeg

EDIT : I don't understand the use of it. From the reddit post "So the special DV/HDR10+ dynamic scene by scene metadata will get lost/ignored, but i'm not even sure those are used much outside of testfiles?". It is just a fallback solution to avoid purple colors with tone mapping on dolby vision video files that don't carry a HDR10 fallback stream, but the guy from the post may have misunderstood

Hi,
thanks for these precisions however can you confirm that a dedicated GPU is necessary for 4K (not the iGPU) ?
My 4K videos stutter with my 10th Core i7 CPU and Intel UHD graphics but this may be due to my laptop architecture with the integrated panel. I'll make a test by plugging the laptop to the TV and forcing the intel GPU in the video decoder + in SVP

EDIT : I made the test => Core I7 10th gen CPU+iGPU is not enough for 4K 60FPS
So a dedicated GPU is necessary such as a RTX 2060 or maybe less

Hi,
you don't have HDR display ? in that case madvr does a good job to convert HDR to SDR.
My settings with a gigabyte oled laptop with core I7 10875 + nvidia RTX 2070. I don't get more than 35% CPU and GPU usage with a 4K bluray rip with HDR output.

SVP settings
- GPU acceleration with Nvidia + Optical flow enabled
- Additional options : 10 bits output to "Always"
- Number of frames : I set to match to screen refresh rate (I have a projector running at 60Hz only)
- Disabled remove black borders

Player : MPC-BE is the best, better performance and quality than mpv/vlc and the most fluid for HD/4K and also 3D blurays. MPC-HC is okay too but discontinued
- Settings / video : madVR
- Settings / internal filters / Video decoder : you can use internal MPC decoder or add external filter. I used external LAV filters with D3D11 hardware decoder + Nvidia card selected (necessary to enable copy-back)
- Settings / external filters : LAV audio & video decoders added (optional)+ avisynth filter (mandatory to make SVP work, especially with HDR). Remove FFDShow if present

MadVR
- devices / <your monitor> : I ticked "passthrough HDR to display"
- scaling algorithms / chroma upscaling + image downscaling + image upscaling : Jinc seems to be the best compromise, or try NGU maybe

Notes :
- I noticed that SVP does not work correctly with my laptop monitor, it stutters a lot. Once I plug my OLED TV or projector it works like a charm.
- 4K blurays played from my optical player won't play flawlessly with SVP. I have to rip them first (no reencoding, just a copy as mkv)
- you can also set up kodi with an external player configured to MPC-BE, it works well with a bluetooth remote control

Hi again,

I took a look on MPV & ffmpeg code : so actually (these are my assertions, I may be wrong)
1/ ffmpeg team is working on passing through HDR metadata (static & dynamic HDR10+/DV) to the encoder (h264/hevc) : https://trac.ffmpeg.org/ticket/7037
As long as this won't be achieved, it won't be possible to transcode with SVP while keeping HDR data (although 10 bits colors encoding is working). They seem to be almost there
2/ Adapt MPV code in the command line arguments to input the right parameters to ffmpeg : this is the easy part once ffmpeg will have done the job

Another approach is to extract and then reinject HDR data in the final file as NVEnC does (open source nvidia encoder) or else ffmpeg + Fastflix tool to reinject https://github.com/cdgriffith/FastFlix/ … /tag/3.4.0