idctdsp.c 10.3 KB
Newer Older
1
/*
2
 * This file is part of FFmpeg.
3
 *
4
 * FFmpeg is free software; you can redistribute it and/or
5 6 7 8
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
9
 * FFmpeg is distributed in the hope that it will be useful,
10 11 12 13 14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with FFmpeg; if not, write to the Free Software
16 17 18 19 20 21 22 23 24 25 26
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "config.h"
#include "libavutil/attributes.h"
#include "libavutil/common.h"
#include "avcodec.h"
#include "dct.h"
#include "faanidct.h"
#include "idctdsp.h"
#include "simple_idct.h"
27
#include "xvididct.h"
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st,
                               const uint8_t *src_scantable)
{
    int i, end;

    st->scantable = src_scantable;

    for (i = 0; i < 64; i++) {
        int j = src_scantable[i];
        st->permutated[i] = permutation[j];
    }

    end = -1;
    for (i = 0; i < 64; i++) {
        int j = st->permutated[i];
        if (j > end)
            end = j;
        st->raster_end[i] = end;
    }
}

av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation,
51
                                           enum idct_permutation_type perm_type)
52 53 54 55 56
{
    int i;

    if (ARCH_X86)
        if (ff_init_scantable_permutation_x86(idct_permutation,
57
                                              perm_type))
58 59
            return;

60 61
    switch (perm_type) {
    case FF_IDCT_PERM_NONE:
62 63 64
        for (i = 0; i < 64; i++)
            idct_permutation[i] = i;
        break;
65
    case FF_IDCT_PERM_LIBMPEG2:
66 67 68
        for (i = 0; i < 64; i++)
            idct_permutation[i] = (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
        break;
69
    case FF_IDCT_PERM_TRANSPOSE:
70 71 72
        for (i = 0; i < 64; i++)
            idct_permutation[i] = ((i & 7) << 3) | (i >> 3);
        break;
73
    case FF_IDCT_PERM_PARTTRANS:
74 75 76 77 78 79 80 81 82
        for (i = 0; i < 64; i++)
            idct_permutation[i] = (i & 0x24) | ((i & 3) << 3) | ((i >> 3) & 3);
        break;
    default:
        av_log(NULL, AV_LOG_ERROR,
               "Internal error, IDCT permutation not set\n");
    }
}

83 84
void ff_put_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
                             ptrdiff_t line_size)
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
{
    int i;

    /* read the pixels */
    for (i = 0; i < 8; i++) {
        pixels[0] = av_clip_uint8(block[0]);
        pixels[1] = av_clip_uint8(block[1]);
        pixels[2] = av_clip_uint8(block[2]);
        pixels[3] = av_clip_uint8(block[3]);
        pixels[4] = av_clip_uint8(block[4]);
        pixels[5] = av_clip_uint8(block[5]);
        pixels[6] = av_clip_uint8(block[6]);
        pixels[7] = av_clip_uint8(block[7]);

        pixels += line_size;
        block  += 8;
    }
}

104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
static void put_pixels_clamped4_c(const int16_t *block, uint8_t *av_restrict pixels,
                                 int line_size)
{
    int i;

    /* read the pixels */
    for(i=0;i<4;i++) {
        pixels[0] = av_clip_uint8(block[0]);
        pixels[1] = av_clip_uint8(block[1]);
        pixels[2] = av_clip_uint8(block[2]);
        pixels[3] = av_clip_uint8(block[3]);

        pixels += line_size;
        block += 8;
    }
}

static void put_pixels_clamped2_c(const int16_t *block, uint8_t *av_restrict pixels,
                                 int line_size)
{
    int i;

    /* read the pixels */
    for(i=0;i<2;i++) {
        pixels[0] = av_clip_uint8(block[0]);
        pixels[1] = av_clip_uint8(block[1]);

        pixels += line_size;
        block += 8;
    }
}

136
static void put_signed_pixels_clamped_c(const int16_t *block,
137
                                        uint8_t *av_restrict pixels,
138
                                        ptrdiff_t line_size)
