static void achroma(WaveformContext *s, AVFrame *in, AVFrame *out,

                    int component, int intensity, int offset, int column)

{

    const int plane = s->desc->comp[component].plane;

    const int mirror = s->mirror;

    const int c1_linesize = in->linesize[(plane + 1) % s->ncomp];

    const int c2_linesize = in->linesize[(plane + 2) % s->ncomp];

    const int d1_linesize = out->linesize[(plane + 1) % s->ncomp];

    const int d2_linesize = out->linesize[(plane + 2) % s->ncomp];

    const int max = 255 - intensity;

    const int src_h = in->height;

    const int src_w = in->width;

    int x, y;



    if (column) {

        const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1);

        const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1);



        for (x = 0; x < src_w; x++) {

            const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp];

            const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp];

            uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset * d1_linesize;

            uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset * d2_linesize;

            uint8_t * const d1_bottom_line = d1_data + d1_linesize * (s->size - 1);

            uint8_t * const d1 = (mirror ? d1_bottom_line : d1_data);

            uint8_t * const d2_bottom_line = d2_data + d2_linesize * (s->size - 1);

            uint8_t * const d2 = (mirror ? d2_bottom_line : d2_data);



            for (y = 0; y < src_h; y++) {

                const int c1 = c1_data[x] - 128;

                const int c2 = c2_data[x] - 128;

                uint8_t *target;

                int p;



                for (p = 128 + c1; p < 128; p++) {

                    target = d1 + x + d1_signed_linesize * p;

                    update(target, max, 1);

                }



                for (p = 128 + c1 - 1; p > 128; p--) {

                    target = d1 + x + d1_signed_linesize * p;

                    update(target, max, 1);

                }



                for (p = 128 + c2; p < 128; p++) {

                    target = d2 + x + d2_signed_linesize * p;

                    update(target, max, 1);

                }



                for (p = 128 + c2 - 1; p > 128; p--) {

                    target = d2 + x + d2_signed_linesize * p;

                    update(target, max, 1);

                }



                c1_data += c1_linesize;

                c2_data += c2_linesize;

                d1_data += d1_linesize;

                d2_data += d2_linesize;

            }

        }

    } else {

        const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp];

        const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp];

        uint8_t *d0_data = out->data[plane] + offset;

        uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset;

        uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset;



        if (mirror) {

            d0_data += s->size - 1;

            d1_data += s->size - 1;

            d2_data += s->size - 1;

        }



        for (y = 0; y < src_h; y++) {

            for (x = 0; x < src_w; x++) {

                const int c1 = c1_data[x] - 128;

                const int c2 = c2_data[x] - 128;

                uint8_t *target;

                int p;



                for (p = 128 + c1; p < 128; p++) {

                    if (mirror)

                        target = d1_data - p;

                    else

                        target = d1_data + p;



                    update(target, max, 1);

                }



                for (p = 128 + 1; p < 128 + c1; p++) {

                    if (mirror)

                        target = d1_data - p;

                    else

                        target = d1_data + p;



                    update(target, max, 1);

                }



                for (p = 128 + c2; p < 128; p++) {

                    if (mirror)

                        target = d2_data - p;

                    else

                        target = d2_data + p;



                    update(target, max, 1);

                }



                for (p = 128 + 1; p < 128 + c2; p++) {

                    if (mirror)

                        target = d2_data - p;

                    else

                        target = d2_data + p;



                    update(target, max, 1);

                }

            }



            c1_data += c1_linesize;

            c2_data += c2_linesize;

            d1_data += d1_linesize;

            d2_data += d2_linesize;

        }

    }



    envelope(s, out, plane, (plane + 1) % s->ncomp);

    envelope(s, out, plane, (plane + 2) % s->ncomp);

}

static void achroma(WaveformContext *s, AVFrame *in, AVFrame *out,

                    int component, int intensity, int offset, int column)

