Partially fix GitHub issue #110.

c-lipka · c-lipka · commit 66cef4edc238 · 2016-10-08T09:34:12.000+02:00
To allow for reading and creating fully standard-compliant PGM/PPM files, the ITU-R BT.709 transfer function can now be explicitly chosen as input and/or output gamma by specifying `gamma bt709` for input images or the `File_Gamma=bt709` INI setting for output images, respectively. (Note however that at present PGM/PPM files still default to linear encoding, in spite of the standard.) Support for the very similar but slightly superior ITU-R BT.2020 transfer function has also been added along the way using corresponding syntax. In addition, both `bt709` and `bt2020` are now valid parameters for the `assumed_gamma` global setting and the `Display_Gamma` INI setting.
diff --git a/source/base/image/colourspace.cpp b/source/base/image/colourspace.cpp
@@ -58,8 +58,9 @@ boost::mutex GammaCurve::cacheMutex;
 // definitions of static GammaCurve-derivatives' member variables to satisfy the linker
 SimpleGammaCurvePtr NeutralGammaCurve::instance;
 SimpleGammaCurvePtr SRGBGammaCurve::instance;
-GammaCurvePtr ITURBT709GammaCurve::instance;
-GammaCurvePtr Rec1361GammaCurve::instance;
+SimpleGammaCurvePtr BT709GammaCurve::instance;
+SimpleGammaCurvePtr BT1361GammaCurve::instance;
+SimpleGammaCurvePtr BT2020GammaCurve::instance;
 
 /*******************************************************************************/
 
@@ -200,53 +201,96 @@ int SRGBGammaCurve::GetTypeId() const
 
 /*******************************************************************************/
 
-ITURBT709GammaCurve::ITURBT709GammaCurve() {}
-GammaCurvePtr ITURBT709GammaCurve::Get()
+BT709GammaCurve::BT709GammaCurve() {}
+SimpleGammaCurvePtr BT709GammaCurve::Get()
 {
     if (!instance)
-        instance.reset(new ITURBT709GammaCurve());
-    return GammaCurvePtr(instance);
+        instance.reset(new BT709GammaCurve());
+    return SimpleGammaCurvePtr(instance);
 }
-float ITURBT709GammaCurve::Encode(float x) const
+float BT709GammaCurve::Encode(float x) const
 {
     if (x < 0.018f) return x * 4.5f;
     else            return 1.099f * pow(x, 0.45f) - 0.099f;
 }
-float ITURBT709GammaCurve::Decode(float x) const
+float BT709GammaCurve::Decode(float x) const
 {
+    // NB: ITU-R BT.709 does not officially specify a decoding transfer function. The following is the actual inverse
+    //     of the implemented transfer function.
     if (x < 0.081f) return x / 4.5f;
     else            return pow((x + 0.099f) / 1.099f, 1.0f/0.45f);
 }
-float ITURBT709GammaCurve::ApproximateDecodingGamma() const
+float BT709GammaCurve::ApproximateDecodingGamma() const
 {
     return 1.9f; // very rough approximation
 }
+int BT709GammaCurve::GetTypeId() const
+{
+    return kPOVList_GammaType_BT709;
+}
 
 /*******************************************************************************/
 
-Rec1361GammaCurve::Rec1361GammaCurve() {}
-GammaCurvePtr Rec1361GammaCurve::Get()
+BT1361GammaCurve::BT1361GammaCurve() {}
+SimpleGammaCurvePtr BT1361GammaCurve::Get()
 {
     if (!instance)
-        instance.reset(new Rec1361GammaCurve());
-    return GammaCurvePtr(instance);
+        instance.reset(new BT1361GammaCurve());
+    return SimpleGammaCurvePtr(instance);
 }
-float Rec1361GammaCurve::Encode(float x) const
+float BT1361GammaCurve::Encode(float x) const
 {
     if      (x < -0.0045f) return (1.099f * pow(-4*x, 0.45f) - 0.099f) / 4;
     else if (x <  0.018f)  return x * 4.5f;
     else                   return 1.099f * pow(x,0.45f) - 0.099f;
 }
-float Rec1361GammaCurve::Decode(float x) const
+float BT1361GammaCurve::Decode(float x) const
 {
     if      (x < -0.02025f) return pow((4*x + 0.099f) / 1.099f, 1.0f/0.45f) / -4;
     else if (x <  0.081f)   return x / 4.5f;
     else                    return pow((x + 0.099f) / 1.099f, 1.0f/0.45f);
 }
-float Rec1361GammaCurve::ApproximateDecodingGamma() const
+float BT1361GammaCurve::ApproximateDecodingGamma() const
 {
     return 1.9f; // very rough approximation of the x>0 section
 }
