Seems OK in VLC and ffplay

...later, trying again and looks good in VLC but washed out in ffplay

hevc (Main 10), yuv420p10le(tv, bt2020nc/bt2020/smpte2084)

Making a DCP and playing it back in DoM looks closer than ffmpeg but still not a very deep red on the marvel logo. Part of the problem (at least) may be a lack of colourspace conversion / tone mapping for the preview.

ffplay -vf colorspace=iall=bt2020:all=bt709 looks better.

also
ffplay -vf zscale=transfer=linear,tonemap=hable,zscale=transfer=bt709:primaries=709

The main problem here seems to be that for the preview there's no accounting for the difference in primaries between Rec 709 and Rec 2020. Since sRGB and Rec 708 use the same primaries I think we get away with this normally.

Putting in a conversion from Rec 2020 to XYZ and back to Rec 709 makes it look a lot better:

+       for (int y = 0; y < out->size().height; ++y) {
+               uint8_t* p = out->data()[0] + y * out->stride()[0];
+               for (int x = 0; x < out->size().width; ++x) {
+                       int const R = p[0];
+                       int const G = p[1];
+                       int const B = p[2];
+
+                       auto const X = R * source_to_xyz(0, 0) + G * source_to_xyz(0, 1) + B * source_to_xyz(0, 2);
+                       auto const Y = R * source_to_xyz(1, 0) + G * source_to_xyz(1, 1) + B * source_to_xyz(1, 2);
+                       auto const Z = R * source_to_xyz(2, 0) + G * source_to_xyz(2, 1) + B * source_to_xyz(2, 2);
+
+                       p[0] = std::max(0.0, std::min(255.0, X * xyz_to_dest(0, 0) + Y * xyz_to_dest(0, 1) + Z * xyz_to_dest(0, 2)));
+                       p[1] = std::max(0.0, std::min(255.0, X * xyz_to_dest(1, 0) + Y * xyz_to_dest(1, 1) + Z * xyz_to_dest(1, 2)));
+                       p[2] = std::max(0.0, std::min(255.0, X * xyz_to_dest(2, 0) + Y * xyz_to_dest(2, 1) + Z * xyz_to_dest(2, 2)));
+
+                       p += 3;
+               }
+       }

Also it looks like there is a different YUV -> RGB conversion for Rec 2020 (I don't understand why) which FFmpeg now supports but libdcp/DoM do not. I haven't managed to see a difference when using that, so either I'm doing it wrong or it's quite subtle.

We should also offer tone mapping to account for the fact that Rec 2020 is a wider gamut than DCI P3. FFmpeg has tonemap for this.

What needs doing

• DONE: support FFmpeg's Rec2020/YUV conversion SWS_CS_BT2020
• DONE: add in a video filter (I guess) to change the primaries of rec2020 to rec709/sRGB for the preview, somehow transparently
• add an option for tonemapping, to work with the preview and the DCP I guess (could maybe just be a video filter; but we need either parameters or different filters for rec2020/display and rec2020/dcp)

Try using VideoFilterGraphSet in the simple video view and an OpenGL matrix in the GL view.

This might be enough for now, it should at least make things a little better. @carl tests running

Merged at 94eff17bdb94c170d456c7dab5ad3d4c00af4b14