{

    const int plane = s->desc->comp[component].plane;

    const int mirror = s->mirror;

    const int c1_linesize = in->linesize[(plane + 1) % s->ncomp];

    const int c2_linesize = in->linesize[(plane + 2) % s->ncomp];

    const int d1_linesize = out->linesize[(plane + 1) % s->ncomp];

    const int d2_linesize = out->linesize[(plane + 2) % s->ncomp];

    const int max = 255 - intensity;

    const int src_h = in->height;

    const int src_w = in->width;

    int x, y;



    if (column) {

        const int d1_signed_linesize = d1_linesize * (mirror == 1 ? -1 : 1);

        const int d2_signed_linesize = d2_linesize * (mirror == 1 ? -1 : 1);



        for (x = 0; x < src_w; x++) {

            const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp];

            const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp];

            uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset * d1_linesize;

            uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset * d2_linesize;

            uint8_t * const d1_bottom_line = d1_data + d1_linesize * (s->size - 1);

            uint8_t * const d1 = (mirror ? d1_bottom_line : d1_data);

            uint8_t * const d2_bottom_line = d2_data + d2_linesize * (s->size - 1);

            uint8_t * const d2 = (mirror ? d2_bottom_line : d2_data);



            for (y = 0; y < src_h; y++) {

                const int c1 = c1_data[x] - 128;

                const int c2 = c2_data[x] - 128;

                uint8_t *target;

                int p;



                for (p = 128 + c1; p < 128; p++) {

                    target = d1 + x + d1_signed_linesize * p;

                    update(target, max, 1);

                }



                for (p = 128 + c1 - 1; p > 128; p--) {

                    target = d1 + x + d1_signed_linesize * p;

                    update(target, max, 1);

                }



                for (p = 128 + c2; p < 128; p++) {

                    target = d2 + x + d2_signed_linesize * p;

                    update(target, max, 1);

                }



                for (p = 128 + c2 - 1; p > 128; p--) {

                    target = d2 + x + d2_signed_linesize * p;

                    update(target, max, 1);

                }



                c1_data += c1_linesize;

                c2_data += c2_linesize;

                d1_data += d1_linesize;

                d2_data += d2_linesize;

            }

        }

    } else {

        const uint8_t *c1_data = in->data[(plane + 1) % s->ncomp];

        const uint8_t *c2_data = in->data[(plane + 2) % s->ncomp];

        uint8_t *d0_data = out->data[plane] + offset;

        uint8_t *d1_data = out->data[(plane + 1) % s->ncomp] + offset;

        uint8_t *d2_data = out->data[(plane + 2) % s->ncomp] + offset;



        if (mirror) {

            d0_data += s->size - 1;

            d1_data += s->size - 1;

            d2_data += s->size - 1;

        }



        for (y = 0; y < src_h; y++) {

            for (x = 0; x < src_w; x++) {

                const int c1 = c1_data[x] - 128;

                const int c2 = c2_data[x] - 128;

                uint8_t *target;

                int p;



                for (p = 128 + c1; p < 128; p++) {

                    if (mirror)

                        target = d1_data - p;

                    else

                        target = d1_data + p;



                    update(target, max, 1);

                }



                for (p = 128 + 1; p < 128 + c1; p++) {

                    if (mirror)

                        target = d1_data - p;

                    else

                        target = d1_data + p;



                    update(target, max, 1);

                }



                for (p = 128 + c2; p < 128; p++) {

                    if (mirror)

                        target = d2_data - p;

                    else

                        target = d2_data + p;



                    update(target, max, 1);

                }



                for (p = 128 + 1; p < 128 + c2; p++) {

                    if (mirror)

                        target = d2_data - p;

                    else

                        target = d2_data + p;



                    update(target, max, 1);

                }

            }



            c1_data += c1_linesize;

            c2_data += c2_linesize;

            d1_data += d1_linesize;

            d2_data += d2_linesize;

        }

    }



    envelope(s, out, plane, (plane + 1) % s->ncomp);

    envelope(s, out, plane, (plane + 2) % s->ncomp);

}