139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
{
    int i, j;

    for (i = 0; i < 8; i++) {
        for (j = 0; j < 8; j++) {
            if (*block < -128)
                *pixels = 0;
            else if (*block > 127)
                *pixels = 255;
            else
                *pixels = (uint8_t) (*block + 128);
            block++;
            pixels++;
        }
        pixels += (line_size - 8);
    }
}

157 158
void ff_add_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
                             ptrdiff_t line_size)
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
{
    int i;

    /* read the pixels */
    for (i = 0; i < 8; i++) {
        pixels[0] = av_clip_uint8(pixels[0] + block[0]);
        pixels[1] = av_clip_uint8(pixels[1] + block[1]);
        pixels[2] = av_clip_uint8(pixels[2] + block[2]);
        pixels[3] = av_clip_uint8(pixels[3] + block[3]);
        pixels[4] = av_clip_uint8(pixels[4] + block[4]);
        pixels[5] = av_clip_uint8(pixels[5] + block[5]);
        pixels[6] = av_clip_uint8(pixels[6] + block[6]);
        pixels[7] = av_clip_uint8(pixels[7] + block[7]);
        pixels   += line_size;
        block    += 8;
    }
}

177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
static void add_pixels_clamped4_c(const int16_t *block, uint8_t *av_restrict pixels,
                          int line_size)
{
    int i;

    /* read the pixels */
    for(i=0;i<4;i++) {
        pixels[0] = av_clip_uint8(pixels[0] + block[0]);
        pixels[1] = av_clip_uint8(pixels[1] + block[1]);
        pixels[2] = av_clip_uint8(pixels[2] + block[2]);
        pixels[3] = av_clip_uint8(pixels[3] + block[3]);
        pixels += line_size;
        block += 8;
    }
}

static void add_pixels_clamped2_c(const int16_t *block, uint8_t *av_restrict pixels,
                          int line_size)
{
    int i;

    /* read the pixels */
    for(i=0;i<2;i++) {
        pixels[0] = av_clip_uint8(pixels[0] + block[0]);
        pixels[1] = av_clip_uint8(pixels[1] + block[1]);
        pixels += line_size;
        block += 8;
    }
}

James Almer's avatar
James Almer committed
207
static void ff_jref_idct4_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
208 209 210 211
{
    ff_j_rev_dct4 (block);
    put_pixels_clamped4_c(block, dest, line_size);
}
James Almer's avatar
James Almer committed
212
static void ff_jref_idct4_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
213 214 215 216 217
{
    ff_j_rev_dct4 (block);
    add_pixels_clamped4_c(block, dest, line_size);
}

James Almer's avatar
James Almer committed
218
static void ff_jref_idct2_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
219 220 221 222
{
    ff_j_rev_dct2 (block);
    put_pixels_clamped2_c(block, dest, line_size);
}
James Almer's avatar
James Almer committed
223
static void ff_jref_idct2_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
224 225 226 227 228
{
    ff_j_rev_dct2 (block);
    add_pixels_clamped2_c(block, dest, line_size);
}

James Almer's avatar
James Almer committed
229
static void ff_jref_idct1_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
230 231 232
{
    dest[0] = av_clip_uint8((block[0] + 4)>>3);
}
James Almer's avatar
James Almer committed
233
static void ff_jref_idct1_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
234 235 236
{
    dest[0] = av_clip_uint8(dest[0] + ((block[0] + 4)>>3));
}
237 238 239 240 241

