static void get_slice_data(ProresContext *ctx, const uint16_t *src,

                           int linesize, int x, int y, int w, int h,

                           DCTELEM *blocks, uint16_t *emu_buf,

                           int mbs_per_slice, int blocks_per_mb, int is_chroma)

{

    const uint16_t *esrc;

    const int mb_width = 4 * blocks_per_mb;

    int elinesize;

    int i, j, k;



    for (i = 0; i < mbs_per_slice; i++, src += mb_width) {

        if (x >= w) {

            memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb

                              * sizeof(*blocks));

            return;

        }

        if (x + mb_width <= w && y + 16 <= h) {

            esrc      = src;

            elinesize = linesize;

        } else {

            int bw, bh, pix;



            esrc      = emu_buf;

            elinesize = 16 * sizeof(*emu_buf);



            bw = FFMIN(w - x, mb_width);

            bh = FFMIN(h - y, 16);



            for (j = 0; j < bh; j++) {

                memcpy(emu_buf + j * 16,

                       (const uint8_t*)src + j * linesize,

                       bw * sizeof(*src));

                pix = emu_buf[j * 16 + bw - 1];

                for (k = bw; k < mb_width; k++)

                    emu_buf[j * 16 + k] = pix;

            }

            for (; j < 16; j++)

                memcpy(emu_buf + j * 16,

                       emu_buf + (bh - 1) * 16,

                       mb_width * sizeof(*emu_buf));

        }

        if (!is_chroma) {

            ctx->dsp.fdct(esrc, elinesize, blocks);

            blocks += 64;

            if (blocks_per_mb > 2) {

                ctx->dsp.fdct(src + 8, linesize, blocks);

                blocks += 64;

            }

            ctx->dsp.fdct(src + linesize * 4, linesize, blocks);

            blocks += 64;

            if (blocks_per_mb > 2) {

                ctx->dsp.fdct(src + linesize * 4 + 8, linesize, blocks);

                blocks += 64;

            }

        } else {

            ctx->dsp.fdct(esrc, elinesize, blocks);

            blocks += 64;

            ctx->dsp.fdct(src + linesize * 4, linesize, blocks);

            blocks += 64;

            if (blocks_per_mb > 2) {

                ctx->dsp.fdct(src + 8, linesize, blocks);

                blocks += 64;

                ctx->dsp.fdct(src + linesize * 4 + 8, linesize, blocks);

                blocks += 64;

            }

        }



        x += mb_width;

    }

}

static void get_slice_data(ProresContext *ctx, const uint16_t *src,

                           int linesize, int x, int y, int w, int h,

                           DCTELEM *blocks, uint16_t *emu_buf,

                           int mbs_per_slice, int blocks_per_mb, int is_chroma)

{

    const uint16_t *esrc;

    const int mb_width = 4 * blocks_per_mb;

    int elinesize;

    int i, j, k;



    for (i = 0; i < mbs_per_slice; i++, src += mb_width) {

        if (x >= w) {

            memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb

                              * sizeof(*blocks));

            return;

        }

        if (x + mb_width <= w && y + 16 <= h) {

            esrc      = src;

            elinesize = linesize;

        } else {

            int bw, bh, pix;



            esrc      = emu_buf;

            elinesize = 16 * sizeof(*emu_buf);



            bw = FFMIN(w - x, mb_width);

            bh = FFMIN(h - y, 16);



            for (j = 0; j < bh; j++) {

                memcpy(emu_buf + j * 16,

                       (const uint8_t*)src + j * linesize,

                       bw * sizeof(*src));

                pix = emu_buf[j * 16 + bw - 1];

                for (k = bw; k < mb_width; k++)

                    emu_buf[j * 16 + k] = pix;

            }

            for (; j < 16; j++)

                memcpy(emu_buf + j * 16,

                       emu_buf + (bh - 1) * 16,

                       mb_width * sizeof(*emu_buf));

        }

        if (!is_chroma) {

            ctx->dsp.fdct(esrc, elinesize, blocks);

            blocks += 64;

            if (blocks_per_mb > 2) {

                ctx->dsp.fdct(src + 8, linesize, blocks);

                blocks += 64;

            }

            ctx->dsp.fdct(src + linesize * 4, linesize, blocks);

            blocks += 64;

            if (blocks_per_mb > 2) {

                ctx->dsp.fdct(src + linesize * 4 + 8, linesize, blocks);

                blocks += 64;

            }

        } else {

            ctx->dsp.fdct(esrc, elinesize, blocks);

            blocks += 64;

            ctx->dsp.fdct(src + linesize * 4, linesize, blocks);

            blocks += 64;

            if (blocks_per_mb > 2) {

                ctx->dsp.fdct(src + 8, linesize, blocks);

                blocks += 64;

                ctx->dsp.fdct(src + linesize * 4 + 8, linesize, blocks);

                blocks += 64;

            }

        }



        x += mb_width;

    }

}

static void FUNC_0(ProresContext *VAR_0, const uint16_t *VAR_1,

                           int VAR_2, int VAR_3, int VAR_4, int VAR_5, int VAR_6,

                           DCTELEM *VAR_7, uint16_t *VAR_8,

                           int VAR_9, int VAR_10, int VAR_11)

