RV 2024.0.1 Errors using DisplayViewTransform in ColorSpace OCIO v2.2.1

jjonahlowercase · March 6, 2024, 10:45pm

Hi!

With the introduction of OCIO v2, the output baked LUT colourspaces have been (rightfully) removed.

To mimic this behaviour in the new ODT workflow so we can view outputted PNGs/MOVs with this Display Transform baked in without changing the Display Transform in RV, I pulled this ColorSpace definition and edited it to create a ColorSpace that applies the Rec.1886 Rec.709 - Display ACES 1.0 - SDR Video View Transform to the colorspace then clips it.

  - !<ColorSpace>
    name: ACES 1.0 SDR-video (Rec709)
    aliases: [aces_to_rec709_rec1886_ala]
    family: Clipped View Output
    description: |
      ACES ACES 1.0 SDR-video for Rec.709 broadcast monitor with Rec.1886 gamma (2.4)
    isdata: false
    categories: [ file-io ]
    encoding: sdr-video
    from_scene_reference: !<GroupTransform>
      children:
        - !<DisplayViewTransform> {src: ACES2065-1, display: "Rec.1886 Rec.709 - Display", view: "ACES 1.0 - SDR Video"}
        - !<RangeTransform> {min_in_value: 0., min_out_value: 0., max_in_value: 1., max_out_value: 1.}

When using this new ColorSpace in RV the output looks as expected, however as soon as I load a second sequence of media and swap back to the original sequence with this new ColorSpace, the image turns black and I get the attached error.

ERROR: compiling program:
      with functions:  OCIO_c_ACES_1_0_SDR_video_Rec709_2_scene_linear_sourceGroup000000_tolinPipeline_0_ac6659778_0_e28f663db7deb1b4 SourcePlanarYUV ResizeDownSampleDerivative
Fragment info
-------------
0(7) : error C1038: declaration of "ocio_grading_rgbcurve_knotsOffsets_0" conflicts with previous declaration at 0
0(8) : error C1038: declaration of "ocio_grading_rgbcurve_knots_0" conflicts with previous declaration at 0(8)
0(9) : error C1038: declaration of "ocio_grading_rgbcurve_coefsOffsets_0" conflicts with previous declaration at 0
0(10) : error C1038: declaration of "ocio_grading_rgbcurve_coefs_0" conflicts with previous declaration at 0(10)
0(58) : error C1038: declaration of "ocio_grading_rgbcurve_knotsOffsets_1" conflicts with previous declaration at 
0(59) : error C1038: declaration of "ocio_grading_rgbcurve_knots_1" conflicts with previous declaration at 0(70)
0(60) : error C1038: declaration of "ocio_grading_rgbcurve_coefsOffsets_1" conflicts with previous declaration at 
0(61) : error C1038: declaration of "ocio_grading_rgbcurve_coefs_1" conflicts with previous declaration at 0(72)
ERROR: failed to compile/select GL program: ERROR: failed to select the GL program

I believe it’s something to do with the ViewTransform being loaded again and the grading information being redefined.

Steps to replicate:

Add above ColorSpace into OCIO config.
Load this ColorSpace in RV.
Load a second sequence of media
Swap between the sequences of media in the Session manager

Any help with this would be very appreciated, it’s got me scratching my head.

Cheers
Jonah

jjonahlowercase · March 6, 2024, 11:12pm

The full error is very long, so I’ve put it in a spoiler tags in this reply and the following reply for reference.

Full Error Part 1

//
// VERTEX PROGRAM
//
  1:  #version 150
  2:  
  3:  in vec2 in_Position;
  4:  uniform mat4 projMatrix, modelviewMatrix;
  5:  in vec2 in_TexCoord0;
  6:  out vec2 TexCoord0;
  7:  void main()
  8:  {
  9:      TexCoord0 = in_TexCoord0;
 10:      gl_Position = projMatrix * modelviewMatrix * vec4(in_Position, 0, 1);
 11:  }
 12:  
