diff --git a/gyp/gpu.gyp b/gyp/gpu.gyp
index 8b30a12..3a6a730 100644
--- a/gyp/gpu.gyp
+++ b/gyp/gpu.gyp
@@ -157,6 +157,7 @@
         '../include/gpu/GrFontScaler.h',
         '../include/gpu/GrGLConfig.h',
         '../include/gpu/GrGLConfig_chrome.h',
+        '../include/gpu/GrGLDefines.h',
         '../include/gpu/GrGLInterface.h',
         '../include/gpu/GrGlyph.h',
         '../include/gpu/GrInstanceCounter.h',
diff --git a/include/gpu/GrGLDefines.h b/include/gpu/GrGLDefines.h
index 5d11b9f..94e7cb5 100644
--- a/include/gpu/GrGLDefines.h
+++ b/include/gpu/GrGLDefines.h
@@ -282,6 +282,9 @@
 
 /* PixelFormat */
 #define GR_GL_DEPTH_COMPONENT                0x1902
+#define GR_GL_RED                            0x1903
+#define GR_GL_GREEN                          0x1904
+#define GR_GL_BLUE                           0x1905
 #define GR_GL_ALPHA                          0x1906
 #define GR_GL_RGB                            0x1907
 #define GR_GL_RGBA                           0x1908
@@ -424,10 +427,17 @@
 #define GR_GL_CLAMP_TO_EDGE                  0x812F
 #define GR_GL_MIRRORED_REPEAT                0x8370
 
+/* Texture Swizzle */
+#define GR_GL_TEXTURE_SWIZZLE_R              0x8E42
+#define GR_GL_TEXTURE_SWIZZLE_G              0x8E43
+#define GR_GL_TEXTURE_SWIZZLE_B              0x8E44
+#define GR_GL_TEXTURE_SWIZZLE_A              0x8E45
+#define GR_GL_TEXTURE_SWIZZLE_RGBA           0x8E46
+
 /* Texture mapping */
-#define GR_GL_TEXTURE_ENV                   0x2300
-#define GR_GL_TEXTURE_ENV_MODE              0x2200
-#define GR_GL_TEXTURE_1D                    0x0DE0
+#define GR_GL_TEXTURE_ENV                    0x2300
+#define GR_GL_TEXTURE_ENV_MODE               0x2200
+#define GR_GL_TEXTURE_1D                     0x0DE0
 /* GL_TEXTURE_2D */
 /* GL_TEXTURE_WRAP_S */
 /* GL_TEXTURE_WRAP_T */
diff --git a/src/gpu/GrGLProgram.cpp b/src/gpu/GrGLProgram.cpp
index c538054..554a274 100644
--- a/src/gpu/GrGLProgram.cpp
+++ b/src/gpu/GrGLProgram.cpp
@@ -79,6 +79,7 @@
     bool            fUsesGS;
 };
 
+typedef GrGLProgram::ProgramDesc::StageDesc StageDesc;
 
 #if GR_GL_ATTRIBUTE_MATRICES
     #define VIEW_MATRIX_NAME "aViewM"
@@ -548,12 +549,12 @@
     }
 }
 