av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
{
    const unsigned high_bit_depth = avctx->bits_per_raw_sample > 8;

242
    if (avctx->lowres==1) {
243 244 245 246
        c->idct_put  = ff_jref_idct4_put;
        c->idct_add  = ff_jref_idct4_add;
        c->idct      = ff_j_rev_dct4;
        c->perm_type = FF_IDCT_PERM_NONE;
247
    } else if (avctx->lowres==2) {
248 249 250 251
        c->idct_put  = ff_jref_idct2_put;
        c->idct_add  = ff_jref_idct2_add;
        c->idct      = ff_j_rev_dct2;
        c->perm_type = FF_IDCT_PERM_NONE;
252
    } else if (avctx->lowres==3) {
253 254 255
        c->idct_put  = ff_jref_idct1_put;
        c->idct_add  = ff_jref_idct1_add;
        c->idct      = ff_j_rev_dct1;
256
        c->perm_type = FF_IDCT_PERM_NONE;
257
    } else {
258
        if (avctx->bits_per_raw_sample == 10 || avctx->bits_per_raw_sample == 9) {
259 260
            /* 10-bit MPEG-4 Simple Studio Profile requires a higher precision IDCT
               However, it only uses idct_put */
261
            if (c->mpeg4_studio_profile) {
262
                c->idct_put              = ff_simple_idct_put_int32_10bit;
263 264 265
                c->idct_add              = NULL;
                c->idct                  = NULL;
            } else {
266 267 268 269
                c->idct_put              = ff_simple_idct_put_int16_10bit;
                c->idct_add              = ff_simple_idct_add_int16_10bit;
                c->idct                  = ff_simple_idct_int16_10bit;
            }
270
            c->perm_type             = FF_IDCT_PERM_NONE;
271
        } else if (avctx->bits_per_raw_sample == 12) {
272 273 274
            c->idct_put              = ff_simple_idct_put_int16_12bit;
            c->idct_add              = ff_simple_idct_add_int16_12bit;
            c->idct                  = ff_simple_idct_int16_12bit;
275
            c->perm_type             = FF_IDCT_PERM_NONE;
276
        } else {
277
            if (avctx->idct_algo == FF_IDCT_INT) {
278 279
                c->idct_put  = ff_jref_idct_put;
                c->idct_add  = ff_jref_idct_add;
280 281
                c->idct      = ff_j_rev_dct;
                c->perm_type = FF_IDCT_PERM_LIBMPEG2;
282
#if CONFIG_FAANIDCT
283 284 285 286 287
            } else if (avctx->idct_algo == FF_IDCT_FAAN) {
                c->idct_put  = ff_faanidct_put;
                c->idct_add  = ff_faanidct_add;
                c->idct      = ff_faanidct;
                c->perm_type = FF_IDCT_PERM_NONE;
288
#endif /* CONFIG_FAANIDCT */
289
            } else { // accurate/default
290
                /* Be sure FF_IDCT_NONE will select this one, since it uses FF_IDCT_PERM_NONE */
291 292 293
                c->idct_put  = ff_simple_idct_put_int16_8bit;
                c->idct_add  = ff_simple_idct_add_int16_8bit;
                c->idct      = ff_simple_idct_int16_8bit;
294 295
                c->perm_type = FF_IDCT_PERM_NONE;
            }
296
        }
297 298
    }

299
    c->put_pixels_clamped        = ff_put_pixels_clamped_c;
300
    c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
301
    c->add_pixels_clamped        = ff_add_pixels_clamped_c;
302

303
    if (CONFIG_MPEG4_DECODER && avctx->idct_algo == FF_IDCT_XVID)
304
        ff_xvid_idct_init(c, avctx);
305

306 307
    if (ARCH_AARCH64)
        ff_idctdsp_init_aarch64(c, avctx, high_bit_depth);
308 309
    if (ARCH_ALPHA)
        ff_idctdsp_init_alpha(c, avctx, high_bit_depth);
310 311 312 313 314 315
    if (ARCH_ARM)
        ff_idctdsp_init_arm(c, avctx, high_bit_depth);
    if (ARCH_PPC)
        ff_idctdsp_init_ppc(c, avctx, high_bit_depth);
    if (ARCH_X86)
        ff_idctdsp_init_x86(c, avctx, high_bit_depth);
316 317
    if (ARCH_MIPS)
        ff_idctdsp_init_mips(c, avctx, high_bit_depth);
318 319

    ff_init_scantable_permutation(c->idct_permutation,
320
                                  c->perm_type);
321
}