diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1e982e4..a647d25 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,8 +5,12 @@
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+### Added
+- exposed util functions: `avifFullToLimitedY`, `avifFullToLimitedUV`, `avifLimitedToFullY`, `avifLimitedToFullUV`, `avifPrepareReformatState`
+
 ### Changed
 - Renamed ispeWidth/ispeHeight to containerWidth/containerHeight; they now can hold tkhd's width/height
+- Split avifImageYUVToRGB into faster internal functions (estimated gain: 3.5x)
 
 ## [0.3.11] - 2019-09-26
 ### Added
diff --git a/include/avif/avif.h b/include/avif/avif.h
index e54e45f..857e70d 100644
--- a/include/avif/avif.h
+++ b/include/avif/avif.h
@@ -313,6 +313,29 @@
 avifResult avifImageRGBToYUV(avifImage * image);
 avifResult avifImageYUVToRGB(avifImage * image);
 
+// ---------------------------------------------------------------------------
+// YUV Utils
+
+int avifFullToLimitedY(int depth, int v);
+int avifFullToLimitedUV(int depth, int v);
+int avifLimitedToFullY(int depth, int v);
+int avifLimitedToFullUV(int depth, int v);
+
+typedef struct avifReformatState
+{
+    // YUV coefficients
+    float kr;
+    float kg;
+    float kb;
+
+    avifPixelFormatInfo formatInfo;
+    avifBool usesU16;
+} avifReformatState;
+avifBool avifPrepareReformatState(avifImage * image, avifReformatState * state);
+
+// ---------------------------------------------------------------------------
+// avifDecoder
+
 // Useful stats related to a read/write
 typedef struct avifIOStats
 {
@@ -418,7 +441,10 @@
 avifBool avifDecoderIsKeyframe(avifDecoder * decoder, uint32_t frameIndex);
 uint32_t avifDecoderNearestKeyframe(avifDecoder * decoder, uint32_t frameIndex);
 
-// avifEncoder notes:
+// ---------------------------------------------------------------------------
+// avifEncoder
+
+// Notes:
 // * if avifEncoderWrite() returns AVIF_RESULT_OK, output must be freed with avifRWDataFree()
 // * if (maxThreads < 2), multithreading is disabled
 // * quality range: [AVIF_BEST_QUALITY - AVIF_WORST_QUALITY]
diff --git a/include/avif/internal.h b/include/avif/internal.h
index 6ce2689..412a1ea 100644
--- a/include/avif/internal.h
+++ b/include/avif/internal.h
@@ -36,11 +36,6 @@
 uint64_t avifHTON64(uint64_t l);
 uint64_t avifNTOH64(uint64_t l);
 
-int avifFullToLimitedY(int depth, int v);
-int avifFullToLimitedUV(int depth, int v);
-int avifLimitedToFullY(int depth, int v);
-int avifLimitedToFullUV(int depth, int v);
-
 void avifCalcYUVCoefficients(avifImage * image, float * outR, float * outG, float * outB);
 
 #define AVIF_ARRAY_DECLARE(TYPENAME, ITEMSTYPE, ITEMSNAME) \
diff --git a/src/reformat.c b/src/reformat.c
index f0bbd15..bf71940 100644
--- a/src/reformat.c
+++ b/src/reformat.c
@@ -5,17 +5,6 @@
 
 #include <string.h>
 
-typedef struct avifReformatState
-{
-    // YUV coefficients
-    float kr;
-    float kg;
-    float kb;
-
-    avifPixelFormatInfo formatInfo;
-    avifBool usesU16;
-} avifReformatState;
-
 struct YUVBlock
 {
     float y;
@@ -23,7 +12,7 @@
     float v;
 };
 
-static avifBool avifPrepareReformatState(avifImage * image, avifReformatState * state)
+avifBool avifPrepareReformatState(avifImage * image, avifReformatState * state)
 {
     if (image->yuvFormat == AVIF_PIXEL_FORMAT_NONE) {
         return AVIF_FALSE;
@@ -196,6 +185,198 @@
     return AVIF_RESULT_OK;
 }
 
+static avifResult avifImageYUVToRGB16Color(avifImage * image, avifReformatState * state)
+{
+    const float kr = state->kr;
+    const float kg = state->kg;
+    const float kb = state->kb;
+
+    float maxChannel = (float)((1 << image->depth) - 1);
+    uint8_t ** rgbPlanes = image->rgbPlanes;
+    uint32_t * rgbRowBytes = image->rgbRowBytes;
+    for (uint32_t j = 0; j < image->height; ++j) {
+        const int uvJ = j >> state->formatInfo.chromaShiftY;
+        uint16_t * ptrY = (uint16_t *)&image->yuvPlanes[AVIF_CHAN_Y][(j * image->yuvRowBytes[AVIF_CHAN_Y])];
+        uint16_t * ptrU = (uint16_t *)&image->yuvPlanes[AVIF_CHAN_U][(uvJ * image->yuvRowBytes[AVIF_CHAN_U])];
+        uint16_t * ptrV = (uint16_t *)&image->yuvPlanes[AVIF_CHAN_V][(uvJ * image->yuvRowBytes[AVIF_CHAN_V])];
+        uint16_t * ptrR = (uint16_t *)&rgbPlanes[AVIF_CHAN_R][j * rgbRowBytes[AVIF_CHAN_R]];
+        uint16_t * ptrG = (uint16_t *)&rgbPlanes[AVIF_CHAN_G][j * rgbRowBytes[AVIF_CHAN_G]];
+        uint16_t * ptrB = (uint16_t *)&rgbPlanes[AVIF_CHAN_B][j * rgbRowBytes[AVIF_CHAN_B]];
+
+        for (uint32_t i = 0; i < image->width; ++i) {
+            // Unpack YUV into unorm
+            const int uvI = i >> state->formatInfo.chromaShiftX;
+            uint32_t unormY = ptrY[i];
+            uint32_t unormU = ptrU[uvI];
+            uint32_t unormV = ptrV[uvI];
+
+            // adjust for limited/full color range, if need be
+            if (image->yuvRange == AVIF_RANGE_LIMITED) {
+                unormY = avifLimitedToFullY(image->depth, unormY);
+                unormU = avifLimitedToFullUV(image->depth, unormU);
+                unormV = avifLimitedToFullUV(image->depth, unormV);
+            }
+
+            // Convert unorm to float
+            const float Y = unormY / maxChannel;
+            const float Cb = (unormU / maxChannel) - 0.5f;
+            const float Cr = (unormV / maxChannel) - 0.5f;
+
+            float R = Y + (2 * (1 - kr)) * Cr;
+            float B = Y + (2 * (1 - kb)) * Cb;
+            float G = Y - ((2 * ((kr * (1 - kr) * Cr) + (kb * (1 - kb) * Cb))) / kg);
+            R = AVIF_CLAMP(R, 0.0f, 1.0f);
+            G = AVIF_CLAMP(G, 0.0f, 1.0f);
+            B = AVIF_CLAMP(B, 0.0f, 1.0f);
+
+            ptrR[i] = (uint16_t)(0.5f + (R * maxChannel));
+            ptrG[i] = (uint16_t)(0.5f + (G * maxChannel));
+            ptrB[i] = (uint16_t)(0.5f + (B * maxChannel));
+        }
+    }
+    return AVIF_RESULT_OK;
+}
+
+static avifResult avifImageYUVToRGB16Mono(avifImage * image, avifReformatState * state)
+{
+    const float kr = state->kr;
+    const float kg = state->kg;
+    const float kb = state->kb;
+
+    float maxChannel = (float)((1 << image->depth) - 1);
+    uint8_t ** rgbPlanes = image->rgbPlanes;
+    uint32_t * rgbRowBytes = image->rgbRowBytes;
+    for (uint32_t j = 0; j < image->height; ++j) {
+        uint16_t * ptrY = (uint16_t *)&image->yuvPlanes[AVIF_CHAN_Y][(j * image->yuvRowBytes[AVIF_CHAN_Y])];
+        uint16_t * ptrR = (uint16_t *)&rgbPlanes[AVIF_CHAN_R][j * rgbRowBytes[AVIF_CHAN_R]];
+        uint16_t * ptrG = (uint16_t *)&rgbPlanes[AVIF_CHAN_G][j * rgbRowBytes[AVIF_CHAN_G]];
+        uint16_t * ptrB = (uint16_t *)&rgbPlanes[AVIF_CHAN_B][j * rgbRowBytes[AVIF_CHAN_B]];
+
+        for (uint32_t i = 0; i < image->width; ++i) {
+            // Unpack YUV into unorm
+            uint32_t unormY = ptrY[i];
+
+            // adjust for limited/full color range, if need be
+            if (image->yuvRange == AVIF_RANGE_LIMITED) {
+                unormY = avifLimitedToFullY(image->depth, unormY);
+            }
+
+            // Convert unorm to float
+            const float Y = unormY / maxChannel;
+            const float Cb = -0.5f;
+            const float Cr = -0.5f;
+
+            float R = Y + (2 * (1 - kr)) * Cr;
+            float B = Y + (2 * (1 - kb)) * Cb;
+            float G = Y - ((2 * ((kr * (1 - kr) * Cr) + (kb * (1 - kb) * Cb))) / kg);
+            R = AVIF_CLAMP(R, 0.0f, 1.0f);
+            G = AVIF_CLAMP(G, 0.0f, 1.0f);
+            B = AVIF_CLAMP(B, 0.0f, 1.0f);
+
+            ptrR[i] = (uint16_t)(0.5f + (R * maxChannel));
+            ptrG[i] = (uint16_t)(0.5f + (G * maxChannel));
+            ptrB[i] = (uint16_t)(0.5f + (B * maxChannel));
+        }
+    }
+    return AVIF_RESULT_OK;
+}
+
+static avifResult avifImageYUVToRGB8Color(avifImage * image, avifReformatState * state)
+{
+    const float kr = state->kr;
+    const float kg = state->kg;
+    const float kb = state->kb;
+
+    float maxChannel = (float)((1 << image->depth) - 1);
+    uint8_t ** rgbPlanes = image->rgbPlanes;
+    uint32_t * rgbRowBytes = image->rgbRowBytes;
+    for (uint32_t j = 0; j < image->height; ++j) {
+        int uvJ = j >> state->formatInfo.chromaShiftY;
+        uint8_t * ptrY = &image->yuvPlanes[AVIF_CHAN_Y][(j * image->yuvRowBytes[AVIF_CHAN_Y])];
+        uint8_t * ptrU = &image->yuvPlanes[AVIF_CHAN_U][(uvJ * image->yuvRowBytes[AVIF_CHAN_U])];
+        uint8_t * ptrV = &image->yuvPlanes[AVIF_CHAN_V][(uvJ * image->yuvRowBytes[AVIF_CHAN_V])];
+        uint8_t * ptrR = &rgbPlanes[AVIF_CHAN_R][j * rgbRowBytes[AVIF_CHAN_R]];
+        uint8_t * ptrG = &rgbPlanes[AVIF_CHAN_G][j * rgbRowBytes[AVIF_CHAN_G]];
+        uint8_t * ptrB = &rgbPlanes[AVIF_CHAN_B][j * rgbRowBytes[AVIF_CHAN_B]];
+
+        for (uint32_t i = 0; i < image->width; ++i) {
+            // Unpack YUV into unorm
+            const int uvI = i >> state->formatInfo.chromaShiftX;
+            uint32_t unormY = ptrY[i];
+            uint32_t unormU = ptrU[uvI];
+            uint32_t unormV = ptrV[uvI];
+
+            // adjust for limited/full color range, if need be
+            if (image->yuvRange == AVIF_RANGE_LIMITED) {
+                unormY = avifLimitedToFullY(image->depth, unormY);
+                unormU = avifLimitedToFullUV(image->depth, unormU);
+                unormV = avifLimitedToFullUV(image->depth, unormV);
+            }
+
+            // Convert unorm to float
+            const float Y = unormY / maxChannel;
+            const float Cb = (unormU / maxChannel) - 0.5f;
+            const float Cr = (unormV / maxChannel) - 0.5f;
+
+            float R = Y + (2 * (1 - kr)) * Cr;
+            float B = Y + (2 * (1 - kb)) * Cb;
+            float G = Y - ((2 * ((kr * (1 - kr) * Cr) + (kb * (1 - kb) * Cb))) / kg);
+            R = AVIF_CLAMP(R, 0.0f, 1.0f);
+            G = AVIF_CLAMP(G, 0.0f, 1.0f);
+            B = AVIF_CLAMP(B, 0.0f, 1.0f);
+
+            ptrR[i] = (uint8_t)(0.5f + (R * maxChannel));
+            ptrG[i] = (uint8_t)(0.5f + (G * maxChannel));
+            ptrB[i] = (uint8_t)(0.5f + (B * maxChannel));
+        }
+    }
+    return AVIF_RESULT_OK;
+}
+
+static avifResult avifImageYUVToRGB8Mono(avifImage * image, avifReformatState * state)
+{
+    const float kr = state->kr;
+    const float kg = state->kg;
+    const float kb = state->kb;
+
+    float maxChannel = (float)((1 << image->depth) - 1);
+    uint8_t ** rgbPlanes = image->rgbPlanes;
+    uint32_t * rgbRowBytes = image->rgbRowBytes;
+    for (uint32_t j = 0; j < image->height; ++j) {
+        uint8_t * ptrY = &image->yuvPlanes[AVIF_CHAN_Y][(j * image->yuvRowBytes[AVIF_CHAN_Y])];
+        uint8_t * ptrR = &rgbPlanes[AVIF_CHAN_R][j * rgbRowBytes[AVIF_CHAN_R]];
+        uint8_t * ptrG = &rgbPlanes[AVIF_CHAN_G][j * rgbRowBytes[AVIF_CHAN_G]];
+        uint8_t * ptrB = &rgbPlanes[AVIF_CHAN_B][j * rgbRowBytes[AVIF_CHAN_B]];
+
+        for (uint32_t i = 0; i < image->width; ++i) {
+            // Unpack YUV into unorm
+            uint32_t unormY = ptrY[i];
+
+            // adjust for limited/full color range, if need be
+            if (image->yuvRange == AVIF_RANGE_LIMITED) {
+                unormY = avifLimitedToFullY(image->depth, unormY);
+            }
+
+            // Convert unorm to float
+            const float Y = unormY / maxChannel;
+            const float Cb = -0.5f;
+            const float Cr = -0.5f;
+
+            float R = Y + (2 * (1 - kr)) * Cr;
+            float B = Y + (2 * (1 - kb)) * Cb;
+            float G = Y - ((2 * ((kr * (1 - kr) * Cr) + (kb * (1 - kb) * Cb))) / kg);
+            R = AVIF_CLAMP(R, 0.0f, 1.0f);
+            G = AVIF_CLAMP(G, 0.0f, 1.0f);
+            B = AVIF_CLAMP(B, 0.0f, 1.0f);
+
+            ptrR[i] = (uint8_t)(0.5f + (R * maxChannel));
+            ptrG[i] = (uint8_t)(0.5f + (G * maxChannel));
+            ptrB[i] = (uint8_t)(0.5f + (B * maxChannel));
+        }
+    }
+    return AVIF_RESULT_OK;
+}
+
 avifResult avifImageYUVToRGB(avifImage * image)
 {
     if (!image->yuvPlanes[AVIF_CHAN_Y] || !image->yuvPlanes[AVIF_CHAN_U] || !image->yuvPlanes[AVIF_CHAN_V]) {
@@ -209,88 +390,17 @@
 
     avifImageAllocatePlanes(image, AVIF_PLANES_RGB);
 
-    const float kr = state.kr;
-    const float kg = state.kg;
-    const float kb = state.kb;
-
-    int yuvUNorm[3];
-    float yuvPixel[3];
-    float rgbPixel[3];
-    float maxChannel = (float)((1 << image->depth) - 1);
-    uint8_t ** rgbPlanes = image->rgbPlanes;
-    uint32_t * rgbRowBytes = image->rgbRowBytes;
-    for (uint32_t j = 0; j < image->height; ++j) {
-        for (uint32_t i = 0; i < image->width; ++i) {
-            // Unpack YUV into unorm
-            int uvI = i >> state.formatInfo.chromaShiftX;
-            int uvJ = j >> state.formatInfo.chromaShiftY;
-            if (state.usesU16) {
-                yuvUNorm[0] = *((uint16_t *)&image->yuvPlanes[AVIF_CHAN_Y][(i * 2) + (j * image->yuvRowBytes[AVIF_CHAN_Y])]);
-                if (image->yuvRowBytes[AVIF_CHAN_U]) {
-                    yuvUNorm[1] = *((uint16_t *)&image->yuvPlanes[AVIF_CHAN_U][(uvI * 2) + (uvJ * image->yuvRowBytes[AVIF_CHAN_U])]);
-                } else {
-                    yuvUNorm[1] = 0;
-                }
-                if (image->yuvRowBytes[AVIF_CHAN_V]) {
-                    yuvUNorm[2] = *((uint16_t *)&image->yuvPlanes[AVIF_CHAN_V][(uvI * 2) + (uvJ * image->yuvRowBytes[AVIF_CHAN_V])]);
-                } else {
-                    yuvUNorm[2] = 0;
-                }
-            } else {
-                yuvUNorm[0] = image->yuvPlanes[AVIF_CHAN_Y][i + (j * image->yuvRowBytes[AVIF_CHAN_Y])];
-                if (image->yuvRowBytes[AVIF_CHAN_U]) {
-                    yuvUNorm[1] = image->yuvPlanes[AVIF_CHAN_U][uvI + (uvJ * image->yuvRowBytes[AVIF_CHAN_U])];
-                } else {
-                    yuvUNorm[1] = 0;
-                }
-                if (image->yuvRowBytes[AVIF_CHAN_V]) {
-                    yuvUNorm[2] = image->yuvPlanes[AVIF_CHAN_V][uvI + (uvJ * image->yuvRowBytes[AVIF_CHAN_V])];
-                } else {
-                    yuvUNorm[2] = 0;
-                }
-            }
-
-            // adjust for limited/full color range, if need be
-            if (image->yuvRange == AVIF_RANGE_LIMITED) {
-                yuvUNorm[0] = avifLimitedToFullY(image->depth, yuvUNorm[0]);
-                yuvUNorm[1] = avifLimitedToFullUV(image->depth, yuvUNorm[1]);
-                yuvUNorm[2] = avifLimitedToFullUV(image->depth, yuvUNorm[2]);
-            }
-
-            // Convert unorm to float
-            yuvPixel[0] = yuvUNorm[0] / maxChannel;
-            yuvPixel[1] = yuvUNorm[1] / maxChannel;
-            yuvPixel[2] = yuvUNorm[2] / maxChannel;
-            yuvPixel[1] -= 0.5f;
-            yuvPixel[2] -= 0.5f;
-
-            float Y = yuvPixel[0];
-            float Cb = yuvPixel[1];
-            float Cr = yuvPixel[2];
-
-            float R = Y + (2 * (1 - kr)) * Cr;
-            float B = Y + (2 * (1 - kb)) * Cb;
-            float G = Y - ((2 * ((kr * (1 - kr) * Cr) + (kb * (1 - kb) * Cb))) / kg);
-
-            rgbPixel[0] = AVIF_CLAMP(R, 0.0f, 1.0f);
-            rgbPixel[1] = AVIF_CLAMP(G, 0.0f, 1.0f);
-            rgbPixel[2] = AVIF_CLAMP(B, 0.0f, 1.0f);
-
-            if (state.usesU16) {
-                uint16_t * pR = (uint16_t *)&rgbPlanes[AVIF_CHAN_R][(i * 2) + (j * rgbRowBytes[AVIF_CHAN_R])];
-                *pR = (uint16_t)avifRoundf(rgbPixel[0] * maxChannel);
-                uint16_t * pG = (uint16_t *)&rgbPlanes[AVIF_CHAN_G][(i * 2) + (j * rgbRowBytes[AVIF_CHAN_G])];
-                *pG = (uint16_t)avifRoundf(rgbPixel[1] * maxChannel);
-                uint16_t * pB = (uint16_t *)&rgbPlanes[AVIF_CHAN_B][(i * 2) + (j * rgbRowBytes[AVIF_CHAN_B])];
-                *pB = (uint16_t)avifRoundf(rgbPixel[2] * maxChannel);
-            } else {
-                image->rgbPlanes[AVIF_CHAN_R][i + (j * image->rgbRowBytes[AVIF_CHAN_R])] = (uint8_t)avifRoundf(rgbPixel[0] * maxChannel);
-                image->rgbPlanes[AVIF_CHAN_G][i + (j * image->rgbRowBytes[AVIF_CHAN_G])] = (uint8_t)avifRoundf(rgbPixel[1] * maxChannel);
-                image->rgbPlanes[AVIF_CHAN_B][i + (j * image->rgbRowBytes[AVIF_CHAN_B])] = (uint8_t)avifRoundf(rgbPixel[2] * maxChannel);
-            }
+    if (state.usesU16) {
+        if (image->yuvRowBytes[AVIF_CHAN_U] && image->yuvRowBytes[AVIF_CHAN_V]) {
+            return avifImageYUVToRGB16Color(image, &state);
         }
+        return avifImageYUVToRGB16Mono(image, &state);
     }
-    return AVIF_RESULT_OK;
+
+    if (image->yuvRowBytes[AVIF_CHAN_U] && image->yuvRowBytes[AVIF_CHAN_V]) {
+        return avifImageYUVToRGB8Color(image, &state);
+    }
+    return avifImageYUVToRGB8Mono(image, &state);
 }
 
 int avifLimitedToFullY(int depth, int v)