Blackmagic Forum

I'm trying to learn how to work with BMCC RAW files in Fusion which should be a no-brainer, right?

So, the User Manual describes it on page 64 like this:

To convert an Cinema DNG file into linear color space
1. In the Flow Node Editor, select the Loader for the image
2. In the Control Panel, click the Format tab
3. Click the disclosure triangle for the Source Gama Space
4. Enable the Remove curve checkbox.

First, the only checkbox with "Remove curve" I could find is on the Import tab and clicking on that doesn't provide any wanted result whatsoever. The image is still saturated and it has even more contrast than without the removed curve.

Second, I notice in the Format tab of the Loader that there is no actual "BMD Film" color space available, like we have one in Resolve. Is the color space the actual problem to begin with?

I'm lost.

BTW, "an Cinema DNG file" is not right... it can't be... right?

Yeah, disregard that whole section.

Chad Capeland wrote:Yeah, disregard that whole section.

And then what?

Head into resolve, import the Sequence, develop the RAW into linear space, render it out as EXR

I'd not work with RAW inside of a comper if I can get around it.

Rick Griffo wrote:Head into resolve, import the Sequence, develop the RAW into linear space, render it out as EXR

I'd not work with RAW inside of a comper if I can get around it.

I'm trying to preserve as much data as possible and to keep a manageable workflow. Is this the only way?

Currently yes, and it will preserve all the data.

If you image is DNG, make your timeline in resolve LOG, select color managed in prefs, set output to Linear, and then render as EXR format from the delivery page. This is the ONLY way.

Do not covert to a DPX log, as there is not conversion curve in fusion, and our DNG support is not the same as Resolve, so you don't want to use fusion at all for DNG right now.

Thanks for your replies! But let me rewind back a bit to my intentions.

I'm working on a project that was entirely shot on the BMCC. Here's the workflow I'm going for:

1. I've applied some color correction and a preliminary grade in Resolve just to get things moving for the edit (using Premiere CC with DNxHR for that).
2. I finished the cut for a teaser and now I'm preparing to do some clean-ups and VFX. I figured I should give Fusion a try.
3. I'd like to use the ungraded LOG footage coming out of the camera and use the exact preliminary grade (via LUT) in Fusion for reference when doing the work.
4. Then, get back to Resolve, work on the final grade, export it again via LUT and use it in Fusion for tweaks and the final render.
5. And, finally, get the footage back to Premiere and render out the final clip.

I realize now that there's basically no way to use the ungraded flat CinemaDNG footage directly in Fusion. But, if I'm exporting Linear from Resolve, is there a way to go Lin to Log and apply the LUT to get the exact grade for reference?

Or... would you recommend a completely different workflow?

Two options:

Export a 3D LUT to use in Fusion. That can include the lin-log covnversion and grade.

Render linear out of Fusion and do the lin-log in whatever application you did the original grade on.

After exrs are outputed and loaded into fusion do you suggest to work in linear and all the nodes should be placed before the gamut tool that convers from linear to srgb and the ociofile transform with lut from resolve, but viewed through them constantly to see how will look the outputted image from fusion in resolve, correct? I mean if on the other hand I set in resolve the output color space to bmcd4k film and export the exrs and load into fusion that would not be right, right?

Octavian Mot wrote:I realize now that there's basically no way to use the ungraded flat CinemaDNG footage directly in Fusion. But, if I'm exporting Linear from Resolve, is there a way to go Lin to Log and apply the LUT to get the exact grade for reference?

Well, first off you have to take a step back to look at it a bit differently I'd suggest.
There is no "ungraded, flat CinemaDNG footage" - your CinemaDNGs are a RAW sequence, not your typical ungraded, flat footage. It can become this ungraded flat footage, but you have to develop the RAW so it will be like that.
There'd essentialy no big reason to develop the RAW in Fusion, even if it was the same result as in DaVinci, except that it gets slower. Of course you can get "more" out of the RAW directly, but that doesn't always (read as: very seldom) make sense inside your compositing application.

Your basic idea isn't bad though, so I don't see why you don't do it exacly like that?