//
// FUNCTION: OCIO_c_ACES_1_0_SDR_video_Rec709_2_scene_linear_sourceGroup000000_tolinPipeline_0_ac66597788dfb789
//
  1:  
                                   
  2:  
  3:  
  4:  const int ocio_grading_rgbcurve_knotsOffsets_0[8] = int[8](-1, 0, -1, 0, -1, 0, 0, 15);
  5:  const float ocio_grading_rgbcurve_knots_0[15] = float[15](-2.54062366, -2.08035731, -1.62009084, -1.1598243765, 2.00766158, 2.33926654, 2.67087173, 3.00247669);
  6:  const int ocio_grading_rgbcurve_coefsOffsets_0[8] = int[8](-1, 0, -1, 0, -1, 0, 0, 42);
  7:  const float ocio_grading_rgbcurve_coefs_0[42] = float[42](0.521772683, 0.0654487088, 0.272604734, 0.12391129, -0.276004612, -0.139139131, -0.0922630876, -0.0665909499, 0., 0.480308801, 0.54055649, 0.791498125, 0.90556252, 5353615, 0.0841637775, -1.69896996, -1.58843505, -1.35350001, -1.04694998, -0.656400025, -0.221410006, 0.22814402,;
  8:  
  9:  float ocio_grading_rgbcurve_evalBSplineCurve_0f7cead4f(in int curveIdx, in float x)
 10:  {
 11:    int knotsOffs = ocio_grading_rgbcurve_knotsOffsets_0[curveIdx * 2];
 12:    int knotsCnt = ocio_grading_rgbcurve_knotsOffsets_0[curveIdx * 2 + 1];
 13:    int coefsOffs = ocio_grading_rgbcurve_coefsOffsets_0[curveIdx * 2];
 14:    int coefsCnt = ocio_grading_rgbcurve_coefsOffsets_0[curveIdx * 2 + 1];
 15:    int coefsSets = coefsCnt / 3;
 16:    if (coefsSets == 0)
 17:    {
 18:      return x;
 19:    }
 20:    float knStart = ocio_grading_rgbcurve_knots_0[knotsOffs];
 21:    float knEnd = ocio_grading_rgbcurve_knots_0[knotsOffs + knotsCnt - 1];
 22:    float knStartY = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets * 2];
 23:    float knEndY;
 24:    {
 25:      float A = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets - 1];
 26:      float B = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets * 2 - 1];
 27:      float C = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets * 3 - 1];
 28:      float kn = ocio_grading_rgbcurve_knots_0[knotsOffs + knotsCnt - 2];
 29:      float t = knEnd - kn;
 30:      knEndY = ( A * t + B ) * t + C;
 31:    }
 32:    if (x <= knStartY)
 33:    {
 34:      float B = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets];
 35:      float C = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets * 2];
 36:      return abs(B) < 1e-5 ? knStart : (x - C) / B + knStart;
 37:    }
 38:    else if (x >= knEndY)
 39:    {
 40:      float A = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets - 1];
 41:      float B = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets * 2 - 1];
 42:      float C = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets * 3 - 1];
 43:      float kn = ocio_grading_rgbcurve_knots_0[knotsOffs + knotsCnt - 2];
 44:      float t = knEnd - kn;
 45:      float slope = 2. * A * t + B;
 46:      float offs = ( A * t + B ) * t + C;
 47:      return abs(slope) < 1e-5 ? knEnd : (x - offs) / slope + knEnd;
 48:    }
 49:    int i = 0;
 50:    for (i = 0; i < knotsCnt - 2; ++i)
 51:    {
 52:      if (x < ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets * 2 + i + 1])
 53:      {
 54:        break;
 55:      }
 56:    }
 57:    float A = ocio_grading_rgbcurve_coefs_0[coefsOffs + i];
 58:    float B = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets + i];
 59:    float C = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets * 2 + i];
 60:    float kn = ocio_grading_rgbcurve_knots_0[knotsOffs + i];
 61:    float C0 = C - x;
 62:    float discrim = sqrt(B * B - 4. * A * C0);
 63:    return kn + (-2. * C0) / (discrim + B);
 64:  }
 65:  
 66:  const int ocio_grading_rgbcurve_knotsOffsets_1[8] = int[8](-1, 0, -1, 0, -1, 0, 0, 9);
 67:  const float ocio_grading_rgbcurve_knots_1[9] = float[9](-5.26017761, -3.75502753, -2.24987745, -0.744727492,
 68:  const int ocio_grading_rgbcurve_coefsOffsets_1[8] = int[8](-1, 0, -1, 0, -1, 0, 0, 24);
 69:  const float ocio_grading_rgbcurve_coefs_1[24] = float[24](0.185970441, 0.403778881, -0.0748505071, -0.185833244, 1.54999995, 0.878701687, 0.531223178, 0.182825878, 0.0918722972, -4., -3.57868838, -1.82131326, 0.681241214, 
 70:  
 71:  float ocio_grading_rgbcurve_evalBSplineCurve_1f7cead4f(in int curveIdx, in float x)
 72:  {
 73:    int knotsOffs = ocio_grading_rgbcurve_knotsOffsets_1[curveIdx * 2];
 74:    int knotsCnt = ocio_grading_rgbcurve_knotsOffsets_1[curveIdx * 2 + 1];
 75:    int coefsOffs = ocio_grading_rgbcurve_coefsOffsets_1[curveIdx * 2];
 76:    int coefsCnt = ocio_grading_rgbcurve_coefsOffsets_1[curveIdx * 2 + 1];
 77:    int coefsSets = coefsCnt / 3;
 78:    if (coefsSets == 0)
 79:    {
 80:      return x;
 81:    }
 82:    float knStart = ocio_grading_rgbcurve_knots_1[knotsOffs];
 83:    float knEnd = ocio_grading_rgbcurve_knots_1[knotsOffs + knotsCnt - 1];
 84:    float knStartY = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets * 2];
 85:    float knEndY;
 86:    {
 87:      float A = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets - 1];
 88:      float B = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets * 2 - 1];
 89:      float C = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets * 3 - 1];
 90:      float kn = ocio_grading_rgbcurve_knots_1[knotsOffs + knotsCnt - 2];
 91:      float t = knEnd - kn;
 92:      knEndY = ( A * t + B ) * t + C;
 93:    }
 94:    if (x <= knStartY)
 95:    {
 96:      float B = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets];
 97:      float C = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets * 2];
 98:      return abs(B) < 1e-5 ? knStart : (x - C) / B + knStart;
 99:    }