static void FUNC_0(WaveformContext *VAR_0, AVFrame *VAR_1, AVFrame *VAR_2,

                    int VAR_3, int VAR_4, int VAR_5, int VAR_6)

{

    const int VAR_7 = VAR_0->desc->comp[VAR_3].VAR_7;

    const int VAR_8 = VAR_0->VAR_8;

    const int VAR_9 = VAR_1->linesize[(VAR_7 + 1) % VAR_0->ncomp];

    const int VAR_10 = VAR_1->linesize[(VAR_7 + 2) % VAR_0->ncomp];

    const int VAR_11 = VAR_2->linesize[(VAR_7 + 1) % VAR_0->ncomp];

    const int VAR_12 = VAR_2->linesize[(VAR_7 + 2) % VAR_0->ncomp];

    const int VAR_13 = 255 - VAR_4;

    const int VAR_14 = VAR_1->height;

    const int VAR_15 = VAR_1->width;

    int VAR_16, VAR_17;



    if (VAR_6) {

        const int VAR_18 = VAR_11 * (VAR_8 == 1 ? -1 : 1);

        const int VAR_19 = VAR_12 * (VAR_8 == 1 ? -1 : 1);



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

            const uint8_t *VAR_25 = VAR_1->data[(VAR_7 + 1) % VAR_0->ncomp];

            const uint8_t *VAR_25 = VAR_1->data[(VAR_7 + 2) % VAR_0->ncomp];

            uint8_t *d1_data = VAR_2->data[(VAR_7 + 1) % VAR_0->ncomp] + VAR_5 * VAR_11;

            uint8_t *d2_data = VAR_2->data[(VAR_7 + 2) % VAR_0->ncomp] + VAR_5 * VAR_12;

            uint8_t * const d1_bottom_line = d1_data + VAR_11 * (VAR_0->size - 1);

            uint8_t * const d1 = (VAR_8 ? d1_bottom_line : d1_data);

            uint8_t * const d2_bottom_line = d2_data + VAR_12 * (VAR_0->size - 1);

            uint8_t * const d2 = (VAR_8 ? d2_bottom_line : d2_data);



            for (VAR_17 = 0; VAR_17 < VAR_14; VAR_17++) {

                const int VAR_25 = VAR_25[VAR_16] - 128;

                const int VAR_25 = VAR_25[VAR_16] - 128;

                uint8_t *target;

                int VAR_25;



                for (VAR_25 = 128 + VAR_25; VAR_25 < 128; VAR_25++) {

                    target = d1 + VAR_16 + VAR_18 * VAR_25;

                    update(target, VAR_13, 1);

                }



                for (VAR_25 = 128 + VAR_25 - 1; VAR_25 > 128; VAR_25--) {

                    target = d1 + VAR_16 + VAR_18 * VAR_25;

                    update(target, VAR_13, 1);

                }



                for (VAR_25 = 128 + VAR_25; VAR_25 < 128; VAR_25++) {

                    target = d2 + VAR_16 + VAR_19 * VAR_25;

                    update(target, VAR_13, 1);

                }



                for (VAR_25 = 128 + VAR_25 - 1; VAR_25 > 128; VAR_25--) {

                    target = d2 + VAR_16 + VAR_19 * VAR_25;

                    update(target, VAR_13, 1);

                }



                VAR_25 += VAR_9;

                VAR_25 += VAR_10;

                d1_data += VAR_11;

                d2_data += VAR_12;

            }

        }

    } else {

        const uint8_t *VAR_25 = VAR_1->data[(VAR_7 + 1) % VAR_0->ncomp];

        const uint8_t *VAR_25 = VAR_1->data[(VAR_7 + 2) % VAR_0->ncomp];

        uint8_t *d0_data = VAR_2->data[VAR_7] + VAR_5;

        uint8_t *d1_data = VAR_2->data[(VAR_7 + 1) % VAR_0->ncomp] + VAR_5;

        uint8_t *d2_data = VAR_2->data[(VAR_7 + 2) % VAR_0->ncomp] + VAR_5;



        if (VAR_8) {

            d0_data += VAR_0->size - 1;

            d1_data += VAR_0->size - 1;

            d2_data += VAR_0->size - 1;

        }



        for (VAR_17 = 0; VAR_17 < VAR_14; VAR_17++) {

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

                const int VAR_25 = VAR_25[VAR_16] - 128;

                const int VAR_25 = VAR_25[VAR_16] - 128;

                uint8_t *target;

                int VAR_25;



                for (VAR_25 = 128 + VAR_25; VAR_25 < 128; VAR_25++) {

                    if (VAR_8)

                        target = d1_data - VAR_25;

                    else

                        target = d1_data + VAR_25;



                    update(target, VAR_13, 1);

                }



                for (VAR_25 = 128 + 1; VAR_25 < 128 + VAR_25; VAR_25++) {

                    if (VAR_8)

                        target = d1_data - VAR_25;

                    else

                        target = d1_data + VAR_25;



                    update(target, VAR_13, 1);

                }



                for (VAR_25 = 128 + VAR_25; VAR_25 < 128; VAR_25++) {

                    if (VAR_8)

                        target = d2_data - VAR_25;

                    else

                        target = d2_data + VAR_25;



                    update(target, VAR_13, 1);

                }



                for (VAR_25 = 128 + 1; VAR_25 < 128 + VAR_25; VAR_25++) {

                    if (VAR_8)

                        target = d2_data - VAR_25;

                    else

                        target = d2_data + VAR_25;



                    update(target, VAR_13, 1);

                }

            }



            VAR_25 += VAR_9;

            VAR_25 += VAR_10;

            d1_data += VAR_11;

            d2_data += VAR_12;

        }

    }



    envelope(VAR_0, VAR_2, VAR_7, (VAR_7 + 1) % VAR_0->ncomp);

    envelope(VAR_0, VAR_2, VAR_7, (VAR_7 + 2) % VAR_0->ncomp);

}