-void genInputColor(GrGLProgram::ProgramDesc::ColorType colorType,
+void genInputColor(GrGLProgram::ProgramDesc::ColorInput colorInput,
                    GrGLProgram::CachedData* programData,
                    ShaderCodeSegments* segments,
                    GrStringBuilder* inColor) {
-    switch (colorType) {
-        case GrGLProgram::ProgramDesc::kAttribute_ColorType: {
+    switch (colorInput) {
+        case GrGLProgram::ProgramDesc::kAttribute_ColorInput: {
             segments->fVSAttrs.push_back().set(GrGLShaderVar::kVec4f_Type,
                                                COL_ATTR_NAME);
             const char *vsName, *fsName;
@@ -561,16 +562,16 @@
             segments->fVSCode.appendf("\t%s = " COL_ATTR_NAME ";\n", vsName);
             *inColor = fsName;
             } break;
-        case GrGLProgram::ProgramDesc::kUniform_ColorType:
+        case GrGLProgram::ProgramDesc::kUniform_ColorInput:
             segments->fFSUnis.push_back().set(GrGLShaderVar::kVec4f_Type,
                                               COL_UNI_NAME);
             programData->fUniLocations.fColorUni = kUseUniform;
             *inColor = COL_UNI_NAME;
             break;
-        case GrGLProgram::ProgramDesc::kTransBlack_ColorType:
+        case GrGLProgram::ProgramDesc::kTransBlack_ColorInput:
             GrAssert(!"needComputedColor should be false.");
             break;
-        case GrGLProgram::ProgramDesc::kSolidWhite_ColorType:
+        case GrGLProgram::ProgramDesc::kSolidWhite_ColorInput:
             break;
         default:
             GrCrash("Unknown color type.");
@@ -655,7 +656,7 @@
     // If we know the final color is going to be all zeros then we can
     // simplify the color filter coeffecients. needComputedColor will then
     // come out false below.
-    if (ProgramDesc::kTransBlack_ColorType == fProgramDesc.fColorType) {
+    if (ProgramDesc::kTransBlack_ColorInput == fProgramDesc.fColorInput) {
         colorCoeff = SkXfermode::kZero_Coeff;
         if (SkXfermode::kDC_Coeff == uniformCoeff ||
             SkXfermode::kDA_Coeff == uniformCoeff) {
@@ -698,7 +699,7 @@
     GrStringBuilder inColor;
 
     if (needComputedColor) {
-        genInputColor((ProgramDesc::ColorType) fProgramDesc.fColorType,
+        genInputColor((ProgramDesc::ColorInput) fProgramDesc.fColorInput,
                       programData, &segments, &inColor);
     }
 
@@ -762,7 +763,7 @@
     // if have all ones or zeros for the "dst" input to the color filter then we
     // may be able to make additional optimizations.
     if (needColorFilterUniform && needComputedColor && !inColor.size()) {
-        GrAssert(ProgramDesc::kSolidWhite_ColorType == fProgramDesc.fColorType);
+        GrAssert(ProgramDesc::kSolidWhite_ColorInput == fProgramDesc.fColorInput);
         bool uniformCoeffIsZero = SkXfermode::kIDC_Coeff == uniformCoeff ||
                                   SkXfermode::kIDA_Coeff == uniformCoeff;
         if (uniformCoeffIsZero) {
@@ -791,7 +792,7 @@
         if (inColor.size()) {
             color = inColor.c_str();
         } else {
-            if (ProgramDesc::kSolidWhite_ColorType == fProgramDesc.fColorType) {
+            if (ProgramDesc::kSolidWhite_ColorInput == fProgramDesc.fColorInput) {
                 color = all_ones_vec(4);
             } else {
                 color = all_zeros_vec(4);
@@ -1480,7 +1481,7 @@
 }
 
 void genConvolutionVS(int stageNum,
-                      const GrGLProgram::ProgramDesc::StageDesc& desc,
+                      const StageDesc& desc,
                       ShaderCodeSegments* segments,
                       GrGLProgram::StageUniLocations* locations,
                       const char** kernelName,
@@ -1510,7 +1511,7 @@
 }
 
 void genConvolutionFS(int stageNum,
-                      const GrGLProgram::ProgramDesc::StageDesc& desc,
+                      const StageDesc& desc,
                       ShaderCodeSegments* segments,
                       const char* samplerName,
                       const char* kernelName,
@@ -1634,7 +1635,7 @@
 
     const char* kernelName = NULL;
     const char* imageIncrementName = NULL;
-    if (ProgramDesc::StageDesc::kConvolution_FetchMode == desc.fFetchMode) {
+    if (StageDesc::kConvolution_FetchMode == desc.fFetchMode) {
         genConvolutionVS(stageNum, desc, segments, locations,
                          &kernelName, &imageIncrementName, varyingVSName);
     }
@@ -1701,7 +1702,7 @@
     };
 
     const char* smear;
-    if (desc.fModulation == StageDesc::kAlpha_Modulation) {
+    if (desc.fInputConfig == StageDesc::kAlphaOnly_InputConfig) {
         smear = ".aaaa";
     } else {
         smear = "";
@@ -1733,7 +1734,7 @@
             samplerName, texelSizeName, smear, fsOutColor,
             texFunc, modulate, complexCoord, coordDims);
         break;
-    case ProgramDesc::StageDesc::kConvolution_FetchMode:
+    case StageDesc::kConvolution_FetchMode:
         genConvolutionFS(stageNum, desc, segments,
             samplerName, kernelName, smear, imageIncrementName, fsOutColor,
             sampleCoords, texFunc, modulate);
diff --git a/src/gpu/GrGLProgram.h b/src/gpu/GrGLProgram.h
index 58e24d9..53bc0d8 100644
--- a/src/gpu/GrGLProgram.h
+++ b/src/gpu/GrGLProgram.h
@@ -109,12 +109,6 @@
                 kCustomTextureDomain_OptFlagBit = 1 << 2,
                 kIsEnabled_OptFlagBit           = 1 << 7
             };
-            enum Modulation {
-                kColor_Modulation,
-                kAlpha_Modulation,
-
-                kModulationCnt
-            };
             enum FetchMode {
                 kSingle_FetchMode,
                 k2x2_FetchMode,
@@ -122,6 +116,20 @@
 
                 kFetchModeCnt,
             };
+            enum InputConfig {
+                /**
+                  The texture has r,g,b, and optionally a.
+                 */
+                kColor_InputConfig,
+                /**
+                  The texture is alpha only. This should only be used if the
+                  caller is unable to map the r,g,b sample values to the
+                  texture's alpha channel (GL_ARB_texture_swizzle).
+                */
+                kAlphaOnly_InputConfig,
+
+                kInputConfigCnt
+            };
             enum CoordMapping {
                 kIdentity_CoordMapping,
                 kRadialGradient_CoordMapping,
@@ -134,8 +142,8 @@
             };
 
             uint8_t fOptFlags;
-            uint8_t fModulation;  // casts to enum Modulation
-            uint8_t fFetchMode;  // casts to enum FetchMode
+            uint8_t fInputConfig;   // casts to enum InputConfig
+            uint8_t fFetchMode;     // casts to enum FetchMode
             uint8_t fCoordMapping;  // casts to enum CoordMapping
             uint8_t fKernelWidth;
 
@@ -153,13 +161,13 @@
 
         // Specifies where the intitial color comes from before the stages are
         // applied.
-        enum ColorType {
-            kSolidWhite_ColorType,
-            kTransBlack_ColorType,
-            kAttribute_ColorType,
-            kUniform_ColorType,
+        enum ColorInput {
+            kSolidWhite_ColorInput,
+            kTransBlack_ColorInput,
+            kAttribute_ColorInput,
+            kUniform_ColorInput,
 
-            kColorTypeCnt
+            kColorInputCnt
         };
         // Dual-src blending makes use of a secondary output color that can be
         // used as a per-pixel blend coeffecient. This controls whether a
@@ -186,8 +194,8 @@
         bool fExperimentalGS;
 #endif
 
-        uint8_t fColorType;  // casts to enum ColorType
-        uint8_t fDualSrcOutput;  // casts to enum DualSrcOutput
+        uint8_t fColorInput;        // casts to enum ColorInput
+        uint8_t fDualSrcOutput;     // casts to enum DualSrcOutput
         int8_t fFirstCoverageStage;
         SkBool8 fEmitsPointSize;
         SkBool8 fEdgeAAConcave;
diff --git a/src/gpu/GrGpuGL.cpp b/src/gpu/GrGpuGL.cpp
index bae4f77..a3562b2 100644
--- a/src/gpu/GrGpuGL.cpp
+++ b/src/gpu/GrGpuGL.cpp
@@ -395,6 +395,13 @@
     }
 
     if (kDesktop_GrGLBinding == this->glBinding()) {
+        fGLCaps.fTextureSwizzle = this->glVersion() >= GR_GL_VER(3,3) ||
+                                  this->hasExtension("GL_ARB_texture_swizzle");
+    } else {
+        fGLCaps.fTextureSwizzle = false;
+    }
+
+    if (kDesktop_GrGLBinding == this->glBinding()) {
         fCaps.fBufferLockSupport = true; // we require VBO support and the desktop VBO
                                          // extension includes glMapBuffer.
     } else {
@@ -1019,6 +1026,40 @@
 }
 #endif
 
+namespace {
+void set_tex_swizzle(GrPixelConfig config, const GrGLInterface* gl) {
+    // Today we always use GL_ALPHA for kAlpha_8_GrPixelConfig. However,
+    // this format is deprecated sometimes isn't a renderable format. If we
+    // were to spoof it in the future with GL_RED we'd want to notice that
+    // here.
+    // This isn't recorded in our tex params struct becauase we infer it
+    // from the pixel config.
+    const GrGLint* swiz;
+    if (GrPixelConfigIsAlphaOnly(config)) {
+        static const GrGLint gAlphaSwiz[] = {GR_GL_ALPHA, GR_GL_ALPHA,
+                                             GR_GL_ALPHA, GR_GL_ALPHA};
+        swiz = gAlphaSwiz;
+    } else {
+        static const GrGLint gColorSwiz[] = {GR_GL_RED,  GR_GL_GREEN,
+                                             GR_GL_BLUE, GR_GL_ALPHA};
+        swiz = gColorSwiz;
+    }
+    // should add texparameteri to interface to make 1 instead of 4 calls here
+    GR_GL_CALL(gl, TexParameteri(GR_GL_TEXTURE_2D,
+                                 GR_GL_TEXTURE_SWIZZLE_R,
+                                 swiz[0]));
+    GR_GL_CALL(gl, TexParameteri(GR_GL_TEXTURE_2D,
+                                 GR_GL_TEXTURE_SWIZZLE_G,
+                                 swiz[1]));
+    GR_GL_CALL(gl, TexParameteri(GR_GL_TEXTURE_2D,
+                                 GR_GL_TEXTURE_SWIZZLE_B,
+                                 swiz[2]));
+    GR_GL_CALL(gl, TexParameteri(GR_GL_TEXTURE_2D,
+                                 GR_GL_TEXTURE_SWIZZLE_A,
+                                 swiz[3]));
+}
+}
+
 GrTexture* GrGpuGL::onCreateTexture(const GrTextureDesc& desc,
                                     const void* srcData,
                                     size_t rowBytes) {
@@ -1118,7 +1159,9 @@
     GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
                           GR_GL_TEXTURE_WRAP_T,
                           DEFAULT_TEX_PARAMS.fWrapT));
-
+    if (fGLCaps.fTextureSwizzle) {
+        set_tex_swizzle(desc.fConfig, this->glInterface());
+    }
     this->allocateAndUploadTexData(glTexDesc, internalFormat,srcData, rowBytes);
 
     GrGLTexture* tex;
@@ -2055,6 +2098,9 @@
                 GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
                                       GR_GL_TEXTURE_WRAP_T,
                                       newTexParams.fWrapT));
+                if (this->glCaps().fTextureSwizzle) {
+                    set_tex_swizzle(nextTexture->config(), this->glInterface());
+                }
             } else {
                 if (newTexParams.fFilter != oldTexParams.fFilter) {
                     setTextureUnit(s);
@@ -2389,4 +2435,6 @@
     GrPrintf("Max FS Uniform Vectors: %d\n", fMaxFragmentUniformVectors);
     GrPrintf("Support RGBA8 Render Buffer: %s\n",
              (fRGBA8Renderbuffer ? "YES": "NO"));
+    GrPrintf("Support texture swizzle: %s\n",
+             (fTextureSwizzle ? "YES": "NO"));
 }
diff --git a/src/gpu/GrGpuGL.h b/src/gpu/GrGpuGL.h
index 0addf4a..3f10967 100644
--- a/src/gpu/GrGpuGL.h
+++ b/src/gpu/GrGpuGL.h
@@ -22,6 +22,7 @@
 #include "SkString.h"
 
 class GrGpuGL : public GrGpu {
+
 public:
     virtual ~GrGpuGL();
 
@@ -32,6 +33,56 @@
 protected:
     GrGpuGL(const GrGLInterface* glInterface, GrGLBinding glBinding);
 
+    struct GLCaps {
+        GLCaps()
+            // make defaults be the most restrictive
+            : fMSFBOType(kNone_MSFBO)
+            , fMaxFragmentUniformVectors(0)
+            , fRGBA8Renderbuffer(false)
+            , fBGRAFormat(false)
+            , fStencilFormats(8) // prealloc space for    stencil formats
+            , fTextureSwizzle(false) {
+            memset(fAASamples, 0, sizeof(fAASamples));
+        }
+        SkTArray<GrGLStencilBuffer::Format, true> fStencilFormats;
+    
+        enum {
+            /**
+             * no support for MSAA FBOs
+             */
+            kNone_MSFBO = 0,  
+            /**
+             * GL3.0-style MSAA FBO (GL_ARB_framebuffer_object)
+             */
+            kDesktopARB_MSFBO,
+            /**
+             * earlier GL_EXT_framebuffer* extensions
+             */
+            kDesktopEXT_MSFBO,
+            /**
+             * GL_APPLE_framebuffer_multisample ES extension
+             */
+            kAppleES_MSFBO,
+        } fMSFBOType;
+    
+        // TODO: get rid of GrAALevel and use sample cnt directly
+        GrGLuint fAASamples[4];
+    
+        // The maximum number of fragment uniform vectors (GLES has min. 16).
+        int fMaxFragmentUniformVectors;
+    
+        // ES requires an extension to support RGBA8 in RenderBufferStorage
+        bool fRGBA8Renderbuffer;
+    
+        // Is GL_BGRA supported
+        bool fBGRAFormat;
+    
+        // GL_ARB_texture_swizzle support
+        bool fTextureSwizzle;
+    
+        void print() const;
+    } fGLCaps;
+ 
     struct {
         size_t                  fVertexOffset;
         GrVertexLayout          fVertexLayout;
@@ -69,6 +120,8 @@
         GrGLIRect   fViewportRect;
     } fHWBounds;
 
+    const GLCaps& glCaps() const { return fGLCaps; }
+
     // GrGpu overrides
     virtual void onResetContext() SK_OVERRIDE;
 
@@ -207,43 +260,6 @@
     SkString fExtensionString;
     GrGLVersion fGLVersion;
 
-    struct GLCaps {
-        // prealloc space for 8 stencil formats
-        GLCaps() : fStencilFormats(8) {}
-        SkTArray<GrGLStencilBuffer::Format, true> fStencilFormats;
-
-        enum {
-            /**
-             * no support for MSAA FBOs
-             */
-            kNone_MSFBO = 0,  
-            /**
-             * GL3.0-style MSAA FBO (GL_ARB_framebuffer_object)
-             */
-            kDesktopARB_MSFBO,
-            /**
-             * earlier GL_EXT_framebuffer* extensions
-             */
-            kDesktopEXT_MSFBO,
-            /**
-             * GL_APPLE_framebuffer_multisample ES extension
-             */
-            kAppleES_MSFBO,
-        } fMSFBOType;
-
-        // TODO: get rid of GrAALevel and use sample cnt directly
-        GrGLuint fAASamples[4];
-
-        // The maximum number of fragment uniform vectors (GLES has min. 16).
-        int fMaxFragmentUniformVectors;
-
-        // ES requires an extension to support RGBA8 in RenderBufferStorage
-        bool fRGBA8Renderbuffer;
-
-        void print() const;
-    } fGLCaps;
-
-
     // we want to clear stencil buffers when they are created. We want to clear
     // the entire buffer even if it is larger than the color attachment. We
     // attach it to this fbo with no color attachment to do the initial clear.
diff --git a/src/gpu/GrGpuGLShaders.cpp b/src/gpu/GrGpuGLShaders.cpp
index c287a30..e3d2c2e 100644
--- a/src/gpu/GrGpuGLShaders.cpp
+++ b/src/gpu/GrGpuGLShaders.cpp
@@ -204,8 +204,8 @@
 
         pdesc.fVertexLayout = 0;
         pdesc.fEmitsPointSize = random.nextF() > .5f;
-        pdesc.fColorType = static_cast<int>(random.nextF() *
-                                            ProgramDesc::kColorTypeCnt);
+        pdesc.fColorInput = static_cast<int>(random.nextF() *
+                                             ProgramDesc::kColorInputCnt);
 
         int idx = (int)(random.nextF() * (SkXfermode::kCoeffModesCnt));
         pdesc.fColorFilterXfermode = (SkXfermode::Mode)idx;
@@ -270,7 +270,7 @@
             idx = (int)(random.nextF() * GR_ARRAY_COUNT(STAGE_OPTS));
             StageDesc& stage = pdesc.fStages[s];
             stage.fOptFlags = STAGE_OPTS[idx];
-            stage.fModulation = random_val(&random, StageDesc::kModulationCnt);
+            stage.fInputConfig = random_val(&random, StageDesc::kInputConfigCnt);
             stage.fCoordMapping =  random_val(&random, StageDesc::kCoordMappingCnt);
             stage.fFetchMode = random_val(&random, StageDesc::kFetchModeCnt);
             // convolution shaders don't work with persp tex matrix
@@ -605,8 +605,8 @@
         // invalidate the const vertex attrib color
         fHWDrawState.fColor = GrColor_ILLEGAL;
     } else {
-        switch (desc.fColorType) {
-            case ProgramDesc::kAttribute_ColorType:
+        switch (desc.fColorInput) {
+            case ProgramDesc::kAttribute_ColorInput:
                 if (fHWDrawState.fColor != color) {
                     // OpenGL ES only supports the float varities of glVertexAttrib
                     float c[] = GR_COLOR_TO_VEC4(color);
@@ -615,7 +615,7 @@
                     fHWDrawState.fColor = color;
                 }
                 break;
-            case ProgramDesc::kUniform_ColorType:
+            case ProgramDesc::kUniform_ColorInput:
                 if (fProgramData->fColor != color) {
                     // OpenGL ES only supports the float varities of glVertexAttrib
                     float c[] = GR_COLOR_TO_VEC4(color);
@@ -626,8 +626,8 @@
                     fProgramData->fColor = color;
                 }
                 break;
-            case ProgramDesc::kSolidWhite_ColorType:
-            case ProgramDesc::kTransBlack_ColorType:
+            case ProgramDesc::kSolidWhite_ColorInput:
+            case ProgramDesc::kTransBlack_ColorInput:
                 break;
             default:
                 GrCrash("Unknown color type.");
@@ -882,7 +882,7 @@
 
     bool requiresAttributeColors = 
         !skipColor && SkToBool(desc.fVertexLayout & kColor_VertexLayoutBit);
-    // fColorType records how colors are specified for the program. Strip
+    // fColorInput records how colors are specified for the program. Strip
     // the bit from the layout to avoid false negatives when searching for an
     // existing program in the cache.
     desc.fVertexLayout &= ~(kColor_VertexLayoutBit);
@@ -903,13 +903,13 @@
                              (!requiresAttributeColors &&
                               0xffffffff == fCurrDrawState.fColor);
     if (GR_AGGRESSIVE_SHADER_OPTS && colorIsTransBlack) {
-        desc.fColorType = ProgramDesc::kTransBlack_ColorType;
+        desc.fColorInput = ProgramDesc::kTransBlack_ColorInput;
     } else if (GR_AGGRESSIVE_SHADER_OPTS && colorIsSolidWhite) {
-        desc.fColorType = ProgramDesc::kSolidWhite_ColorType;
+        desc.fColorInput = ProgramDesc::kSolidWhite_ColorInput;
     } else if (GR_GL_NO_CONSTANT_ATTRIBUTES && !requiresAttributeColors) {
-        desc.fColorType = ProgramDesc::kUniform_ColorType;
+        desc.fColorInput = ProgramDesc::kUniform_ColorInput;
     } else {
-        desc.fColorType = ProgramDesc::kAttribute_ColorType;
+        desc.fColorInput = ProgramDesc::kAttribute_ColorInput;
     }
 
     desc.fEdgeAANumEdges = skipCoverage ? 0 : fCurrDrawState.fEdgeAANumEdges;
@@ -999,10 +999,14 @@
                 stage.fOptFlags |= StageDesc::kCustomTextureDomain_OptFlagBit;
             }
 
-            if (GrPixelConfigIsAlphaOnly(texture->config())) {
-                stage.fModulation = StageDesc::kAlpha_Modulation;
+            if (!this->glCaps().fTextureSwizzle &&
+                GrPixelConfigIsAlphaOnly(texture->config())) {
+                // if we don't have texture swizzle support then
+                // the shader must do an alpha smear after reading
+                // the texture
+                stage.fInputConfig = StageDesc::kAlphaOnly_InputConfig;
             } else {
-                stage.fModulation = StageDesc::kColor_Modulation;
+                stage.fInputConfig = StageDesc::kColor_InputConfig;
             }
             if (sampler.getFilter() == GrSamplerState::kConvolution_Filter) {
                 stage.fKernelWidth = sampler.getKernelWidth();
@@ -1012,9 +1016,9 @@
         } else {
             stage.fOptFlags     = 0;
             stage.fCoordMapping = (StageDesc::CoordMapping)0;
-            stage.fModulation   = (StageDesc::Modulation)0;
-            stage.fFetchMode = (StageDesc::FetchMode) 0;
-            stage.fKernelWidth = 0;
+            stage.fInputConfig  = (StageDesc::InputConfig)0;
+            stage.fFetchMode    = (StageDesc::FetchMode) 0;
+            stage.fKernelWidth  = 0;
         }
     }