/*
 * Copyright (C) 2020 Rockchip Electronics Co., Ltd.
 * author: Zhihua Wang, hogan.wang@rock-chips.com
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL), available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#include "image_read.h"
#include "vpu_decode.h"
#include "rga_control.h"

static int mjpeg_get_resolutin(FILE *fp, int *width, int *height)
{
    int ret = -1;
    char mark[2];
    char size[2];
    char data[14];

    rewind(fp);
    while (!feof(fp)) {
        fread(mark, 1, sizeof(mark), fp);
        if (mark[0] == 0xFF && mark[1] == 0xD8)
            continue;
        if (mark[0] != 0xFF)
            break;
        if (mark[1] == 0xC0) {
            fseek(fp, 3, SEEK_CUR);
            fread(data, 1, sizeof(data), fp);
            *height = data[0] * 256 + data[1];
            *width = data[2] * 256 + data[3];
            /* rga support RK_FORMAT_YCbCr_420_SP and RK_FORMAT_YCbCr_422_SP */
            if (data[4] == 3 && (data[6] == 0x22 || data[6] == 0x21) && data[9] == 0x11 && data[12] == 0x11)
                ret = 0;
            break;
        } else {
            fread(size, 1, sizeof(size), fp);
            fseek(fp, size[0] * 256 + size[1] - 2, SEEK_CUR);
            continue;
        }
    }

    return ret;
}

static int _decode(int width, int height, void *data, size_t size, int out_fd, void* out_data, int *fmt, int *hor_stride, int *ver_stride)
{
    int ret = -1;
    struct vpu_decode dec;
    memset(&dec, 0, sizeof(dec));
    if (!vpu_decode_jpeg_init(&dec, width, height))
        ret = vpu_decode_jpeg_doing(&dec, data, size, out_fd, out_data);
    *fmt = (MPP_FMT_YUV422SP != dec.fmt ? RK_FORMAT_YCbCr_420_SP : RK_FORMAT_YCbCr_422_SP);
    *hor_stride = dec.hor_stride;
    *ver_stride = dec.ver_stride;
    vpu_decode_jpeg_done(&dec);
    return ret;
}

static int image_read_begin(const char *path, bo_t *buf_bo, int *buf_fd, int *w, int *h, int *fmt, int *hor_stride, int *ver_stride)
{
    int ret = 0;
    int width, height;
    FILE *fp;
    size_t size;
    void *data;

    memset(buf_bo, 0, sizeof(bo_t));
    *buf_fd = -1;

    fp = fopen(path, "rb");
    if (!fp)
        return -1;

    if (mjpeg_get_resolutin(fp, &width, &height) || width % 2 || height % 2) {
        ret = -1;
        goto err_close;
    }

    fseek(fp, 0, SEEK_END);
    size = ftell(fp);

    data = malloc(size);
    if (!data) {
        ret = -1;
        goto err_close;
    }

    rewind(fp);
    fread(data, 1, size, fp);

    *w = width;
    *h = height;
    if (rga_control_buffer_init(buf_bo, buf_fd, MPP_ALIGN(width, 16), MPP_ALIGN(height, 16), 24)) {
        printf("%s: alloc buffer failed!\n", __func__);
        ret = -1;
        goto err_free;
    }

    ret = _decode(width, height, data, size, *buf_fd, buf_bo->ptr, fmt, hor_stride, ver_stride);

err_free:
    if (data)
        free(data);

err_close:
    if (fp)
        fclose(fp);
    return ret;
}

static int image_read_end(bo_t *buf_bo, int buf_fd)
{
    rga_control_buffer_deinit(buf_bo, buf_fd);
    return 0;
}

int image_read(const char *path, rockface_image_t *img, bo_t *rgb_bo, int *rgb_fd)
{
    int ret = -1;
    bo_t dec_bo;
    int dec_fd = -1;
    int width = 0, height = 0;
    int fmt;
    int hor_stride, ver_stride;

    if (image_read_begin(path, &dec_bo, &dec_fd, &width, &height, &fmt, &hor_stride, &ver_stride)) {
        ret = -2;
        goto exit0;
    }

    if (rga_control_buffer_init(rgb_bo, rgb_fd, hor_stride, ver_stride, 24)) {
        printf("%s: alloc buffer failed!\n", __func__);
        goto exit0;
    }

    rga_info_t src, dst;
    memset(&src, 0, sizeof(rga_info_t));
    src.fd = -1;
    src.virAddr = dec_bo.ptr;
    src.mmuFlag = 1;
    rga_set_rect(&src.rect, 0, 0, width, height, hor_stride, ver_stride, fmt);
    memset(&dst, 0, sizeof(rga_info_t));
    dst.fd = -1;
    dst.virAddr = rgb_bo->ptr;
    dst.mmuFlag = 1;
    rga_set_rect(&dst.rect, 0, 0, hor_stride, ver_stride, hor_stride, ver_stride, RK_FORMAT_RGB_888);
    if (c_RkRgaBlit(&src, &dst, NULL)) {
        printf("%s: rga fail\n", __func__);
        goto exit0;
    }

    memset(img, 0, sizeof(rockface_image_t));
    img->width = hor_stride;
    img->height = ver_stride;
    img->pixel_format = ROCKFACE_PIXEL_FORMAT_RGB888;
    img->data = (uint8_t *)rgb_bo->ptr;
    ret = 0;

exit0:
    if (width > 0 && height > 0)
        image_read_end(&dec_bo, dec_fd);
    return ret;
}

int image_read_deinit(bo_t *rgb_bo, int *rgb_fd)
{
    rga_control_buffer_deinit(rgb_bo, *rgb_fd);
}