+int BT1361GammaCurve::GetTypeId() const
+{
+    return kPOVList_GammaType_BT1361;
+}
+
+/*******************************************************************************/
+
+BT2020GammaCurve::BT2020GammaCurve() {}
+SimpleGammaCurvePtr BT2020GammaCurve::Get()
+{
+    if (!instance)
+        instance.reset(new BT2020GammaCurve());
+    return SimpleGammaCurvePtr(instance);
+}
+float BT2020GammaCurve::Encode(float x) const
+{
+    // NB: We're using higher-precision coefficients than given in ITU-R BT.2020; note that this is perfectly in
+    //     accordance with the specification, as the numerical values given there are just approximations, and the
+    //     coefficients are instead defined as "the solutions to [a certain set of] simultaneous equations".
+    if (x < 0.01805396851080780734f) return x * 4.5f;
+    else                             return 1.09929682680944294035f * pow(x, 0.45f) - 0.09929682680944294035f;
+}
+float BT2020GammaCurve::Decode(float x) const
+{
+    // NB: ITU-R BT.2020 does not officially specify a decoding transfer function. The following is the actual inverse
+    //     of the implemented transfer function.
+    if (x < 0.08124285829863513301f) return x / 4.5f;
+    else                             return pow((x + 0.09929682680944294035f) / 1.09929682680944294035f, 1.0f/0.45f);
+}
+float BT2020GammaCurve::ApproximateDecodingGamma() const
+{
+    return 1.9f; // very rough approximation
+}
+int BT2020GammaCurve::GetTypeId() const
+{
+    return kPOVList_GammaType_BT2020;
+}
 
 /*******************************************************************************/
 
@@ -394,6 +438,9 @@ SimpleGammaCurvePtr GetGammaCurve(GammaTypeId type, float param)
         case kPOVList_GammaType_Neutral:    return NeutralGammaCurve::Get();
         case kPOVList_GammaType_PowerLaw:   return PowerLawGammaCurve::GetByDecodingGamma(param);
         case kPOVList_GammaType_SRGB:       return SRGBGammaCurve::Get();
+        case kPOVList_GammaType_BT709:      return BT709GammaCurve::Get();
+        case kPOVList_GammaType_BT1361:     return BT1361GammaCurve::Get();
+        case kPOVList_GammaType_BT2020:     return BT2020GammaCurve::Get();
         default:                            return PowerLawGammaCurve::GetByDecodingGamma(DEFAULT_FILE_GAMMA);
     }
 }
diff --git a/source/base/image/colourspace.h b/source/base/image/colourspace.h
@@ -463,35 +463,60 @@ class SRGBGammaCurve : public UniqueGammaCurve
 
 /// Class representing the ITU-R BT.709 transfer function.
 ///
+/// @remark The ITU-R BT.709 transfer function is identical to that defined in ITU-R BT.601.
+///
 /// @note   This class does _not_ account for the "black digital count" and "white digital count" being defined
 ///         as 16/255 and 235/255, respectively.
 ///
-class ITURBT709GammaCurve : public GammaCurve // TODO we could make this a UniqueGammaCurve if we assign it a type ID
+class BT709GammaCurve : public UniqueGammaCurve
 {
     public:
-        static GammaCurvePtr Get();
+        static SimpleGammaCurvePtr Get();
         virtual float Encode(float x) const;
         virtual float Decode(float x) const;
         virtual float ApproximateDecodingGamma() const;
+        virtual int GetTypeId() const;
     private:
-        static GammaCurvePtr instance;
-        ITURBT709GammaCurve();
+        static SimpleGammaCurvePtr instance;
+        BT709GammaCurve();
 };
 
-/// Class representing the Rec1361 transfer function.
+/// Class representing the ITU-R BT.1361 transfer function.
 ///
 /// This transfer function is a wide-gamut extension to that specified in ITU-R BT.709.
 ///
-class Rec1361GammaCurve : public GammaCurve // TODO we could make this a UniqueGammaCurve if we assign it a type ID
+class BT1361GammaCurve : public UniqueGammaCurve
 {
     public:
-        static GammaCurvePtr Get();
+        static SimpleGammaCurvePtr Get();
         virtual float Encode(float x) const;
         virtual float Decode(float x) const;
         virtual float ApproximateDecodingGamma() const;
+        virtual int GetTypeId() const;
     private:
-        static GammaCurvePtr instance;
-        Rec1361GammaCurve();
+        static SimpleGammaCurvePtr instance;
+        BT1361GammaCurve();
+};
+
+/// Class representing the ITU-R BT.2020 transfer function.
+///
+/// @remark The ITU-R BT.2020 transfer function is essentially identical to that defined in ITU-R BT.601 and BT.709,
+///         albeit using more precise constants.
+///
+/// @note   This class does _not_ account for the "black digital count" and "white digital count" being defined
+///         as 16/255 and 235/255, respectively.
+///
+class BT2020GammaCurve : public UniqueGammaCurve
+{
+    public:
+        static SimpleGammaCurvePtr Get();
+        virtual float Encode(float x) const;
+        virtual float Decode(float x) const;
+        virtual float ApproximateDecodingGamma() const;
+        virtual int GetTypeId() const;
+    private:
+        static SimpleGammaCurvePtr instance;
+        BT2020GammaCurve();
 };
 
 /// Class representing a classic constant-gamma (power-law) gamma encoding curve.