{

    const uint16_t *VAR_12;

    const int VAR_13 = 4 * VAR_10;

    int VAR_14;

    int VAR_15, VAR_16, VAR_17;



    for (VAR_15 = 0; VAR_15 < VAR_9; VAR_15++, VAR_1 += VAR_13) {

        if (VAR_3 >= VAR_5) {

            memset(VAR_7, 0, 64 * (VAR_9 - VAR_15) * VAR_10

                              * sizeof(*VAR_7));

            return;

        }

        if (VAR_3 + VAR_13 <= VAR_5 && VAR_4 + 16 <= VAR_6) {

            VAR_12      = VAR_1;

            VAR_14 = VAR_2;

        } else {

            int VAR_18, VAR_19, VAR_20;



            VAR_12      = VAR_8;

            VAR_14 = 16 * sizeof(*VAR_8);



            VAR_18 = FFMIN(VAR_5 - VAR_3, VAR_13);

            VAR_19 = FFMIN(VAR_6 - VAR_4, 16);



            for (VAR_16 = 0; VAR_16 < VAR_19; VAR_16++) {

                memcpy(VAR_8 + VAR_16 * 16,

                       (const uint8_t*)VAR_1 + VAR_16 * VAR_2,

                       VAR_18 * sizeof(*VAR_1));

                VAR_20 = VAR_8[VAR_16 * 16 + VAR_18 - 1];

                for (VAR_17 = VAR_18; VAR_17 < VAR_13; VAR_17++)

                    VAR_8[VAR_16 * 16 + VAR_17] = VAR_20;

            }

            for (; VAR_16 < 16; VAR_16++)

                memcpy(VAR_8 + VAR_16 * 16,

                       VAR_8 + (VAR_19 - 1) * 16,

                       VAR_13 * sizeof(*VAR_8));

        }

        if (!VAR_11) {

            VAR_0->dsp.fdct(VAR_12, VAR_14, VAR_7);

            VAR_7 += 64;

            if (VAR_10 > 2) {

                VAR_0->dsp.fdct(VAR_1 + 8, VAR_2, VAR_7);

                VAR_7 += 64;

            }

            VAR_0->dsp.fdct(VAR_1 + VAR_2 * 4, VAR_2, VAR_7);

            VAR_7 += 64;

            if (VAR_10 > 2) {

                VAR_0->dsp.fdct(VAR_1 + VAR_2 * 4 + 8, VAR_2, VAR_7);

                VAR_7 += 64;

            }

        } else {

            VAR_0->dsp.fdct(VAR_12, VAR_14, VAR_7);

            VAR_7 += 64;

            VAR_0->dsp.fdct(VAR_1 + VAR_2 * 4, VAR_2, VAR_7);

            VAR_7 += 64;

            if (VAR_10 > 2) {

                VAR_0->dsp.fdct(VAR_1 + 8, VAR_2, VAR_7);

                VAR_7 += 64;

                VAR_0->dsp.fdct(VAR_1 + VAR_2 * 4 + 8, VAR_2, VAR_7);

                VAR_7 += 64;

            }

        }



        VAR_3 += VAR_13;

    }

}

static void FUNC_0(ProresContext *VAR_0, const uint16_t *VAR_1,
int VAR_2, int VAR_3, int VAR_4, int VAR_5, int VAR_6,
DCTELEM *VAR_7, uint16_t *VAR_8,
int VAR_9, int VAR_10, int VAR_11)
{ const uint16_t *VAR_12; const int VAR_13 = 4 * VAR_10; int VAR_14; int VAR_15, VAR_16, VAR_17; for (VAR_15 = 0; VAR_15 < VAR_9; VAR_15++, VAR_1 += VAR_13) { if (VAR_3 >= VAR_5) { memset(VAR_7, 0, 64 * (VAR_9 - VAR_15) * VAR_10
* sizeof(*VAR_7)); return; } if (VAR_3 + VAR_13 <= VAR_5 && VAR_4 + 16 <= VAR_6) { VAR_12      = VAR_1; VAR_14 = VAR_2; } else { int VAR_18, VAR_19, VAR_20; VAR_12      = VAR_8; VAR_14 = 16 * sizeof(*VAR_8); VAR_18 = FFMIN(VAR_5 - VAR_3, VAR_13); VAR_19 = FFMIN(VAR_6 - VAR_4, 16); for (VAR_16 = 0; VAR_16 < VAR_19; VAR_16++) { memcpy(VAR_8 + VAR_16 * 16,
(const uint8_t*)VAR_1 + VAR_16 * VAR_2,
VAR_18 * sizeof(*VAR_1)); VAR_20 = VAR_8[VAR_16 * 16 + VAR_18 - 1]; for (VAR_17 = VAR_18; VAR_17 < VAR_13; VAR_17++) VAR_8[VAR_16 * 16 + VAR_17] = VAR_20; } for (; VAR_16 < 16; VAR_16++) memcpy(VAR_8 + VAR_16 * 16,
VAR_8 + (VAR_19 - 1) * 16,
VAR_13 * sizeof(*VAR_8)); } if (!VAR_11) { VAR_0->dsp.fdct(VAR_12, VAR_14, VAR_7); VAR_7 += 64; if (VAR_10 > 2) { VAR_0->dsp.fdct(VAR_1 + 8, VAR_2, VAR_7); VAR_7 += 64; } VAR_0->dsp.fdct(VAR_1 + VAR_2 * 4, VAR_2, VAR_7); VAR_7 += 64; if (VAR_10 > 2) { VAR_0->dsp.fdct(VAR_1 + VAR_2 * 4 + 8, VAR_2, VAR_7); VAR_7 += 64; } } else { VAR_0->dsp.fdct(VAR_12, VAR_14, VAR_7); VAR_7 += 64; VAR_0->dsp.fdct(VAR_1 + VAR_2 * 4, VAR_2, VAR_7); VAR_7 += 64; if (VAR_10 > 2) { VAR_0->dsp.fdct(VAR_1 + 8, VAR_2, VAR_7); VAR_7 += 64; VAR_0->dsp.fdct(VAR_1 + VAR_2 * 4 + 8, VAR_2, VAR_7); VAR_7 += 64; } } VAR_3 += VAR_13; } }