diff --git a/src/Transform.c b/src/Transform.c
index 0de0727..f07c5e7 100644
--- a/src/Transform.c
+++ b/src/Transform.c
@@ -404,9 +404,12 @@
     }
     int n = (int)nz;
 
-    // Both profiles can be null if we're just doing format conversion, otherwise both are needed
-    if (!dstProfile != !srcProfile) {
-        return false;
+    // Null profiles default to sRGB. Passing null for both is handy when doing format conversion.
+    if (!srcProfile) {
+        srcProfile = skcms_sRGB_profile();
+    }
+    if (!dstProfile) {
+        dstProfile = skcms_sRGB_profile();
     }
 
     // We can't transform in place unless the PixelFormats are the same size.
@@ -442,7 +445,7 @@
         *ops++ = Op_swap_rb;
     }
 
-    if (srcProfile && srcProfile->data_color_space == skcms_Signature_CMYK) {
+    if (srcProfile->data_color_space == skcms_Signature_CMYK) {
         // Photoshop creates CMYK images as inverse CMYK.
         // These happen to be the only ones we've _ever_ seen.
         *ops++ = Op_invert;
diff --git a/tests.c b/tests.c
index 00fd64d..fea003b 100644
--- a/tests.c
+++ b/tests.c
@@ -47,10 +47,6 @@
 }
 
 static void test_FormatConversions() {
-    // If we use a single skcms_ICCProfile, we should be able to use skcms_Transform()
-    // to do skcms_PixelFormat conversions.
-    skcms_ICCProfile profile;
-
     // We can interpret src as 85 RGB_888 pixels or 64 RGB_8888 pixels.
     uint8_t src[256],
             dst[85*4];
@@ -59,16 +55,16 @@
     }
 
     // This should basically be a really complicated memcpy().
-    expect(skcms_Transform(src, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
-                           dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(src, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
+                           dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            64));
     for (int i = 0; i < 256; i++) {
         expect(dst[i] == i);
     }
 
     // We can do RGBA -> BGRA swaps two ways:
-    expect(skcms_Transform(src, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
-                           dst, skcms_PixelFormat_BGRA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(src, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
+                           dst, skcms_PixelFormat_BGRA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            64));
     for (int i = 0; i < 64; i++) {
         expect(dst[4*i+0] == 4*i+2);
@@ -76,8 +72,8 @@
         expect(dst[4*i+2] == 4*i+0);
         expect(dst[4*i+3] == 4*i+3);
     }
-    expect(skcms_Transform(src, skcms_PixelFormat_BGRA_8888, skcms_AlphaFormat_Unpremul, &profile,
-                           dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(src, skcms_PixelFormat_BGRA_8888, skcms_AlphaFormat_Unpremul, NULL,
+                           dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            64));
     for (int i = 0; i < 64; i++) {
         expect(dst[4*i+0] == 4*i+2);
@@ -87,8 +83,8 @@
     }
 
     // Let's convert RGB_888 to RGBA_8888...
-    expect(skcms_Transform(src, skcms_PixelFormat_RGB_888  , skcms_AlphaFormat_Unpremul, &profile,
-                           dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(src, skcms_PixelFormat_RGB_888  , skcms_AlphaFormat_Unpremul, NULL,
+                           dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            85));
     for (int i = 0; i < 85; i++) {
         expect(dst[4*i+0] == 3*i+0);
@@ -97,8 +93,8 @@
         expect(dst[4*i+3] ==   255);
     }
     // ... and now all the variants of R-B swaps.
-    expect(skcms_Transform(src, skcms_PixelFormat_BGR_888  , skcms_AlphaFormat_Unpremul, &profile,
-                           dst, skcms_PixelFormat_BGRA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(src, skcms_PixelFormat_BGR_888  , skcms_AlphaFormat_Unpremul, NULL,
+                           dst, skcms_PixelFormat_BGRA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            85));
     for (int i = 0; i < 85; i++) {
         expect(dst[4*i+0] == 3*i+0);
@@ -106,8 +102,8 @@
         expect(dst[4*i+2] == 3*i+2);
         expect(dst[4*i+3] ==   255);
     }
-    expect(skcms_Transform(src, skcms_PixelFormat_BGR_888  , skcms_AlphaFormat_Unpremul, &profile,
-                           dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(src, skcms_PixelFormat_BGR_888  , skcms_AlphaFormat_Unpremul, NULL,
+                           dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            85));
     for (int i = 0; i < 85; i++) {
         expect(dst[4*i+0] == 3*i+2);
@@ -115,8 +111,8 @@
         expect(dst[4*i+2] == 3*i+0);
         expect(dst[4*i+3] ==   255);
     }
-    expect(skcms_Transform(src, skcms_PixelFormat_RGB_888  , skcms_AlphaFormat_Unpremul, &profile,
-                           dst, skcms_PixelFormat_BGRA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(src, skcms_PixelFormat_RGB_888  , skcms_AlphaFormat_Unpremul, NULL,
+                           dst, skcms_PixelFormat_BGRA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            85));
     for (int i = 0; i < 85; i++) {
         expect(dst[4*i+0] == 3*i+2);
@@ -127,13 +123,13 @@
 
     // Let's test in-place transforms.
     // RGBA_8888 and RGB_888 aren't the same size, so we shouldn't allow this call.
-    expect(!skcms_Transform(src, skcms_PixelFormat_RGB_888  , skcms_AlphaFormat_Unpremul, &profile,
-                            src, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(!skcms_Transform(src, skcms_PixelFormat_RGB_888  , skcms_AlphaFormat_Unpremul, NULL,
+                            src, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
                             85));
 
     // These two should work fine.
-    expect(skcms_Transform(src, skcms_PixelFormat_BGRA_8888, skcms_AlphaFormat_Unpremul, &profile,
-                           src, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(src, skcms_PixelFormat_BGRA_8888, skcms_AlphaFormat_Unpremul, NULL,
+                           src, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            64));
     for (int i = 0; i < 64; i++) {
         expect(src[4*i+0] == 4*i+2);
@@ -141,8 +137,8 @@
         expect(src[4*i+2] == 4*i+0);
         expect(src[4*i+3] == 4*i+3);
     }
-    expect(skcms_Transform(src, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
-                           src, skcms_PixelFormat_BGRA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(src, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
+                           src, skcms_PixelFormat_BGRA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            64));
     for (int i = 0; i < 64; i++) {
         expect(src[4*i+0] == 4*i+0);
@@ -153,8 +149,8 @@
 
     uint32_t _8888[3] = { 0x03020100, 0x07060504, 0x0b0a0908 };
     uint8_t _888[9];
-    expect(skcms_Transform(_8888, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
-                           _888 , skcms_PixelFormat_RGB_888  , skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(_8888, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
+                           _888 , skcms_PixelFormat_RGB_888  , skcms_AlphaFormat_Unpremul, NULL,
                            3));
     expect(_888[0] == 0 && _888[1] == 1 && _888[2] ==  2);
     expect(_888[3] == 4 && _888[4] == 5 && _888[5] ==  6);
@@ -162,10 +158,6 @@
 }
 
 static void test_FormatConversions_565() {
-    // If we use a single skcms_ICCProfile, we should be able to use skcms_Transform()
-    // to do skcms_PixelFormat conversions.
-    skcms_ICCProfile profile;
-
     // This should hit all the unique values of each lane of 565.
     uint16_t src[64];
     for (int i = 0; i < 64; i++) {
@@ -178,8 +170,8 @@
     expect(src[63] == 0xffff);
 
     uint32_t dst[64];
-    expect(skcms_Transform(src, skcms_PixelFormat_RGB_565  , skcms_AlphaFormat_Unpremul, &profile,
-                           dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(src, skcms_PixelFormat_RGB_565  , skcms_AlphaFormat_Unpremul, NULL,
+                           dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            64));
     // We'll just spot check these results a bit.
     for (int i = 0; i < 64; i++) {
@@ -192,8 +184,8 @@
 
     // Let's convert back the other way.
     uint16_t back[64];
-    expect(skcms_Transform(dst , skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
-                           back, skcms_PixelFormat_RGB_565  , skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(dst , skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
+                           back, skcms_PixelFormat_RGB_565  , skcms_AlphaFormat_Unpremul, NULL,
                            64));
     for (int i = 0; i < 64; i++) {
         expect(src[i] == back[i]);
@@ -201,8 +193,6 @@
 }
 
 static void test_FormatConversions_16161616() {
-    skcms_ICCProfile profile;
-
     // We want to hit each 16-bit value, 4 per each of 16384 pixels.
     uint64_t* src = malloc(8 * 16384);
     for (int i = 0; i < 16384; i++) {
@@ -216,8 +206,8 @@
     expect(src[16383] == 0xfffffffefffdfffc);
 
     uint32_t* dst = malloc(4 * 16384);
-    expect(skcms_Transform(src, skcms_PixelFormat_RGBA_16161616, skcms_AlphaFormat_Unpremul, &profile,
-                           dst, skcms_PixelFormat_RGBA_8888    , skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(src, skcms_PixelFormat_RGBA_16161616, skcms_AlphaFormat_Unpremul, NULL,
+                           dst, skcms_PixelFormat_RGBA_8888    , skcms_AlphaFormat_Unpremul, NULL,
                            16384));
 
     // skcms_Transform() will treat src as holding big-endian 16-bit values,
@@ -230,8 +220,8 @@
     // We've lost precision when transforming to 8-bit, so these won't quite round-trip.
     // Instead we should see the 8-bit dst value byte-doubled, as 65535/255 = 257 = 0x0101.
     uint64_t* back = malloc(8 * 16384);
-    expect(skcms_Transform(dst , skcms_PixelFormat_RGBA_8888    , skcms_AlphaFormat_Unpremul, &profile,
-                           back, skcms_PixelFormat_RGBA_16161616, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(dst , skcms_PixelFormat_RGBA_8888    , skcms_AlphaFormat_Unpremul, NULL,
+                           back, skcms_PixelFormat_RGBA_16161616, skcms_AlphaFormat_Unpremul, NULL,
                            16384));
     for (int i = 0; i < 16384; i++) {
         expect( ((back[i] >>  0) & 0xffff) == ((dst[i] >>  0) & 0xff) * 0x0101);
@@ -246,16 +236,14 @@
 }
 
 static void test_FormatConversions_161616() {
-    skcms_ICCProfile profile;
-
     // We'll test the same cases as the _16161616() test, as if they were 4 RGB pixels.
     uint16_t src[] = { 0x0000, 0x0001, 0x0002,
                        0x0003, 0x7efc, 0x7efd,
                        0x7efe, 0x7eff, 0xfffc,
                        0xfffd, 0xfffe, 0xffff };
     uint32_t dst[4];
-    expect(skcms_Transform(src, skcms_PixelFormat_RGB_161616, skcms_AlphaFormat_Unpremul, &profile,
-                           dst, skcms_PixelFormat_RGBA_8888 , skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(src, skcms_PixelFormat_RGB_161616, skcms_AlphaFormat_Unpremul, NULL,
+                           dst, skcms_PixelFormat_RGBA_8888 , skcms_AlphaFormat_Unpremul, NULL,
                            4));
 
     expect(dst[0] == 0xff020100);
@@ -266,8 +254,8 @@
     // We've lost precision when transforming to 8-bit, so these won't quite round-trip.
     // Instead we should see the most signficant (low) byte doubled, as 65535/255 = 257 = 0x0101.
     uint16_t back[12];
-    expect(skcms_Transform(dst , skcms_PixelFormat_RGBA_8888 , skcms_AlphaFormat_Unpremul, &profile,
-                           back, skcms_PixelFormat_RGB_161616, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(dst , skcms_PixelFormat_RGBA_8888 , skcms_AlphaFormat_Unpremul, NULL,
+                           back, skcms_PixelFormat_RGB_161616, skcms_AlphaFormat_Unpremul, NULL,
                            4));
     for (int i = 0; i < 12; i++) {
         expect(back[0] == (src[0] & 0xff) * 0x0101);
@@ -275,34 +263,32 @@
 }
 
 static void test_FormatConversions_101010() {
-    skcms_ICCProfile profile;
-
     uint32_t src = (uint32_t)1023 <<  0    // 1.0.
                  | (uint32_t) 511 << 10    // About 1/2.
                  | (uint32_t)   4 << 20    // Smallest 10-bit channel that's non-zero in 8-bit.
                  | (uint32_t)   1 << 30;   // 1/3, smallest non-zero alpha.
     uint32_t dst;
-    expect(skcms_Transform(&src, skcms_PixelFormat_RGBA_1010102, skcms_AlphaFormat_Unpremul, &profile,
-                           &dst, skcms_PixelFormat_RGBA_8888   , skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(&src, skcms_PixelFormat_RGBA_1010102, skcms_AlphaFormat_Unpremul, NULL,
+                           &dst, skcms_PixelFormat_RGBA_8888   , skcms_AlphaFormat_Unpremul, NULL,
                            1));
     expect(dst == 0x55017fff);
 
     // Same as above, but we'll ignore the 1/3 alpha and fill in 1.0.
-    expect(skcms_Transform(&src, skcms_PixelFormat_RGBA_1010102, skcms_AlphaFormat_Opaque  , &profile,
-                           &dst, skcms_PixelFormat_RGBA_8888   , skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(&src, skcms_PixelFormat_RGBA_1010102, skcms_AlphaFormat_Opaque  , NULL,
+                           &dst, skcms_PixelFormat_RGBA_8888   , skcms_AlphaFormat_Unpremul, NULL,
                            1));
     expect(dst == 0xff017fff);
 
     // Converting 101010x <-> 1010102 will force opaque in either direction.
-    expect(skcms_Transform(&src, skcms_PixelFormat_RGBA_1010102, skcms_AlphaFormat_Unpremul, &profile,
-                           &dst, skcms_PixelFormat_RGBA_1010102, skcms_AlphaFormat_Opaque  , &profile,
+    expect(skcms_Transform(&src, skcms_PixelFormat_RGBA_1010102, skcms_AlphaFormat_Unpremul, NULL,
+                           &dst, skcms_PixelFormat_RGBA_1010102, skcms_AlphaFormat_Opaque  , NULL,
                            1));
     expect(dst == ( (uint32_t)1023 <<  0
                   | (uint32_t) 511 << 10
                   | (uint32_t)   4 << 20
                   | (uint32_t)   3 << 30));
-    expect(skcms_Transform(&src, skcms_PixelFormat_RGBA_1010102, skcms_AlphaFormat_Opaque  , &profile,
-                           &dst, skcms_PixelFormat_RGBA_1010102, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(&src, skcms_PixelFormat_RGBA_1010102, skcms_AlphaFormat_Opaque  , NULL,
+                           &dst, skcms_PixelFormat_RGBA_1010102, skcms_AlphaFormat_Unpremul, NULL,
                            1));
     expect(dst == ( (uint32_t)1023 <<  0
                   | (uint32_t) 511 << 10
@@ -311,8 +297,6 @@
 }
 
 static void test_FormatConversions_half() {
-    skcms_ICCProfile profile;
-
     uint16_t src[] = {
         0x3c00,  // 1.0
         0x3800,  // 0.5
@@ -325,21 +309,21 @@
     };
 
     uint32_t dst[2];
-    expect(skcms_Transform(&src, skcms_PixelFormat_RGBA_hhhh, skcms_AlphaFormat_Unpremul, &profile,
-                           &dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(&src, skcms_PixelFormat_RGBA_hhhh, skcms_AlphaFormat_Unpremul, NULL,
+                           &dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            2));
     expect(dst[0] == 0x000180ff);
     expect(dst[1] == 0x000000ff);  // Notice we've clamped 2.0 to 0xff and -1.0 to 0x00.
 
-    expect(skcms_Transform(&src, skcms_PixelFormat_RGB_hhh  , skcms_AlphaFormat_Unpremul, &profile,
-                           &dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(&src, skcms_PixelFormat_RGB_hhh  , skcms_AlphaFormat_Unpremul, NULL,
+                           &dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            2));
     expect(dst[0] == 0xff0180ff);
     expect(dst[1] == 0xff00ff00);  // Remember, this corresponds to src[3-5].
 
     float fdst[8];
-    expect(skcms_Transform( &src, skcms_PixelFormat_RGBA_hhhh, skcms_AlphaFormat_Unpremul, &profile,
-                           &fdst, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform( &src, skcms_PixelFormat_RGBA_hhhh, skcms_AlphaFormat_Unpremul, NULL,
+                           &fdst, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, NULL,
                            2));
     expect(fdst[0] ==  1.0f);
     expect(fdst[1] ==  0.5f);
@@ -352,8 +336,8 @@
 
     // Now convert back, first to RGBA halfs, then RGB halfs.
     uint16_t back[8];
-    expect(skcms_Transform(&fdst, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, &profile,
-                           &back, skcms_PixelFormat_RGBA_hhhh, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(&fdst, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, NULL,
+                           &back, skcms_PixelFormat_RGBA_hhhh, skcms_AlphaFormat_Unpremul, NULL,
                            2));
     expect(back[0] == src[0]);
     expect(back[1] == src[1]);
@@ -364,8 +348,8 @@
     expect(back[6] == src[6] || back[6] == 0x0000);
     expect(back[7] == src[7]);
 
-    expect(skcms_Transform(&fdst, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, &profile,
-                           &back, skcms_PixelFormat_RGB_hhh  , skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(&fdst, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, NULL,
+                           &back, skcms_PixelFormat_RGB_hhh  , skcms_AlphaFormat_Unpremul, NULL,
                            2));
     expect(back[0] == src[0]);
     expect(back[1] == src[1]);
@@ -376,19 +360,17 @@
 }
 
 static void test_FormatConversions_float() {
-    skcms_ICCProfile profile;
-
     float src[] = { 1.0f, 0.5f, 1/255.0f, 1/512.0f };
 
     uint32_t dst;
-    expect(skcms_Transform(&src, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, &profile,
-                           &dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(&src, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, NULL,
+                           &dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            1));
     expect(dst == 0x000180ff);
 
     // Same as above, but we'll ignore the 1/512 alpha and fill in 1.0.
-    expect(skcms_Transform(&src, skcms_PixelFormat_RGB_fff  , skcms_AlphaFormat_Unpremul, &profile,
-                           &dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(&src, skcms_PixelFormat_RGB_fff  , skcms_AlphaFormat_Unpremul, NULL,
+                           &dst, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
                            1));
     expect(dst == 0xff0180ff);
 
@@ -398,8 +380,8 @@
     for (int i = 0; i < 64; i++) {
         bytes[i] = 0x03020100 + 0x04040404 * (uint32_t)i;
     }
-    expect(skcms_Transform(&bytes, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, &profile,
-                            &fdst, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(&bytes, skcms_PixelFormat_RGBA_8888, skcms_AlphaFormat_Unpremul, NULL,
+                            &fdst, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, NULL,
                            64));
     for (int i = 0; i < 256; i++) {
         expect(fdst[i] == i*(1/255.0f));
@@ -407,13 +389,13 @@
 
     float ffff[16] = { 0,1,2,3, 4,5,6,7, 8,9,10,11, 12,13,14,15 };
     float  fff[12] = { 0,0,0, 0,0,0, 0,0,0, 0,0,0};
-    expect(skcms_Transform(ffff, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, &profile,
-                           fff , skcms_PixelFormat_RGB_fff  , skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(ffff, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, NULL,
+                           fff , skcms_PixelFormat_RGB_fff  , skcms_AlphaFormat_Unpremul, NULL,
                            1));
     expect(fff[0] == 0); expect(fff[1] == 1); expect(fff[2] == 2);
 
-    expect(skcms_Transform(ffff, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, &profile,
-                           fff , skcms_PixelFormat_RGB_fff  , skcms_AlphaFormat_Unpremul, &profile,
+    expect(skcms_Transform(ffff, skcms_PixelFormat_RGBA_ffff, skcms_AlphaFormat_Unpremul, NULL,
+                           fff , skcms_PixelFormat_RGB_fff  , skcms_AlphaFormat_Unpremul, NULL,
                            4));
     expect(fff[0] ==  0); expect(fff[ 1] ==  1); expect(fff[ 2] ==  2);
     expect(fff[3] ==  4); expect(fff[ 4] ==  5); expect(fff[ 5] ==  6);