-> Go into Resolve, develop the RAW the ungraded, flat images that you used for the Proxy files, and export them into an uncompressed format as suggested before (because there's nothing more to preserve than that, after all)
-> Export a 3D LUT of your Grade inside of Resolve
-> Load the Footage into Fusion, and apply the LUT (at the end of the tree! So you can always disable it and nothing changes!)

The problem with going lin-log inside of Fusion is that the 3D Linear->BMDFilm LUT that shippes with Resolve doesn't work in Fusion (I made a topic about that a long time ago), so you could only convert it to AlexaV3LogC, Cineon, sLog or whatev.

Rick Griffo wrote:-> Export a 3D LUT of your Grade inside of Resolve
-> Load the Footage into Fusion, and apply the LUT (at the end of the tree! So you can always disable it and nothing changes!)

no need to use apply the LUT at the end of the tree in any form, besides if you want to render already with this LUT "burned" into your image.
i would suggest to use the LUT as a viewer LUT, so you can see the Image with the LUT on any node not just at the end.

So you guys are saying that it's not absolutely important to export Linear from Resolve for VFX, right?

The only important thing when loading footage into Fusion is the format of the file (EXR for no data loss, but it can might as well be DNxHR, Prores or others - depending on how much data you need), if I got it right.

michael vorberg wrote:no need to use apply the LUT at the end of the tree in any form, besides if you want to render already with this LUT "burned" into your image.
i would suggest to use the LUT as a viewer LUT, so you can see the Image with the LUT on any node not just at the end.

Michael, where is it that you apply the final LUT in your workflow, if not in the compositing software? Are you sending the ungraded footage back to the colorist or to the editor?

You don't have to do linear footage, but you would need a LUT to make it linear. So you might as well save a step and work linear.

DNxHR will, at best, give you 12 bit, which isn't enough for linear images, and for the BMCC, it won't work because it doesn't support the 2.5K resolution.

Chad Capeland wrote:DNxHR will, at best, give you 12 bit, which isn't enough for linear images, and for the BMCC, it won't work because it doesn't support the 2.5K resolution.

DNxHR is resolution independent like Prores, you think of DNxHR.

If the reason for DNGs inside of Fusion really is that you don't want any loss, don't think about lossy formats. And if you do DNxHR, do the 444 version...

While I'm also a friend of working linear inside of applications, there's no need for that if you are more comfortable with the log-footage. Additional issue is that the LUTs you'd need are not compatible with Fusion... one reason I suggested the log footage, as you can't apply the grade-LUT over the linear if you want the same result.
It's a pain that BMD didn't made the LUTs compatible (not even talking about the LINLOG Node) after 1,5 years ...

@Michael
sure you can apply it as Viewer LUT, I'm not a big fan of that inside of Fusion though. But surely is the more conveniant way

You can't work in Fusion in log, though. Doesn't work. So while you could load log footage and apply a LUT to convert to linear, it doesn't really save you anything unless you were absolutely stuck on doing a 12-bit file.

You can make a LUT that converts any global color grade from Resolve into Fusion. That's what the 3D LUT images are there for. They support anything. You only have to do it once, too, so it's not even that onerous.

You can make a LUT that converts any global color grade from Resolve into Fusion.

Yet if the grade was done on the LOG material in Fusion, it gets tricky if Fusion doesn't work with the LOG.

However, how do you mean that anyway, it doesn't work with the LOG? There's of course room for discussion if you should do that, but importing a clip in LOG and working on that is nothing impossible or do I get you wrong?

It's no more wrong than working in CMKY instead of RGBA. You can do it, but it won't work. I guess it's a matter of defining what "work" means. Can you load, crop, and save? Sure. Can you do anything else? Not correctly.

You can grade log footage and make a LUT that you can apply to linear footage. Just need to include the lin-log in the LUT, which is perfectly valid and has no impact on accuracy or speed.

"not correctly" - yes, that's it. I don't say you should do that, but to say it wouldn't work... since a few years people working directly on LOG without proper linearization and bring that into cinema, saying it wouldn't work sounds a bit harsh
After all mostly people grade directly on LOG instead of converting it before, works as you want, question is if it makes sense.

The lin-log LUT from Resolve won't work in Fusion, and so far at least I didn't found a way to convert it properly... if you find a great way, please share, was discussed already in this forum

Well, for grading, you can work with linear tools on log footage and there's nothing wrong at all, other than the definitions of "midtone" and such are way off. But the math works fine.

For compositing and for many filters, though, you need to be in linear or it will be mathmatically wrong.

Any (and I mean any) globally applied LUT can be used if Fusion if the application generating it can handle the file size of the LUT Cube image. Just use the LUT Cube Apply and you don't have to worry about what "format" the LUT is in.

So it's mathematically wrong, so what? what gives if you like the result?

Again, I wouldn't recommend that and coming from Nuke I don't find Fusion too pleasing in this regard, however, it doesn't matter in the end if math is right or wrong, as long as it works out for you.
Imagine you had a grade that looked like LOG footage and you had to work on the "graded" material - would work just as well the program is capable of it, it doesn't crash or anything

Any (and I mean any) globally applied LUT can be used if Fusion if the application generating it can handle the file size of the LUT Cube image. Just use the LUT Cube Apply and you don't have to worry about what "format" the LUT is in.

My workflow was
->creating a LUT Cube, exporting it as EXR
->applying the LUT in DaVinci Resolve
->exporting as EXR, RGB half uncompressed, Source Res
->importing into Fusion, LUT Cube Analyzer behind it, save out as .3dl
->import Footage in LOG
->hook up File LUT node to apply the .3dl LUT

Is that a wrong workflow?

Rick Griffo wrote:So it's mathematically wrong, so what? what gives if you like the result?

Again, I wouldn't recommend that and coming from Nuke I don't find Fusion too pleasing in this regard, however, it doesn't matter in the end if math is right or wrong, as long as it works out for you.
Imagine you had a grade that looked like LOG footage and you had to work on the "graded" material - would work just as well the program is capable of it, it doesn't crash or anything

Depends what you are doing with it. Log is basically useless on it's own. You don't have a log monitor or projector, right? The image might not displayed as linear, but it's likely going to be Rec.709 or DCI P3 or something, right? And when that conversion process happens, the footage will be incorrect mathmatically. Meaning physically implausible. Is it subjective? Sure. But if you have a bad rolloff on some colors in shadows in a way that is physically implausible and you have no way to fix it, then yeah, it's generally speaking wrong.

If you graded your log footage to LOOK linear, then you'd have something that worked, yes, but your metadata still says it's log, so when you go to convert it to your display space it will be very wrong.

Here's a simple example. Whether you stay in log for your whole pipeline, or just convert to linear at the end, they're both worse than if you had worked in linear and stayed linear, or working in linear and then converted back to log.

Code: Select all

{
   Tools = ordered() {
      CineonLog1_2 = CineonLog {
         CtrlWZoom = false,
         Inputs = {
            Depth = Input { Value = 4, },
            LogType = Input { Value = FuID { "SonySLog", }, },
            SLogVersion = Input { Value = FuID { "SLog2", }, },
            Input = Input {
               SourceOp = "Merge1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 880, 247.5, }, },
      },
      Crop1_1 = Crop {
         Inputs = {
            XSize = Input { Value = 1920, },
            YSize = Input { Value = 1080, },
            Input = Input {
               SourceOp = "Instance_Merge1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 880, 280.5, }, },
      },
      Merge1 = Merge {
         Inputs = {
            Background = Input {
               SourceOp = "Instance_Instance_CineonLog1_2",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Instance_CineonLog1_2",
               Source = "Output",
            },
            PerformDepthMerge = Input { Value = 0, },
         },
         ViewInfo = OperatorInfo { Pos = { 660, 280.5, }, },
      },
      Instance_Instance_CineonLog1_2 = CineonLog {
         SourceOp = "Instance_CineonLog1_2",
         Inputs = {
            Input = Input {
               SourceOp = "Background1_1",
               Source = "Output",
            },
            StartEndRenderScripts = Input { },
            EffectMask = Input { },
         },
         ViewInfo = OperatorInfo { Pos = { 550, 280.5, }, },
      },
      Instance_CineonLog1_2 = CineonLog {
         SourceOp = "CineonLog1_2",
         Inputs = {
            Mode = Input { Value = 1, },
            Input = Input {
               SourceOp = "Background1",
               Source = "Output",
            },
            StartEndRenderScripts = Input { },
            EffectMask = Input { },
         },
         ViewInfo = OperatorInfo { Pos = { 550, 214.5, }, },
      },
      Crop1 = Crop {
         Inputs = {
            XSize = Input { Value = 1920, },
            YSize = Input { Value = 1080, },
            Input = Input {
               SourceOp = "Merge1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 880, 379.5, }, },
      },
      Instance_Merge1 = Merge {
         SourceOp = "Merge1",
         Inputs = {
            Background = Input {
               SourceOp = "Background1_1",
               Source = "Output",
            },
            Foreground = Input {
               SourceOp = "Background1",
               Source = "Output",
            },
            ReferenceSize = Input { },
            StartEndRenderScripts = Input { },
            EffectMask = Input { },
         },
         ViewInfo = OperatorInfo { Pos = { 660, 379.5, }, },
      },
      Instance_CineonLog1_3 = CineonLog {
         CtrlWZoom = false,
         Inputs = {
            Depth = Input { Value = 4, },
            Mode = Input { Value = 1, },
            LogType = Input { Value = FuID { "SonySLog", }, },
            SLogVersion = Input { Value = FuID { "SLog2", }, },
            Input = Input {
               SourceOp = "Instance_Merge1",
               Source = "Output",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 880, 412.5, }, },
      },
      Background1_1 = Background {
         CtrlWZoom = false,
         Inputs = {
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            Depth = Input { Value = 3, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2", }, },
            Type = Input { Value = FuID { "Horizontal", }, },
            TopLeftRed = Input { Value = 1, },
            TopLeftBlue = Input { Value = 1, },
            TopRightGreen = Input { Value = 1, },
            TopRightBlue = Input { Value = 1, },
            Gradient = Input {
               Value = Gradient {
                  Colors = {
                     [0] = { 0, 0, 0, 1, },
                     [1] = { 1, 1, 1, 1, },
                  },
               },
            },
         },
         ViewInfo = OperatorInfo { Pos = { 330, 280.5, }, },
      },
      Background1 = Background {
         CurrentSettings = 2,
         CustomData = {
            Settings = {
               [1] = {
                  Tools = ordered() {
                     Background1 = Background {
                        CtrlWZoom = false,
                        CustomData = {
                        },
                        Inputs = {
                           Width = Input { Value = 1920, },
                           Height = Input { Value = 1080, },
                           Depth = Input { Value = 3, },
                           ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2", }, },
                           Type = Input { Value = FuID { "Horizontal", }, },
                           TopLeftRed = Input { Value = 1, },
                           TopLeftGreen = Input { Value = 1, },
                           TopRightBlue = Input { Value = 1, },
                           Gradient = Input {
                              Value = Gradient {
                                 Colors = {
                                    [0] = { 0, 0, 0, 1, },
                                    [1] = { 1, 1, 1, 1, },
                                 },
                              },
                           },
                           EffectMask = Input {
                              SourceOp = "Ellipse1",
                              Source = "Mask",
                           },
                        },
                        ViewInfo = OperatorInfo { Pos = { 440, 214.5, }, },
                     },
                  },
               },
            },
         },
         Inputs = {
            Width = Input { Value = 1920, },
            Height = Input { Value = 1080, },
            Depth = Input { Value = 3, },
            ["Gamut.SLogVersion"] = Input { Value = FuID { "SLog2", }, },
            TopLeftRed = Input { Value = 1, },
            TopLeftGreen = Input { Value = 1, },
            TopRightBlue = Input { Value = 1, },
            Gradient = Input {
               Value = Gradient {
                  Colors = {
                     [0] = { 0, 0, 0, 1, },
                     [1] = { 1, 1, 1, 1, },
                  },
               },
            },
            EffectMask = Input {
               SourceOp = "Ellipse1",
               Source = "Mask",
            },
         },
         ViewInfo = OperatorInfo { Pos = { 330, 214.5, }, },
      },
      Ellipse1 = EllipseMask {
         Inputs = {
            MotionBlur = Input { Value = 1, },
            Quality = Input { Value = 15, },
            ShutterAngle = Input { Value = 360, },
            SoftEdge = Input { Value = 0.0257143, },
            MaskWidth = Input { Value = 2048, },
            MaskHeight = Input { Value = 1556, },
            PixelAspect = Input { Value = { 1, 1, }, },
            ClippingMode = Input { Value = FuID { "None", }, },
            Center = Input {
               SourceOp = "Path1",
               Source = "Position",
            },
            Width = Input { Value = 0.345373492096257, },
            Height = Input { Value = 0.345373492096257, },
         },
         ViewInfo = OperatorInfo { Pos = { 220, 214.5, }, },
      },
      Path1 = PolyPath {
         DrawMode = "InsertAndModify",
         Inputs = {
            Displacement = Input {
               SourceOp = "Path1Displacement",
               Source = "Value",
            },
            PolyLine = Input {
               Value = Polyline {
                  Points = {
                     { Linear = true, LockY = true, X = -0.218508997429306, Y = 0, RX = 0.171379605826907, RY = 0, },
                     { Linear = true, LockY = true, X = 0.295629820051414, Y = 0, LX = -0.171379605826907, LY = 0, },
                  },
               },
            },
         },
      },
      Path1Displacement = BezierSpline {
         SplineColor = { Red = 255, Green = 0, Blue = 255, },
         NameSet = true,
         KeyFrames = {
            [0] = { 0, RH = { 0.666666666666667, 0.333333333333333, }, Flags = { Linear = true, LockedY = true, }, },
            [2] = { 1, LH = { 1.33333333333333, 0.666666666666667, }, Flags = { Linear = true, LockedY = true, }, },
         },
      },
   },
}

Rick Griffo wrote:My workflow was
->creating a LUT Cube, exporting it as EXR
->applying the LUT in DaVinci Resolve
->exporting as EXR, RGB half uncompressed, Source Res
->importing into Fusion, LUT Cube Analyzer behind it, save out as .3dl
->import Footage in LOG
->hook up File LUT node to apply the .3dl LUT

Is that a wrong workflow?

Where do you do the log-lin conversion?

Why should I convert it to LIN in the end? Just render it how it went in, like I would with every footage that comes in.
Of course it's not right mathematically, but

You can't work in Fusion in log, though. Doesn't work.

is just not right, it's totally possible, just not to be desired or redommended.

Where do you do the log-lin conversion?

Step two, applying the LOG2LIN LUT in Resolve (as this one doesn't work in Fusion like stated earlier). Analyzing the LUT Cube and applying it with the FileLUT should work, no? Which workflow should be used instead?

You have completely confused me! Here is the Blackmagic 4k footage. https://cudadrive.com/aR7LelnwVsVCDmiV Could you please setup a project to do it the RIGHT WAY If the conditions are to edit grade and finish in resolve and compositing the ungraded in Fusion?

Rick Griffo wrote:Why should I convert it to LIN in the end? Just render it how it went in, like I would with every footage that comes in.
Of course it's not right mathematically, but

You can't work in Fusion in log, though. Doesn't work.

is just not right, it's totally possible, just not to be desired or redommended.

It's not going to crash anything, no, but it's the wrong workflow. Before you send the footage could you resize your footage to 180x120? Could you zero out half the bits? Could you convert to polar coordinates? None of these will cause Fusion to crash, but you shouldn't do it.

Rick Griffo wrote:Step two, applying the LOG2LIN LUT in Resolve (as this one doesn't work in Fusion like stated earlier). Analyzing the LUT Cube and applying it with the FileLUT should work, no? Which workflow should be used instead?

Yes, that would work fine. The footage coming out of Fusion and back into Resolve would be linear, so you'd have to apply the reverse lookup either in Fusion before you render or in Resolve before you grade.

Chad Capeland wrote:None of these will cause Fusion to crash, but you shouldn't do it.

I think you missed the part where I said the same
But saying "won't work", well, that's a bit off.

Chad Capeland wrote:Yes, that would work fine. The footage coming out of Fusion and back into Resolve would be linear, so you'd have to apply the reverse lookup either in Fusion before you render or in Resolve before you grade.

Hm, ok, I can safely assume you never tried it? Because the LUTs you generate from this approach won't work right. Applying the LOG2LIN and then LIN2LOG deforms the image in a strange way. I guess that's because DaVinci has some issue rendering out the LUT CUbe with proper linear values.
Still, you can't do it properly inside of Fusion, unfortunately.

If Resolve can't do a log-lin conversion, that's not Fusion's fault.

I don't think I said that at any point, I just try to clear some earlier statements up

Export a 3D LUT to use in Fusion. That can include the lin-log covnversion and grade.

Which I just claim isn't possible, you can't use the LOG2LIN LUTs inside of Fusion, and would have to make the Conversion inside of DaVinci; which also means, you can't apply the Grade with a LUT there.

So either load the graded footage, or linearized; as you can't use the proper LUTs. You could of course linearize the footage with another LOG2LIN conversion, but then we are at the inaccurate workspace again.

That's why I meant the BMD needs to fix that ASAP, so that you can properly use their own cams with their own software. Updating the linlog Node in Fusion should be easy, no?

It's not just the color space. Fusion can't debayer DNGs properly.

But I'm confused as to what isn't working. Why would Resolve not be able to generate the LUT? For an interoperability standpoint, that's concerning, as users expect Resolve to handle color correctly. You're saying the LUT cube image gets mangled by Resolve? Does it handle an identity output?

I would never load RAW into a comper unless I desperately need to. Brings only headaches.
Always debayer somewhere else, with common ground. As stated in my first post here, too

Resolve utilizes a LUT itself, called BMDFilm to Linear.cube (and the other way around, and in the 4K-version, etc). This LUT won't work in Fusion, if you alter the header slightly you can load it but it gives out crap.
Resolve is able to create LUTs, too; but this function won't save out LUTs used in the process. At least not when it's only a LUT that you applied, from my experience.
So you only can get the LUT Cube Image through DaVinci, with the LUT(s) applied. Generating a LUT from that sure does work, but that generated .3dl doesn't give results as expected, unfortunately

Rick Griffo wrote:I would never load RAW into a comper unless I desperately need to. Brings only headaches.
Always debayer somewhere else, with common ground. As stated in my first post here, too

Resolve utilizes a LUT itself, called BMDFilm to Linear.cube (and the other way around, and in the 4K-version, etc). This LUT won't work in Fusion, if you alter the header slightly you can load it but it gives out crap.
Resolve is able to create LUTs, too; but this function won't save out LUTs used in the process. At least not when it's only a LUT that you applied, from my experience.
So you only can get the LUT Cube Image through DaVinci, with the LUT(s) applied. Generating a LUT from that sure does work, but that generated .3dl doesn't give results as expected, unfortunately

Loading raw is a lot faster, though. Less storage space too. There are pipelines where it makes sense to batch convert everything if you have the storage space, but Resolve can't batch convert, can it?

Do you know if it's the .3dl that is the issue, or is the cube image itself incorrect? LUTCubeApply allows you to skip the generation of the .3dl.

After playing around with footage and roundtrips I can say it's not just storage you're saving.

Color management is really a pain at least in Windows. Just try to move stuff between Resolve, Premiere and Fusion. Even if it's EXR... something somewhere just ignores something and everything gets crushed.

That's bizarre. EXR's are, by definition, linear unclamped.

Chad Capeland wrote:Loading raw is a lot faster, though. Less storage space too. There are pipelines where it makes sense to batch convert everything if you have the storage space, but Resolve can't batch convert, can it?

Resolve is really good in batch-converting stuff, rendering to indidivual sourceclips with source res etc.
We use it a lot, especially for Proxys.
Still, I never experienced RAW beeing faster to be honest. Then again, I have a fast enough RAID so read-speeds aren't an issue. I love to have some middle ground, and leave the decision how RAW should be developed to one person, not several, so no RAW unless necessary in a comp (IMHO).

Chad Capeland wrote:Do you know if it's the .3dl that is the issue, or is the cube image itself incorrect? LUTCubeApply allows you to skip the generation of the .3dl.

I have to get more precise here.

I feel like I didn't watch more carefully when I tested it lately. The LOG->LIN LUT conversion works well. The reults from a directly exported EXR from Resolve vs. the LUTCube applied in Fusion is not identical, yet very close. This is still bad, but not as bad as initially thought.
What won't work at all is the LIN->LOG LUT afterwards. Completely destroys the image. Now I tested the LUTCubeApply node, for LOG2LIN it's the same however for LIN2LOG it actually comes back to where it started! So the .3dl is broken somehow, that's good to notice.
However, what ISN'T good is that the image is clipped. I tested it with a shot of a landscape, in the EXR sequence from DaVinci the values are around 1.5 up to 2, so not too bright.
I had to remove the "Use OpenCL" Option in the LutCubeApply node, because else I god a black/green/pink mess out it. It works without it checked, but it still clips, that is really bad.

So in the end, we still can't use that approach because
-> Fusion and Resolve have different results in the conversion, so log2lin here and lin2log there would mess up
-> in this particular case we'd want a LUT of the grade at the end of the chain, which needs to be applied in LOG, which we can't transform properly without clipping

Ye gads. Can you roundtrip the cube image without doing anything else in Resolve? Then difference it in Fusion to see if Resolve is handling the EXR's correctly to begin with? Then try the same thing, only multiply the cube image by 10 before saving it out from Fusion. See if it handles clipping the same. Something is really not right here... The log-lin-log conversions don't have to be the same between Fusion and Resolve, but the application of a 3D LUT cube image had better well be or something is really screwed up somewhere.

Hi Chad,

1) I just "passed through" the LutCube Image through Resolve without touching anything, using same settings (RGB half, no compression). There is a difference between the one coming from Fusion and DaVinci, but it's around 0.0002 at max so neglectable (I guess this is because Resolve can only export 16bit EXRs or so)

2) I multiplied the Cube Image by 10 inside Fusion and applied the LUTs to it in Resolve, rendering them out again. I'm not entirely sure how I should test this now, when I apply the log2lin x10 CubeImage my demo-material clips at 5.76563, which is around the max value inside the original BMDFilm2Linear LUT.
When I apply the lin2log x10, I get a pretty bright image too but I can still see some things. However, the real bright parts (e.g. the Sky) also clips at 1.0

3) As the Log2Lin Conversion in DaVinci is also only based on a LUT, I somehow feel like the results should be the same; else it would be horrific if you don't do both conversions inside of Fusion (which I'd do anyway, but still)

In the meantime I realized something... now, please don't strangle me, but in the events of this I forgot to set the Depth for my testfile. To clarify, my comp is always set to 32bit, and the test-footage is 10bit ProresHQ from a BMCC. Still, I didn't set it to 16/32bit float like I'd usually do. When I set it to any of the float-modes, it won't clip anymore.
However, before you hit me in the face: the areas that clipped before change when I walkthrough log2lin and then lin2log again. They won't clip, but the values change. And not at a neglectable amount, the difference is at max at around 0.15 which is already clearly visible. So I messed up, yet there's still an issue somewhere.
Probably shouldn't have to say that, but applying the log2lin LUT and then the lin2log LUT inside of Resolve behaves exacly like it's meant to, it stays the same.

just to clarify the matter a bit, here are comparisons of a sample pic before and after the conversion, directly in Fusion.
Correct me if I'm wrong, but this shouldn't happen and is unusable.