Ticket #4881: scaling_r.c

#include <libavutil/imgutils.h>
#include <libswscale/swscale.h>

//#define NO_SLICES

/* Taken from scaling_video.c example */
static void fill_yuv_image(uint8_t *data[4], int linesize[4],
                           int width, int height, int frame_index)
{
    int x, y;

    /* Y */
    for (y = 0; y < height; y++)
        for (x = 0; x < width; x++)
            data[0][y * linesize[0] + x] = x + y + frame_index * 3;

    /* Cb and Cr */
    for (y = 0; y < height / 2; y++) {
        for (x = 0; x < width / 2; x++) {
            data[1][y * linesize[1] + x] = 128 + y + frame_index * 2;
            data[2][y * linesize[2] + x] = 64 + x + frame_index * 5;
        }
    }
}

int main()
{
    uint8_t *src_data[4], *dst_data[4];
    int src_linesize[4], dst_linesize[4];
    int src_w, src_h, dst_w, dst_h;
    struct SwsContext *sws_ctx;
    FILE *dst_file;
    int i, ii;

    src_w = 720;
    src_h = 480;
    dst_w = 720;
    dst_h = 540;

    dst_file = fopen("qqq", "wb");

    sws_ctx = sws_getContext(src_w, src_h, AV_PIX_FMT_YUV420P,
                             dst_w, dst_h, AV_PIX_FMT_RGB24,
                             SWS_PRINT_INFO|SWS_BICUBIC, NULL, NULL, NULL);

    src_linesize[0] = 768;//FFALIGN(src_w,16);
    src_data[0] = av_malloc(src_linesize[0]*src_h+16);
    src_linesize[1] = src_linesize[2] = 768/2;//FFALIGN(src_w/2,16);
    src_data[1] = av_malloc(src_linesize[1]*src_h+16);
    src_data[2] = av_malloc(src_linesize[2]*src_h+16);
    dst_linesize[0] = 2160;//FFALIGN(dst_w*3,16);
    dst_data[0] = av_malloc(dst_linesize[0]*dst_h+16);

    src_data[3] = NULL;
    src_linesize[3] = 0;
    dst_data[1] = dst_data[2] = dst_data[3] = NULL;
    dst_linesize[1] = dst_linesize[2] = dst_linesize[3] = 0;

    for (ii = 0; ii < 100; ii++) {
        /* generate synthetic video */
        fill_yuv_image(src_data, src_linesize, src_w, src_h, ii);

#ifdef NO_SLICES
        /* Single pass */
        sws_scale(sws_ctx, (const uint8_t * const*)src_data,
                  src_linesize, 0, src_h, dst_data, dst_linesize);
#else
        /* Slices */
        for (i = 0; i < src_h; i+=16) {
            // Copy data to the beginninig of the buffer to simulate slice decoding
            memcpy(src_data[0], src_data[0]+src_linesize[0]*i, src_linesize[0]*16);
            memcpy(src_data[1], src_data[1]+src_linesize[1]*i/2, src_linesize[1]*8);
            memcpy(src_data[2], src_data[2]+src_linesize[2]*i/2, src_linesize[2]*8);
            // Do slice scaling to destination buffer
            sws_scale(sws_ctx, (const uint8_t * const*)src_data,
                      src_linesize, i, 16, dst_data, dst_linesize);
        }
#endif
        /* write scaled image to file */
        fwrite(dst_data[0], 1, dst_w*dst_h*3, dst_file);
    }

    fclose(dst_file);
    av_freep(&src_data[0]);
    av_freep(&src_data[1]);
    av_freep(&src_data[2]);
    av_freep(&dst_data[0]);
    sws_freeContext(sws_ctx);
    return 0;
}