100:    else if (x >= knEndY)
101:    {
102:      float A = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets - 1];
103:      float B = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets * 2 - 1];
104:      float C = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets * 3 - 1];
105:      float kn = ocio_grading_rgbcurve_knots_1[knotsOffs + knotsCnt - 2];
106:      float t = knEnd - kn;
107:      float slope = 2. * A * t + B;
108:      float offs = ( A * t + B ) * t + C;
109:      return abs(slope) < 1e-5 ? knEnd : (x - offs) / slope + knEnd;
110:    }
111:    int i = 0;
112:    for (i = 0; i < knotsCnt - 2; ++i)
113:    {
114:      if (x < ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets * 2 + i + 1])
115:      {
116:        break;
117:      }
118:    }
119:    float A = ocio_grading_rgbcurve_coefs_1[coefsOffs + i];
120:    float B = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets + i];
121:    float C = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets * 2 + i];
122:    float kn = ocio_grading_rgbcurve_knots_1[knotsOffs + i];
123:    float C0 = C - x;
124:    float discrim = sqrt(B * B - 4. * A * C0);
125:    return kn + (-2. * C0) / (discrim + B);
126:  }
127:  
128:                                            
129:  
130:  vec4 OCIO_c_ACES_1_0_SDR_video_Rec709_2_scene_linear_sourceGroup000000_tolinPipeline_0_ac66597788dfb789f7cea
131:  {
132:    vec4 outColor = inPixel;
133:    
134:                           
135:    
136:    {
137:      outColor.rgb = max(vec3(0., 0., 0.), outColor.rgb);
138:      outColor.rgb = min(vec3(1., 1., 1.), outColor.rgb);
139:    }
140:    
141:                                      
142:    
143:    {
144:      vec4 gamma = vec4(2.3999999999999999, 2.3999999999999999, 2.3999999999999999, 1.);
145:      vec4 res = pow( max( vec4(0., 0., 0., 0.), outColor ), gamma );
146:      outColor.rgb = vec3(res.x, res.y, res.z);
147:      outColor.a = res.w;
148:    }
149:    
150:                            
151:    
152:    {
153:      vec4 res = vec4(outColor.rgb.r, outColor.rgb.g, outColor.rgb.b, outColor.a);
154:      vec4 tmp = res;
155:      res = mat4(0.6430371952570656, 0.05926979748114361, 0.0059599807205470666, 0., 0.31118556603888886, 0.93 0.93011614490189853, 0., 0., 0., 0., 1.) * tmp;
156:      outColor.rgb = vec3(res.x, res.y, res.z);
157:      outColor.a = res.w;
158:    }
159:    
160:                                                                
161:    
162:    {
163:      float Y = max( 1e-10, 0.27222871678091454 * outColor.rgb.r + 0.67408176581114831 * outColor.rgb.g + 0.05
164:      float Ypow_over_Y = pow( Y, 0.019264102);
165:      outColor.rgb = outColor.rgb * Ypow_over_Y;
166:    }
167:    
168:                            
169:    
170:    {
171:      vec4 res = vec4(outColor.rgb.r, outColor.rgb.g, outColor.rgb.b, outColor.a);
172:      res = vec4(47.9799995, 47.9799995, 47.9799995, 1.) * res;
173:      res = vec4(0.0199999996, 0.0199999996, 0.0199999996, -0.) + res;
174:      outColor.rgb = vec3(res.x, res.y, res.z);
175:      outColor.a = res.w;
176:    }
177:    
178:                         
179:    
180:    {
181:      outColor.rgb = max( vec3(1.17549435e-38, 1.17549435e-38, 1.17549435e-38), outColor.rgb);
182:      outColor.rgb = log(outColor.rgb) * vec3(0.434294462, 0.434294462, 0.434294462);
183:    }
184:    
185:      
186:    
187:    {
188:      outColor.rgb.r = ocio_grading_rgbcurve_evalBSplineCurve_0f7cead4f(3, outColor.rgb.r);
189:      outColor.rgb.g = ocio_grading_rgbcurve_evalBSplineCurve_0f7cead4f(3, outColor.rgb.g);
190:      outColor.rgb.b = ocio_grading_rgbcurve_evalBSplineCurve_0f7cead4f(3, outColor.rgb.b);
191:      outColor.rgb.r = ocio_grading_rgbcurve_evalBSplineCurve_0f7cead4f(0, outColor.rgb.r);
192:      outColor.rgb.g = ocio_grading_rgbcurve_evalBSplineCurve_0f7cead4f(1, outColor.rgb.g);
193:      outColor.rgb.b = ocio_grading_rgbcurve_evalBSplineCurve_0f7cead4f(2, outColor.rgb.b);
194:    }
195:    
196:                                                   
197:    
198:    {
199:      outColor.rgb.r = ocio_grading_rgbcurve_evalBSplineCurve_1f7cead4f(3, outColor.rgb.r);
200:      outColor.rgb.g = ocio_grading_rgbcurve_evalBSplineCurve_1f7cead4f(3, outColor.rgb.g);
201:      outColor.rgb.b = ocio_grading_rgbcurve_evalBSplineCurve_1f7cead4f(3, outColor.rgb.b);
202:      outColor.rgb.r = ocio_grading_rgbcurve_evalBSplineCurve_1f7cead4f(0, outColor.rgb.r);
203:      outColor.rgb.g = ocio_grading_rgbcurve_evalBSplineCurve_1f7cead4f(1, outColor.rgb.g);
204:      outColor.rgb.b = ocio_grading_rgbcurve_evalBSplineCurve_1f7cead4f(2, outColor.rgb.b);
205:    }
206:    
207:                                    
208:    
209:    {
210:      outColor.rgb = pow( vec3(10., 10., 10.), outColor.rgb);
211:    }
212:    
213:                            
214:    
215:    {
216:      vec4 res = vec4(outColor.rgb.r, outColor.rgb.g, outColor.rgb.b, outColor.a);
217:      vec4 tmp = res;
218:      res = mat4(1.0303238034676969, -0.011342863198969676, -0.011342863198969676, 0., -0.028086740241694757, 002237, 1.0394296034416644, 0., 0., 0., 0., 1.) * tmp;
219:      outColor.rgb = vec3(res.x, res.y, res.z);
220:      outColor.a = res.w;
221:    }
222:    
223:                           
224:    
225:    {
226:      outColor.rgb = max(vec3(0., 0., 0.), outColor.rgb);
227:    }
228:    
229:                            
230:    
231:    {
232:      vec4 res = vec4(outColor.rgb.r, outColor.rgb.g, outColor.rgb.b, outColor.a);
233:      vec4 tmp = res;
234:      res = mat4(0.69545224135745176, 0.044794563372037632, -0.0055258825581135443, 0., 0.14067869647029416, 058, 1.0015006722521349, 0., 0., 0., 0., 1.) * tmp;
235:      outColor.rgb = vec3(res.x, res.y, res.z);
236:      outColor.a = res.w;
237:    }
238:    
239:                           
240:    
241:    {
242:      outColor.rgb = max(vec3(0., 0., 0.), outColor.rgb);
243:    }
244:    
245:                                                             
246:    
247:    {
248:      float a = 2.0 * outColor.rgb.r - (outColor.rgb.g + outColor.rgb.b);
249:      float b = 1.7320508075688772 * (outColor.rgb.g - outColor.rgb.b);
250:      float hue = atan(b, a);
251:      float knot_coord = clamp(2. + hue * float(1.6976527), 0., 4.);
252:      int j = int(min(knot_coord, 3.));
253:      float t = knot_coord - float(j);
254:      vec4 monomials = vec4(t*t*t, t*t, t, 1.);
255:      vec4 m0 = vec4(0.25, 0., 0., 0.);
256:      vec4 m1 = vec4(-0.75, 0.75, 0.75, 0.25);
257:      vec4 m2 = vec4(0.75, -1.5, 0., 1.);
258:      vec4 m3 = vec4(-0.25, 0.75, -0.75, 0.25);
259:      vec4 coefs = mix(m0, m1, float(j == 1));
260:      coefs = mix(coefs, m2, float(j == 2));
261:      coefs = mix(coefs, m3, float(j == 3));
262:      float f_H = dot(coefs, monomials);
263:      if (f_H > 0.)
264:      {
265:        float minval = min( outColor.rgb.g, outColor.rgb.b);
266:        float ka = f_H * 0.180000007 - 1.;
267:        float kb = outColor.rgb.r - f_H * (0.0299999993 + minval) * 0.180000007;
268:        float kc = f_H * 0.0299999993 * minval * 0.180000007;
269:        outColor.rgb.r = ( -kb - sqrt( kb * kb - 4. * ka * kc)) / ( 2. * ka);
270:      }
271:    }
272:    
273:                                                           
274:    
275:    {
276:      float chroma = sqrt( outColor.rgb.b * (outColor.rgb.b - outColor.rgb.g) + outColor.rgb.g * (outColor.rgb
277:      float YC = (outColor.rgb.b + outColor.rgb.g + outColor.rgb.r + 1.75 * chroma) / 3.;
278:      float maxval = max( outColor.rgb.r, max( outColor.rgb.g, outColor.rgb.b));
279:      float minval = min( outColor.rgb.r, min( outColor.rgb.g, outColor.rgb.b));
280:      float sat = ( max(1e-10, maxval) - max(1e-10, minval) ) / max(1e-2, maxval);
281:      float x = (sat - 0.4) * 5.;
282:      float t = max( 0., 1. - 0.5 * abs(x));
283:      float s = 0.5 * (1. + sign(x) * (1. - t * t));
284:      float GlowGain = 0.0500000007 * s;
285:      float GlowMid = 0.0799999982;
286:      float glowGainOut = mix(-GlowGain / (1. + GlowGain), GlowGain * (GlowMid / YC - 0.5) / (GlowGain * 0.5 -
287:      glowGainOut = mix(glowGainOut, 0., float( YC > GlowMid * 2. ));
288:      outColor.rgb = outColor.rgb * glowGainOut + outColor.rgb;
289:    }
290:    
291:                            
292:    
293:    {
294:      vec4 res = vec4(outColor.rgb.r, outColor.rgb.g, outColor.rgb.b, outColor.a);
295:      vec4 tmp = res;
296:      res = mat4(1.4514393161456651, -0.076553773396020569, 0.008316148425697719, 0., -0.23651074689374021, 1.29, 0.99771630136532341, 0., 0., 0., 0., 1.) * tmp;
297:      outColor.rgb = vec3(res.x, res.y, res.z);
298:      outColor.a = res.w;
299:    }
300:  
301:    return outColor;
302:  }
303:

jjonahlowercase · March 6, 2024, 11:13pm

Full Error Part 2

//
// FUNCTION: OCIO_d_Rec_1886_Rec_709_Display_ACES_1_0_SDR_Video_displayGroup1_colorPipeline_0_e28f663db7deb1b4
//
  1:  
                                   
  2:  
  3:  
  4:  const int ocio_grading_rgbcurve_knotsOffsets_0[8] = int[8](-1, 0, -1, 0, -1, 0, 0, 9);
  5:  const float ocio_grading_rgbcurve_knots_0[9] = float[9](-5.26017761, -3.75502753, -2.24987745, -0.744727492,
  6:  const int ocio_grading_rgbcurve_coefsOffsets_0[8] = int[8](-1, 0, -1, 0, -1, 0, 0, 24);
  7:  const float ocio_grading_rgbcurve_coefs_0[24] = float[24](0.185970441, 0.403778881, -0.0748505071, -0.185833244, 1.54999995, 0.878701687, 0.531223178, 0.182825878, 0.0918722972, -4., -3.57868838, -1.82131326, 0.681241214, 
  8:  
  9:  float ocio_grading_rgbcurve_evalBSplineCurve_01d7a7a1(in int curveIdx, in float x)
 10:  {
 11:    int knotsOffs = ocio_grading_rgbcurve_knotsOffsets_0[curveIdx * 2];
 12:    int knotsCnt = ocio_grading_rgbcurve_knotsOffsets_0[curveIdx * 2 + 1];
 13:    int coefsOffs = ocio_grading_rgbcurve_coefsOffsets_0[curveIdx * 2];
 14:    int coefsCnt = ocio_grading_rgbcurve_coefsOffsets_0[curveIdx * 2 + 1];
 15:    int coefsSets = coefsCnt / 3;
 16:    if (coefsSets == 0)
 17:    {
 18:      return x;
 19:    }
 20:    float knStart = ocio_grading_rgbcurve_knots_0[knotsOffs];
 21:    float knEnd = ocio_grading_rgbcurve_knots_0[knotsOffs + knotsCnt - 1];
 22:    if (x <= knStart)
 23:    {
 24:      float B = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets];
 25:      float C = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets * 2];
 26:      return (x - knStart) * B + C;
 27:    }
 28:    else if (x >= knEnd)
 29:    {
 30:      float A = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets - 1];
 31:      float B = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets * 2 - 1];
 32:      float C = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets * 3 - 1];
 33:      float kn = ocio_grading_rgbcurve_knots_0[knotsOffs + knotsCnt - 2];
 34:      float t = knEnd - kn;
 35:      float slope = 2. * A * t + B;
 36:      float offs = ( A * t + B ) * t + C;
 37:      return (x - knEnd) * slope + offs;
 38:    }
 39:    int i = 0;
 40:    for (i = 0; i < knotsCnt - 2; ++i)
 41:    {
 42:      if (x < ocio_grading_rgbcurve_knots_0[knotsOffs + i + 1])
 43:      {
 44:        break;
 45:      }
 46:    }
 47:    float A = ocio_grading_rgbcurve_coefs_0[coefsOffs + i];
 48:    float B = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets + i];
 49:    float C = ocio_grading_rgbcurve_coefs_0[coefsOffs + coefsSets * 2 + i];
 50:    float kn = ocio_grading_rgbcurve_knots_0[knotsOffs + i];
 51:    float t = x - kn;
 52:    return ( A * t + B ) * t + C;
 53:  }
 54:  
 55:  const int ocio_grading_rgbcurve_knotsOffsets_1[8] = int[8](-1, 0, -1, 0, -1, 0, 0, 15);
 56:  const float ocio_grading_rgbcurve_knots_1[15] = float[15](-2.54062366, -2.08035731, -1.62009084, -1.1598243765, 2.00766158, 2.33926654, 2.67087173, 3.00247669);
 57:  const int ocio_grading_rgbcurve_coefsOffsets_1[8] = int[8](-1, 0, -1, 0, -1, 0, 0, 42);
 58:  const float ocio_grading_rgbcurve_coefs_1[42] = float[42](0.521772683, 0.0654487088, 0.272604734, 0.12391129, -0.276004612, -0.139139131, -0.0922630876, -0.0665909499, 0., 0.480308801, 0.54055649, 0.791498125, 0.90556252, 5353615, 0.0841637775, -1.69896996, -1.58843505, -1.35350001, -1.04694998, -0.656400025, -0.221410006, 0.22814402,;
 59:  
 60:  float ocio_grading_rgbcurve_evalBSplineCurve_11d7a7a1(in int curveIdx, in float x)
 61:  {
 62:    int knotsOffs = ocio_grading_rgbcurve_knotsOffsets_1[curveIdx * 2];
 63:    int knotsCnt = ocio_grading_rgbcurve_knotsOffsets_1[curveIdx * 2 + 1];
 64:    int coefsOffs = ocio_grading_rgbcurve_coefsOffsets_1[curveIdx * 2];
 65:    int coefsCnt = ocio_grading_rgbcurve_coefsOffsets_1[curveIdx * 2 + 1];
 66:    int coefsSets = coefsCnt / 3;
 67:    if (coefsSets == 0)
 68:    {
 69:      return x;
 70:    }
 71:    float knStart = ocio_grading_rgbcurve_knots_1[knotsOffs];
 72:    float knEnd = ocio_grading_rgbcurve_knots_1[knotsOffs + knotsCnt - 1];
 73:    if (x <= knStart)
 74:    {
 75:      float B = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets];
 76:      float C = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets * 2];
 77:      return (x - knStart) * B + C;
 78:    }
 79:    else if (x >= knEnd)
 80:    {
 81:      float A = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets - 1];
 82:      float B = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets * 2 - 1];
 83:      float C = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets * 3 - 1];
 84:      float kn = ocio_grading_rgbcurve_knots_1[knotsOffs + knotsCnt - 2];
 85:      float t = knEnd - kn;
 86:      float slope = 2. * A * t + B;
 87:      float offs = ( A * t + B ) * t + C;
 88:      return (x - knEnd) * slope + offs;
 89:    }
 90:    int i = 0;
 91:    for (i = 0; i < knotsCnt - 2; ++i)
 92:    {
 93:      if (x < ocio_grading_rgbcurve_knots_1[knotsOffs + i + 1])
 94:      {
 95:        break;
 96:      }
 97:    }
 98:    float A = ocio_grading_rgbcurve_coefs_1[coefsOffs + i];
 99:    float B = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets + i];
