Alla ricerca di trasformata in coseno discreta 8x8 (o NXN) (DCT)/IDCT pseudo-code [chiuso

Question

Sto cercando Google da un po 'di tempo per trovare pseudo-codice di un algoritmo DCT 8x8 (o NXN) decentemente efficiente e non riesco a trovare nulla!

Ho implementato l'approccio ingenuo e ci è voluto troppo tempo per eseguire.

Se potessi pubblicare un po 'di pseudo-codice o fare riferimento a un buon libro/documento/sito Web, sarebbe utile.

Gli esempi di C o C ++ sarebbero ancora migliori!

Answer 1

Come richiesto nei commenti, fonte (sii leggermente avvisato, è in C#, ma la differenza con C ++ dovrebbe essere minima, e sì, so che il codice è zoppo):

Loop principale (a = risultato, b = input):

for (int y = 0; y < 8; y++)
{
    for (int x = 0; x < 8; x++)
    {
        A[y * 8 + x] = 0;
        for (int u = 0; u < 8; u++)
            for (int v = 0; v < 8; v++)
                A[y * 8 + x] += alpha(u) * alpha(v) * B[u, v] *
                    cosine[u, x] * cosine[v, y];
    }
}

Stuff di supporto:

static double alpha(int i)
{
    if (i == 0)
        return SQRT2o2 * 0.5;
    return 0.5;
}
const double SQRT2o2 = 1.414213562373095048801688724209 * 0.5;
cosine = new double[8, 8];
const double inv16 = 1.0 / 16.0;
for (int i = 0; i < 8; i++)
{
     for (int j = 0; j < 8; j++)
     {
         cosine[j, i] = Math.Cos(Math.PI * j * (2.0 * i + 1) * inv16);
     }
}

Modifica: l'ho cronometrato - per 512 per 512 pixel (canale singolo) ci vuole mezzo secondo. Certo è lento, ma da nessuna parte vicino "per sempre".

Answer 2

Fftw ha un'implementazione open source efficiente