@@ -553,7 +578,10 @@ enum GammaTypeId
     kPOVList_GammaType_Unknown,
     kPOVList_GammaType_Neutral,
     kPOVList_GammaType_PowerLaw,
-    kPOVList_GammaType_SRGB
+    kPOVList_GammaType_SRGB,
+    kPOVList_GammaType_BT709,
+    kPOVList_GammaType_BT1361,  ///< Currently not exposed to the user.
+    kPOVList_GammaType_BT2020
 };
 
 /// Generic transfer function factory.
diff --git a/source/frontend/processrenderoptions.cpp b/source/frontend/processrenderoptions.cpp
@@ -1086,11 +1086,13 @@ struct ProcessRenderOptions::Output_FileType_Table FileTypeTable[] =
 struct ProcessRenderOptions::Parameter_Code_Table GammaTypeTable[] =
 {
 
-    // code,    internalId,
-    { "SRGB",   kPOVList_GammaType_SRGB },
+    // code,        internalId,
+    { "BT709",      kPOVList_GammaType_BT709 },
+    { "BT2020",     kPOVList_GammaType_BT2020 },
+    { "SRGB",       kPOVList_GammaType_SRGB },
 
     // end-of-list marker
-    { NULL,     0 }
+    { NULL,         0 }
 };
 
 /* Supported dither types */
diff --git a/source/frontend/renderfrontend.cpp b/source/frontend/renderfrontend.cpp
@@ -1147,6 +1147,12 @@ void OutputOptions(POVMS_Object& cppmsg, TextStreamBuffer *tsb)
             case kPOVList_GammaType_SRGB:
                 tsb->printf("  Graphic display......On  (gamma: sRGB)\n");
                 break;
+            case kPOVList_GammaType_BT709:
+                tsb->printf("  Graphic display......On  (gamma: ITU-R BT.709)\n");
+                break;
+            case kPOVList_GammaType_BT2020:
+                tsb->printf("  Graphic display......On  (gamma: ITU-R BT.2020)\n");
+                break;
             default:
                 throw POV_EXCEPTION_STRING("Unknown gamma mode in OutputOptions()");
         }
diff --git a/source/parser/parser_materials.cpp b/source/parser/parser_materials.cpp
@@ -505,6 +505,14 @@ SimpleGammaCurvePtr Parser::Parse_Gamma (void)
             gamma = SRGBGammaCurve::Get();
             EXIT
         END_CASE
+        CASE (BT709_TOKEN)
+            gamma = BT709GammaCurve::Get();
+            EXIT
+        END_CASE
+        CASE (BT2020_TOKEN)
+            gamma = BT2020GammaCurve::Get();
+            EXIT
+        END_CASE
         OTHERWISE
         {
             UNGET
diff --git a/source/parser/reservedwords.cpp b/source/parser/reservedwords.cpp
@@ -122,6 +122,8 @@ const RESERVED_WORD Reserved_Words[] = {
     { BRICK_SIZE_TOKEN,             "brick_size" },
     { BRIGHTNESS_TOKEN,             "brightness" },
     { BRILLIANCE_TOKEN,             "brilliance" },
+    { BT2020_TOKEN,                 "bt2020" },
+    { BT709_TOKEN,                  "bt709" },
     { BUMP_MAP_TOKEN,               "bump_map" },
     { BUMP_SIZE_TOKEN,              "bump_size" },
     { BUMPS_TOKEN,                  "bumps" },
diff --git a/source/parser/reservedwords.h b/source/parser/reservedwords.h
@@ -258,6 +258,8 @@ enum TOKEN_IDS
     BRICK_SIZE_TOKEN,
     BRIGHTNESS_TOKEN,
     BRILLIANCE_TOKEN,
+    BT2020_TOKEN,
+    BT709_TOKEN,
     BUMP_MAP_TOKEN,
     BUMP_SIZE_TOKEN,
     BUMPS_TOKEN,