100:    float C = ocio_grading_rgbcurve_coefs_1[coefsOffs + coefsSets * 2 + i];
101:    float kn = ocio_grading_rgbcurve_knots_1[knotsOffs + i];
102:    float t = x - kn;
103:    return ( A * t + B ) * t + C;
104:  }
105:  
106:                                            
107:  
108:  vec4 OCIO_d_Rec_1886_Rec_709_Display_ACES_1_0_SDR_Video_displayGroup1_colorPipeline_0_e28f663db7deb1b41d7a7a
109:  {
110:    vec4 outColor = inPixel;
111:    
112:                            
113:    
114:    {
115:      vec4 res = vec4(outColor.rgb.r, outColor.rgb.g, outColor.rgb.b, outColor.a);
116:      vec4 tmp = res;
117:      res = mat4(0.69545224135745187, 0.044794563372037716, -0.0055258825581135443, 0., 0.14067869647029416, 0, 1.0015006722521349, 0., 0., 0., 0., 1.) * tmp;
118:      outColor.rgb = vec3(res.x, res.y, res.z);
119:      outColor.a = res.w;
120:    }
121:    
122:                                                           
123:    
124:    {
125:      float chroma = sqrt( outColor.rgb.b * (outColor.rgb.b - outColor.rgb.g) + outColor.rgb.g * (outColor.rgb
126:      float YC = (outColor.rgb.b + outColor.rgb.g + outColor.rgb.r + 1.75 * chroma) / 3.;
127:      float maxval = max( outColor.rgb.r, max( outColor.rgb.g, outColor.rgb.b));
128:      float minval = min( outColor.rgb.r, min( outColor.rgb.g, outColor.rgb.b));
129:      float sat = ( max(1e-10, maxval) - max(1e-10, minval) ) / max(1e-2, maxval);
130:      float x = (sat - 0.4) * 5.;
131:      float t = max( 0., 1. - 0.5 * abs(x));
132:      float s = 0.5 * (1. + sign(x) * (1. - t * t));
133:      float GlowGain = 0.0500000007 * s;
134:      float GlowMid = 0.0799999982;
135:      float glowGainOut = mix(GlowGain, GlowGain * (GlowMid / YC - 0.5), float( YC > GlowMid * 2. / 3. ));
136:      glowGainOut = mix(glowGainOut, 0., float( YC > GlowMid * 2. ));
137:      outColor.rgb = outColor.rgb * glowGainOut + outColor.rgb;
138:    }
139:    
140:                                                             
141:    
142:    {
143:      float a = 2.0 * outColor.rgb.r - (outColor.rgb.g + outColor.rgb.b);
144:      float b = 1.7320508075688772 * (outColor.rgb.g - outColor.rgb.b);
145:      float hue = atan(b, a);
146:      float knot_coord = clamp(2. + hue * float(1.6976527), 0., 4.);
147:      int j = int(min(knot_coord, 3.));
148:      float t = knot_coord - float(j);
149:      vec4 monomials = vec4(t*t*t, t*t, t, 1.);
150:      vec4 m0 = vec4(0.25, 0., 0., 0.);
151:      vec4 m1 = vec4(-0.75, 0.75, 0.75, 0.25);
152:      vec4 m2 = vec4(0.75, -1.5, 0., 1.);
153:      vec4 m3 = vec4(-0.25, 0.75, -0.75, 0.25);
154:      vec4 coefs = mix(m0, m1, float(j == 1));
155:      coefs = mix(coefs, m2, float(j == 2));
156:      coefs = mix(coefs, m3, float(j == 3));
157:      float f_H = dot(coefs, monomials);
158:      float maxval = max( outColor.rgb.r, max( outColor.rgb.g, outColor.rgb.b));
159:      float minval = min( outColor.rgb.r, min( outColor.rgb.g, outColor.rgb.b));
160:      float f_S = ( max(1e-10, maxval) - max(1e-10, minval) ) / max(1e-2, maxval);
161:      outColor.rgb.r = outColor.rgb.r + f_H * f_S * (0.0299999993 - outColor.rgb.r) * 0.180000007;
162:    }
163:    
164:                           
165:    
166:    {
167:      outColor.rgb = max(vec3(0., 0., 0.), outColor.rgb);
168:    }
169:    
170:                            
171:    
172:    {
173:      vec4 res = vec4(outColor.rgb.r, outColor.rgb.g, outColor.rgb.b, outColor.a);
174:      vec4 tmp = res;
175:      res = mat4(1.4514393161456653, -0.07655377339602043, 0.008316148425697719, 0., -0.23651074689374019, 1.101, 0.9977163013653233, 0., 0., 0., 0., 1.) * tmp;
176:      outColor.rgb = vec3(res.x, res.y, res.z);
177:      outColor.a = res.w;
178:    }
179:    
180:                           
181:    
182:    {
183:      outColor.rgb = max(vec3(0., 0., 0.), outColor.rgb);
184:    }
185:    
186:                            
187:    
188:    {
189:      vec4 res = vec4(outColor.rgb.r, outColor.rgb.g, outColor.rgb.b, outColor.a);
190:      vec4 tmp = res;
191:      res = mat4(0.97088914867099996, 0.010889148671, 0.010889148671, 0., 0.026963270631999998, 0.986963270631758069600004, 0., 0., 0., 0., 1.) * tmp;
192:      outColor.rgb = vec3(res.x, res.y, res.z);
193:      outColor.a = res.w;
194:    }
195:    
196:                         
197:    
198:    {
199:      outColor.rgb = max( vec3(1.17549435e-38, 1.17549435e-38, 1.17549435e-38), outColor.rgb);
200:      outColor.rgb = log(outColor.rgb) * vec3(0.434294462, 0.434294462, 0.434294462);
201:    }
202:    
203:                                                   
204:    
205:    {
206:      outColor.rgb.r = ocio_grading_rgbcurve_evalBSplineCurve_01d7a7a1(0, outColor.rgb.r);
207:      outColor.rgb.g = ocio_grading_rgbcurve_evalBSplineCurve_01d7a7a1(1, outColor.rgb.g);
208:      outColor.rgb.b = ocio_grading_rgbcurve_evalBSplineCurve_01d7a7a1(2, outColor.rgb.b);
209:      outColor.rgb.r = ocio_grading_rgbcurve_evalBSplineCurve_01d7a7a1(3, outColor.rgb.r);
210:      outColor.rgb.g = ocio_grading_rgbcurve_evalBSplineCurve_01d7a7a1(3, outColor.rgb.g);
211:      outColor.rgb.b = ocio_grading_rgbcurve_evalBSplineCurve_01d7a7a1(3, outColor.rgb.b);
212:    }
213:    
214:                                                   
215:    
216:    {
217:      outColor.rgb.r = ocio_grading_rgbcurve_evalBSplineCurve_11d7a7a1(0, outColor.rgb.r);
218:      outColor.rgb.g = ocio_grading_rgbcurve_evalBSplineCurve_11d7a7a1(1, outColor.rgb.g);
219:      outColor.rgb.b = ocio_grading_rgbcurve_evalBSplineCurve_11d7a7a1(2, outColor.rgb.b);
220:      outColor.rgb.r = ocio_grading_rgbcurve_evalBSplineCurve_11d7a7a1(3, outColor.rgb.r);
221:      outColor.rgb.g = ocio_grading_rgbcurve_evalBSplineCurve_11d7a7a1(3, outColor.rgb.g);
222:      outColor.rgb.b = ocio_grading_rgbcurve_evalBSplineCurve_11d7a7a1(3, outColor.rgb.b);
223:    }
224:    
225:                                    
226:    
227:    {
228:      outColor.rgb = pow( vec3(10., 10., 10.), outColor.rgb);
229:    }
230:    
231:                            
232:    
233:    {
234:      vec4 res = vec4(outColor.rgb.r, outColor.rgb.g, outColor.rgb.b, outColor.a);
235:      res = vec4(0.0208420176, 0.0208420176, 0.0208420176, 1.) * res;
236:      res = vec4(-0.000416840339, -0.000416840339, -0.000416840339, 0.) + res;
237:      outColor.rgb = vec3(res.x, res.y, res.z);
238:      outColor.a = res.w;
239:    }
240:    
241:                                                                
242:    
243:    {
244:      float Y = max( 1e-10, 0.27222871678091454 * outColor.rgb.r + 0.67408176581114831 * outColor.rgb.g + 0.05
245:      float Ypow_over_Y = pow( Y, -0.0188999772);
246:      outColor.rgb = outColor.rgb * Ypow_over_Y;
247:    }
248:    
249:                            
250:    
251:    {
252:      vec4 res = vec4(outColor.rgb.r, outColor.rgb.g, outColor.rgb.b, outColor.a);
253:      vec4 tmp = res;
254:      res = mat4(1.604753433346922, -0.10208245810655031, -0.0032671116532946819, 0., -0.531080948604018, 1.1088, 1.0760225357877193, 0., 0., 0., 0., 1.) * tmp;
255:      outColor.rgb = vec3(res.x, res.y, res.z);
256:      outColor.a = res.w;
257:    }
258:    
259:                                      
260:    
261:    {
262:      vec4 gamma = vec4(0.41666666666666669, 0.41666666666666669, 0.41666666666666669, 1.);
263:      vec4 res = pow( max( vec4(0., 0., 0., 0.), outColor ), gamma );
264:      outColor.rgb = vec3(res.x, res.y, res.z);
265:      outColor.a = res.w;
266:    }
267:  
268:    return outColor;
269:  }
270:  
//
// FUNCTION: SourcePlanarYUV
//
  1:    
  2:                                                             
  3:     
  4:                                         
  5:    
  6:    
  7:                                     
  8:    
  9:  
 10:                                                                        
 11:                                                                
 12:  
218:      outColor.rgb.g = ocio_grading_rgbcurve_evalBSplineCurve_11d7a7a1(1, outColor.rgb.g);
219:      outColor.rgb.b = ocio_grading_rgbcurve_evalBSplineCurve_11d7a7a1(2, outColor.rgb.b);
220:      outColor.rgb.r = ocio_grading_rgbcurve_evalBSplineCurve_11d7a7a1(3, outColor.rgb.r);
221:      outColor.rgb.g = ocio_grading_rgbcurve_evalBSplineCurve_11d7a7a1(3, outColor.rgb.g);
222:      outColor.rgb.b = ocio_grading_rgbcurve_evalBSplineCurve_11d7a7a1(3, outColor.rgb.b);
223:    }
224:    
225:                                    
226:    
227:    {
228:      outColor.rgb = pow( vec3(10., 10., 10.), outColor.rgb);
229:    }
230:    
231:                            
232:    
233:    {
234:      vec4 res = vec4(outColor.rgb.r, outColor.rgb.g, outColor.rgb.b, outColor.a);
235:      res = vec4(0.0208420176, 0.0208420176, 0.0208420176, 1.) * res;
236:      res = vec4(-0.000416840339, -0.000416840339, -0.000416840339, 0.) + res;
237:      outColor.rgb = vec3(res.x, res.y, res.z);
238:      outColor.a = res.w;
239:    }
240:    
241:                                                                
242:    
243:    {
244:      float Y = max( 1e-10, 0.27222871678091454 * outColor.rgb.r + 0.67408176581114831 * outColor.rgb.g + 0.05
245:      float Ypow_over_Y = pow( Y, -0.0188999772);
246:      outColor.rgb = outColor.rgb * Ypow_over_Y;
247:    }
248:    
249:                            
250:    
251:    {
252:      vec4 res = vec4(outColor.rgb.r, outColor.rgb.g, outColor.rgb.b, outColor.a);
253:      vec4 tmp = res;
254:      res = mat4(1.604753433346922, -0.10208245810655031, -0.0032671116532946819, 0., -0.531080948604018, 1.1088, 1.0760225357877193, 0., 0., 0., 0., 1.) * tmp;
255:      outColor.rgb = vec3(res.x, res.y, res.z);
256:      outColor.a = res.w;
257:    }
258:    
259:                                      
260:    
261:    {
262:      vec4 gamma = vec4(0.41666666666666669, 0.41666666666666669, 0.41666666666666669, 1.);
263:      vec4 res = pow( max( vec4(0., 0., 0., 0.), outColor ), gamma );
264:      outColor.rgb = vec3(res.x, res.y, res.z);
265:      outColor.a = res.w;
266:    }
267:  
268:    return outColor;
269:  }
270:  
//
// FUNCTION: SourcePlanarYUV
//
  1:    
  2:                                                             
  3:     
  4:                                         
  5:    
  6:    
  7:                                     
  8:    
  9:  
 10:                                                                        
 11:                                                                
 12:  
 13:  vec4 SourcePlanarYUVe3d70750 (const in sampler2DRect Y_sampler, const in sampler2DRect U_sampler, const in sconst in mat4 YUVmatrix, const in vec2 offset, const in vec2 Y_samplerSize, const in float orientation)
 14:  {
 15:                                                                
 16:                                                                
 17:      vec2 st = ST + offset;
 18:      if (st.x < 0.0 || st.y < 0.0 || st.x >= Y_samplerSize.x || st.y >= Y_samplerSize.y)
 19:          return vec4(0.0);                             
 20:  
 21:      if (orientation == 1.0)      
 22:      {
 23:          st.y = Y_samplerSize.y - st.y;
 24:      }
 25:      else if (orientation == 2.0)      
 26:      {
 27:          st.x = Y_samplerSize.x - st.x;
 28:      }
 29:      else if (orientation == 3.0)      
 30:      {
 31:          st.x = Y_samplerSize.x - st.x;
 32:          st.y = Y_samplerSize.y - st.y;
 33:      }
 34:      
 35:      return YUVmatrix * vec4( texture(Y_sampler, st).r,
 36:                               texture(U_sampler, st * ratio0).r,
 37:                               texture(V_sampler, st * ratio1).r,
 38:                               1.0 );
 39:  }
 40:  
 41:  
//
// FUNCTION: ResizeDownSampleDerivative
//
  1:    
  2:                                                             
  3:     
  4:                                         
  5:    
  6:  vec4 ResizeDownSampleDerivativea67083a4 (const in vec2 _offset)
  7:  {
  8:                                                                   
  9:      vec2 absDer = fwidth( in0.st );
 10:  
 11:                                                
 12:      float maxAbsDer = max( absDer.x, absDer.y );
 13:  
 14:                                                            
 15:                                                                              
 16:                               
 17:      int KERNEL_SIZE = int( maxAbsDer / 2.0 );
 18:  
 19:                                                                              
 20:                     
 21:         
 22:                                                          
 23:                                                     
 24:                                                     
 25:                                  
 26:                                                     
 27:                                     
 28:                                     
 29:                                     
 30:                                                       
 31:                                     
 32:                                     
 33:              
 34:                                     
 35:                                     
 36:                                     
 37:                                     
 38:                                                       
 39:  
 40:      if ( KERNEL_SIZE < 0 )
 41:      {
 42:          KERNEL_SIZE = 0;
 43:      }
 44:      else if ( KERNEL_SIZE > 16 )
 45:      {
 46:          KERNEL_SIZE = 16;
 47:      }
 48:  
 49:                                       
 50:      vec4 averageColor=vec4(0.0,0.0,0.0,0.0);
 51:      for ( int x = -KERNEL_SIZE ; x <= KERNEL_SIZE ; x++ )
 52:      {
 53:          for ( int y = -KERNEL_SIZE ; y <= KERNEL_SIZE ; y++ )
 54:          {
 55:              averageColor+= in0( vec2 ( x , y ) );
 56:          }
 57:      }
 58:  
 59:                                        
 60:      float nbSamples = float( ( KERNEL_SIZE * 2 + 1 )* ( KERNEL_SIZE * 2 + 1 ) );
 61:      averageColor /= vec4(nbSamples);
 62:  
 63:      return averageColor;
 64:  }
 65:  
 66:  
//
// PROGRAM:
//
  1:  uniform sampler2DRect Y_sampler_1;
  2:  uniform sampler2DRect U_sampler_1;
  3:  uniform sampler2DRect V_sampler_1;
  4:  uniform vec2 ratio0_1;
  5:  uniform vec2 ratio1_1;
  6:  uniform mat4 YUVmatrix_1;
  7:  uniform vec2 samplerSize_1;
  8:  uniform float orientation_1;
  9:  in vec2 TexCoord0;
 10:  out vec4 FragColor;
 11:  vec4 OCIO_c_ACES_1_0_SDR_video_Rec709_2_scene_linear_sourceGroup000000_tolinPipeline_0_ac66597788dfb789f7cea
 12:  vec4 OCIO_d_Rec_1886_Rec_709_Display_ACES_1_0_SDR_Video_displayGroup1_colorPipeline_0_e28f663db7deb1b41d7a7a
 13:  vec4 SourcePlanarYUVe3d70750(const in sampler2DRect, const in sampler2DRect, const in sampler2DRect, const ist in float);
 14:  
 15:  vec4 ResizeDownSampleDerivativea67083a4_0(const in vec2);
 16:  
 17:  vec4 _samplerExpr1 (const in vec2 _offset)
 18:  {
 19:      return SourcePlanarYUVe3d70750(Y_sampler_1, U_sampler_1, V_sampler_1, TexCoord0.xy, ratio0_1, ratio1_1, 
 20:  }
 21:  
 22:    
 23:                                                             
 24:     
 25:                                         
 26:    
 27:  vec4 ResizeDownSampleDerivativea67083a4_0 (const in vec2 _offset)
 28:  {
 29:                                                                   
 30:      vec2 absDer = fwidth( TexCoord0.st );
 31:  
 32:                                                
 33:      float maxAbsDer = max( absDer.x, absDer.y );
 34:  
 35:                                                            
 36:                                                                              
 37:                               
 38:      int KERNEL_SIZE = int( maxAbsDer / 2.0 );
 39:  
 40:                                                                              
 41:                     
 42:         
 43:                                                          
 44:                                                     
 45:                                                     
 46:                                  
 47:                                                     
 48:                                     
 49:                                     
 50:                                     
 51:                                                       
 52:                                     
 53:                                     
 54:                                     
 55:                                     
 56:                                     
 57:                                     
 58:                                     
 59:                                                       
 60:  
 61:      if ( KERNEL_SIZE < 0 )
 62:      {
 63:          KERNEL_SIZE = 0;
 64:      }
 65:      else if ( KERNEL_SIZE > 16 )
 66:      {
 67:          KERNEL_SIZE = 16;
 68:      }
 69:  
 70:                                       
 71:      vec4 averageColor=vec4(0.0,0.0,0.0,0.0);
 72:      for ( int x = -KERNEL_SIZE ; x <= KERNEL_SIZE ; x++ )
 73:      {
 74:          for ( int y = -KERNEL_SIZE ; y <= KERNEL_SIZE ; y++ )
 75:          {
 76:              averageColor+= _samplerExpr1(_offset +  vec2 ( x , y ) );
 77:          }
 78:      }
 79:  
 80:                                        
 81:      float nbSamples = float( ( KERNEL_SIZE * 2 + 1 )* ( KERNEL_SIZE * 2 + 1 ) );
 82:      averageColor /= vec4(nbSamples);
 83:  
 84:      return averageColor;
 85:  }
 86:  
 87:  
 88:  void main ()
 89:  {
 90:      FragColor = OCIO_d_Rec_1886_Rec_709_Display_ACES_1_0_SDR_Video_displayGroup1_colorPipeline_0_e28f663db7dpeline_0_ac66597788dfb789f7cead4f(ResizeDownSampleDerivativea67083a4_0(vec2(0.0, 0.0))));
 91:  }
 92:  
ERROR: compiling program:
      with functions:  OCIO_c_ACES_1_0_SDR_video_Rec709_2_scene_linear_sourceGroup000000_tolinPipeline_0_ac6659778_0_e28f663db7deb1b4 SourcePlanarYUV ResizeDownSampleDerivative
Fragment info
-------------
0(7) : error C1038: declaration of "ocio_grading_rgbcurve_knotsOffsets_0" conflicts with previous declaration at 0
0(8) : error C1038: declaration of "ocio_grading_rgbcurve_knots_0" conflicts with previous declaration at 0(8)
0(9) : error C1038: declaration of "ocio_grading_rgbcurve_coefsOffsets_0" conflicts with previous declaration at 0
0(10) : error C1038: declaration of "ocio_grading_rgbcurve_coefs_0" conflicts with previous declaration at 0(10)
0(58) : error C1038: declaration of "ocio_grading_rgbcurve_knotsOffsets_1" conflicts with previous declaration at 
0(59) : error C1038: declaration of "ocio_grading_rgbcurve_knots_1" conflicts with previous declaration at 0(70)
0(60) : error C1038: declaration of "ocio_grading_rgbcurve_coefsOffsets_1" conflicts with previous declaration at 
0(61) : error C1038: declaration of "ocio_grading_rgbcurve_coefs_1" conflicts with previous declaration at 0(72)
ERROR: failed to compile/select GL program: ERROR: failed to select the GL program

This text will be hidden

jearb · July 26, 2024, 1:12am

Hey @jjonahlowercase,

A bit of a long shot but did you ever get this sorted out or find a work-around?

I ran into similar issues when trying to apply an inverse Rec709 for movs with a baked in Rec.709 transform in RV2024.1 using OCIO v2.

In fact, I found I was able to replicate the issue by simply switching between the Sequence view of a loaded mov, and the source view. I ran into this with both an approach of using the DisplayViewTransform like you did, as well as just exposing the actual display colour space for Rec709 SDR.

Topic		Replies	Views
RV sumbit with OCIO ACES look on SG? RV	3	745	March 11, 2024
Quicktime from Acescg.exr with rvio RV	1	1201	December 2, 2020
OCIO does not load correct when rendering through RVIO RV rvio	2	787	September 12, 2024
Ocio device output color RV	3	2070	November 11, 2020
RV OCIO not matching Nuke RV rv	6	1248	May 13, 2022

RV 2024.0.1 Errors using DisplayViewTransform in ColorSpace OCIO v2.2.1

Related topics