static void FUNC_0(WaveformContext *VAR_0, AVFrame *VAR_1, AVFrame *VAR_2,
int VAR_3, int VAR_4, int VAR_5, int VAR_6)
{ const int VAR_7 = VAR_0->desc->comp[VAR_3].VAR_7; const int VAR_8 = VAR_0->VAR_8; const int VAR_9 = VAR_1->linesize[(VAR_7 + 1) % VAR_0->ncomp]; const int VAR_10 = VAR_1->linesize[(VAR_7 + 2) % VAR_0->ncomp]; const int VAR_11 = VAR_2->linesize[(VAR_7 + 1) % VAR_0->ncomp]; const int VAR_12 = VAR_2->linesize[(VAR_7 + 2) % VAR_0->ncomp]; const int VAR_13 = 255 - VAR_4; const int VAR_14 = VAR_1->height; const int VAR_15 = VAR_1->width; int VAR_16, VAR_17; if (VAR_6) { const int VAR_18 = VAR_11 * (VAR_8 == 1 ? -1 : 1); const int VAR_19 = VAR_12 * (VAR_8 == 1 ? -1 : 1); for (VAR_16 = 0; VAR_16 < VAR_15; VAR_16++) { const uint8_t *VAR_25 = VAR_1->data[(VAR_7 + 1) % VAR_0->ncomp]; const uint8_t *VAR_25 = VAR_1->data[(VAR_7 + 2) % VAR_0->ncomp]; uint8_t *d1_data = VAR_2->data[(VAR_7 + 1) % VAR_0->ncomp] + VAR_5 * VAR_11; uint8_t *d2_data = VAR_2->data[(VAR_7 + 2) % VAR_0->ncomp] + VAR_5 * VAR_12; uint8_t * const d1_bottom_line = d1_data + VAR_11 * (VAR_0->size - 1); uint8_t * const d1 = (VAR_8 ? d1_bottom_line : d1_data); uint8_t * const d2_bottom_line = d2_data + VAR_12 * (VAR_0->size - 1); uint8_t * const d2 = (VAR_8 ? d2_bottom_line : d2_data); for (VAR_17 = 0; VAR_17 < VAR_14; VAR_17++) { const int VAR_25 = VAR_25[VAR_16] - 128; const int VAR_25 = VAR_25[VAR_16] - 128; uint8_t *target; int VAR_25; for (VAR_25 = 128 + VAR_25; VAR_25 < 128; VAR_25++) { target = d1 + VAR_16 + VAR_18 * VAR_25; update(target, VAR_13, 1); } for (VAR_25 = 128 + VAR_25 - 1; VAR_25 > 128; VAR_25--) { target = d1 + VAR_16 + VAR_18 * VAR_25; update(target, VAR_13, 1); } for (VAR_25 = 128 + VAR_25; VAR_25 < 128; VAR_25++) { target = d2 + VAR_16 + VAR_19 * VAR_25; update(target, VAR_13, 1); } for (VAR_25 = 128 + VAR_25 - 1; VAR_25 > 128; VAR_25--) { target = d2 + VAR_16 + VAR_19 * VAR_25; update(target, VAR_13, 1); } VAR_25 += VAR_9; VAR_25 += VAR_10; d1_data += VAR_11; d2_data += VAR_12; } } } else { const uint8_t *VAR_25 = VAR_1->data[(VAR_7 + 1) % VAR_0->ncomp]; const uint8_t *VAR_25 = VAR_1->data[(VAR_7 + 2) % VAR_0->ncomp]; uint8_t *d0_data = VAR_2->data[VAR_7] + VAR_5; uint8_t *d1_data = VAR_2->data[(VAR_7 + 1) % VAR_0->ncomp] + VAR_5; uint8_t *d2_data = VAR_2->data[(VAR_7 + 2) % VAR_0->ncomp] + VAR_5; if (VAR_8) { d0_data += VAR_0->size - 1; d1_data += VAR_0->size - 1; d2_data += VAR_0->size - 1; } for (VAR_17 = 0; VAR_17 < VAR_14; VAR_17++) { for (VAR_16 = 0; VAR_16 < VAR_15; VAR_16++) { const int VAR_25 = VAR_25[VAR_16] - 128; const int VAR_25 = VAR_25[VAR_16] - 128; uint8_t *target; int VAR_25; for (VAR_25 = 128 + VAR_25; VAR_25 < 128; VAR_25++) { if (VAR_8)
target = d1_data - VAR_25; else
target = d1_data + VAR_25; update(target, VAR_13, 1); } for (VAR_25 = 128 + 1; VAR_25 < 128 + VAR_25; VAR_25++) { if (VAR_8)
target = d1_data - VAR_25; else
target = d1_data + VAR_25; update(target, VAR_13, 1); } for (VAR_25 = 128 + VAR_25; VAR_25 < 128; VAR_25++) { if (VAR_8)
target = d2_data - VAR_25; else
target = d2_data + VAR_25; update(target, VAR_13, 1); } for (VAR_25 = 128 + 1; VAR_25 < 128 + VAR_25; VAR_25++) { if (VAR_8)
target = d2_data - VAR_25; else
target = d2_data + VAR_25; update(target, VAR_13, 1); } } VAR_25 += VAR_9; VAR_25 += VAR_10; d1_data += VAR_11; d2_data += VAR_12; } } envelope(VAR_0, VAR_2, VAR_7, (VAR_7 + 1) % VAR_0->ncomp); envelope(VAR_0, VAR_2, VAR_7, (VAR_7 + 2) % VAR_0->ncomp); }