Partial template specialization for function

Hello,

I've got a template function:

template <typename U, typename T>
void func(ColourImage<U> &input,GrayImage<T> &out_r, GrayImage<T>
&out_g, GrayImage<T> &out_b);

and I would like to specialize it for U = unsigned char. So I wrote

template <u8, typename T>
void func(ColourImage<u8> &input, GrayImage<T> &out_r, GrayImage<T>
&out_g, GrayImage<T> &out_b);

But the specialization never gets called. And I have no idea why.
Could someone explain me what I am doing wrong? The code is below, and
all the action happens at the very bottom.

Thanks

ALex

#include <windows.h>
#include <iostream>
#include <math.h>

typedef unsigned char u8;
typedef float f32;

////////////////////
///// MEMORY ROUTINES
////////////////////

enum { MemoryAlignment=64};

void* AllocateMemory(size_t size)
{
    return _aligned_malloc(size, MemoryAlignment);
}

void ReleaseMemory(void *memblock)
{
    return _aligned_free(memblock);
}

int ComputeAlignedWidth(int width)
{
    int alignment_needed = MemoryAlignment / sizeof(float);
    return (int)ceil((float)width/(float)alignment_needed) *
alignment_needed;
}

////////////////////
///// CLASS DECLARATION
////////////////////

template <typename T>
struct Image
{
public: // members
    // std information
    int width, height, depth;

    // actual width of the buffer
    // buffer holding image data is padded to be a multiple
    // of MemoryAlignment for optimisation purposes
    int width_padded;

    // dimensions helper
    int firstRow, lastRow, firstCol, lastCol;

    // pointer to the image data
    T* data;

public: // methods
    // ctor
    Image():
        width(0),height(0),depth(0),
        width_padded(0),
        firstRow(0), lastRow(0), firstCol(0), lastCol(0),
        data(NULL)
    {
    }

    // dtor
    ~Image()
    {
    }

    // memory management
    void Allocate() { data =
static_cast<T*>(AllocateMemory(width_padded*height*depth*sizeof(T)));}
    void Release () { ReleaseMemory(data);}

    // pixel access
    // virtual T& operator() (int row, int col)

    // dimensions management
    void SetDimensions(int h, int w, int d){
        height = h;
        width = w;
        depth = d;
        width_padded = ComputeAlignedWidth(width);
        firstRow = 0;
        firstCol = 0;
        lastRow = height-1;
        lastCol = width-1;
    }

    // size information
    int GetTotalSize(bool padded=false){
        if (padded) return width_padded*height*depth*sizeof(T);
        else return width *height*depth*sizeof(T);
    }
    int GetImageSize(bool padded=false){
        if (padded) return width_padded*height*depth;
        else return width *height*depth;
    }
    int GetPlaneSize(bool padded=false){
        if (padded) return width_padded*height;
        else return width *height;
    }

};

template <typename T>
struct GrayImage : public Image<T>
{
public: // methods
    // ctor
    GrayImage():
        Image()
    {
        depth=1;
    }

    // pixel access
    T& operator() (int row, int col)
    {
        return data[row*width_padded + col];
    }
};

template <typename T>
struct ColourImage : public Image<T>
{
public: // methods
    // ctor
    ColourImage():
        Image()
    {
        depth=3;
    }

    // pixel access
    T& operator() (int row, int col, int channel)
    {
        return data[(row*width_padded + col)*3 + channel];
    }
};

template <typename U, typename T>
void MapFrom_sRGB(ColourImage<U> &input,
                  GrayImage<T> &out_r, GrayImage<T> &out_g,
GrayImage<T> &out_b)
{
    std::cout << "not partial" << std::endl;
}

template <u8, typename T>
void MapFrom_sRGB(ColourImage<u8> &input,
                  GrayImage<T> &out_r, GrayImage<T> &out_g,
GrayImage<T> &out_b)
{
    cout << "partial" << endl;
}

int main(int argc, char* argv[])
{
    ColourImage<u8> input;
    GrayImage<f32> output1, output2, output3;

    input.SetDimensions(2000, 2000, 3); input.Allocate();
    output1.SetDimensions(input.height, input.width, 1);
output1.Allocate();
    output2.SetDimensions(input.height, input.width, 1);
output2.Allocate();
    output3.SetDimensions(input.height, input.width, 1);
output3.Allocate();

    MapFrom_sRGB(input, output1, output2, output3);

    input.Release(); output1.Release(); output2.Release();
output3.Release();

    return 0;
}