#include "media_info.h"

void print_flags(const struct flag_name* flag_names, unsigned int num_entries, __u32 flags)
{
    bool first = true;
    unsigned int i;

    for (i = 0; i < num_entries; i++) {
        if (!(flags & flag_names[i].flag)) {
            continue;
        }
        if (!first) {
            printf(",");
        }
        printf("%s", flag_names[i].name);
        flags &= ~flag_names[i].flag;
        first = false;
    }

    if (flags) {
        if (!first) {
            printf(",");
        }
        printf("0x%x", flags);
    }
}

void v4l2_subdev_print_format(struct media_entity* entity, unsigned int pad, enum v4l2_subdev_format_whence which)
{
    struct v4l2_mbus_framefmt format;
    struct v4l2_fract interval = {0, 0};
    struct v4l2_rect rect;
    int ret;

    ret = v4l2_subdev_get_format(entity, &format, pad, which);
    if (ret != 0) {
        return;
    }

    ret = v4l2_subdev_get_frame_interval(entity, &interval, pad);
    if (ret != 0 && ret != -ENOTTY && ret != -EINVAL) {
        return;
    }

    printf("\t\t[fmt:%s/%ux%u", v4l2_subdev_pixelcode_to_string(format.code), format.width, format.height);

    if (interval.numerator || interval.denominator) {
        printf("@%u/%u", interval.numerator, interval.denominator);
    }

    if (format.field) {
        printf(" field:%s", v4l2_subdev_field_to_string(format.field));
    }

    if (format.colorspace) {
        printf(" colorspace:%s", v4l2_subdev_colorspace_to_string(format.colorspace));

        if (format.xfer_func) {
            printf(" xfer:%s", v4l2_subdev_xfer_func_to_string(format.xfer_func));
        }

        if (format.ycbcr_enc)
            printf(" ycbcr:%s", v4l2_subdev_ycbcr_encoding_to_string(format.ycbcr_enc));

        if (format.quantization)
            printf(" quantization:%s", v4l2_subdev_quantization_to_string(format.quantization));
    }

    ret = v4l2_subdev_get_selection(entity, &rect, pad, V4L2_SEL_TGT_CROP_BOUNDS, which);
    if (ret == 0)
        printf("\n\t\t crop.bounds:(%u,%u)/%ux%u", rect.left, rect.top, rect.width, rect.height);

    ret = v4l2_subdev_get_selection(entity, &rect, pad, V4L2_SEL_TGT_CROP, which);
    if (ret == 0)
        printf("\n\t\t crop:(%u,%u)/%ux%u", rect.left, rect.top, rect.width, rect.height);

    ret = v4l2_subdev_get_selection(entity, &rect, pad, V4L2_SEL_TGT_COMPOSE_BOUNDS, which);
    if (ret == 0)
        printf("\n\t\t compose.bounds:(%u,%u)/%ux%u", rect.left, rect.top, rect.width, rect.height);

    ret = v4l2_subdev_get_selection(entity, &rect, pad, V4L2_SEL_TGT_COMPOSE, which);
    if (ret == 0)
        printf("\n\t\t compose:(%u,%u)/%ux%u", rect.left, rect.top, rect.width, rect.height);

    printf("]\n");
}

const char* v4l2_dv_type_to_string(unsigned int type)
{
    static const struct {
        __u32 type;
        const char* name;
    } types[] = {
        {V4L2_DV_BT_656_1120, "BT.656/1120"},
    };

    static char unknown[20];
    unsigned int i;

    for (i = 0; i < ARRAY_SIZE(types); i++) {
        if (types[i].type == type) {
            return types[i].name;
        }
    }

    sprintf(unknown, "Unknown (%u)", type);
    return unknown;
}

static const struct flag_name bt_standards[] = {
    {V4L2_DV_BT_STD_CEA861, "CEA-861"}, {V4L2_DV_BT_STD_DMT, "DMT"}, {V4L2_DV_BT_STD_CVT, "CVT"},
    {V4L2_DV_BT_STD_GTF, "GTF"},        {V4L2_DV_BT_STD_SDI, "SDI"},
};

static const struct flag_name bt_capabilities[] = {
    {V4L2_DV_BT_CAP_INTERLACED, "interlaced"},
    {V4L2_DV_BT_CAP_PROGRESSIVE, "progressive"},
    {V4L2_DV_BT_CAP_REDUCED_BLANKING, "reduced-blanking"},
    {V4L2_DV_BT_CAP_CUSTOM, "custom"},
};

static const struct flag_name bt_flags[] = {
    {V4L2_DV_FL_REDUCED_BLANKING, "reduced-blanking"},
    {V4L2_DV_FL_CAN_REDUCE_FPS, "can-reduce-fps"},
    {V4L2_DV_FL_REDUCED_FPS, "reduced-fps"},
    {V4L2_DV_FL_HALF_LINE, "half-line"},
    {V4L2_DV_FL_IS_CE_VIDEO, "CE-video"},
    {V4L2_DV_FL_FIRST_FIELD_EXTRA_LINE, "first-field-extra-line"},
    {V4L2_DV_FL_HAS_PICTURE_ASPECT, "has-picture-aspect"},
    {V4L2_DV_FL_HAS_CEA861_VIC, "has-cea861-vic"},
    {V4L2_DV_FL_HAS_HDMI_VIC, "has-hdmi-vic"},
    {V4L2_DV_FL_CAN_DETECT_REDUCED_FPS, "can-detect-reduced-fps"},
};

void v4l2_subdev_print_dv_timings(const struct v4l2_dv_timings* timings, const char* name)
{
    printf("\t\t[dv.%s:%s", name, v4l2_dv_type_to_string(timings->type));

    switch (timings->type) {
        case V4L2_DV_BT_656_1120: {
            const struct v4l2_bt_timings* bt = &timings->bt;
            unsigned int htotal, vtotal;

            htotal = V4L2_DV_BT_FRAME_WIDTH(bt);
            vtotal = V4L2_DV_BT_FRAME_HEIGHT(bt);

            printf(" %ux%u%s%llu (%ux%u)", bt->width, bt->height, bt->interlaced ? "i" : "p",
                   (htotal * vtotal) > 0 ? (bt->pixelclock / (htotal * vtotal)) : 0, htotal, vtotal);

            printf(" stds:");
            print_flags(bt_standards, ARRAY_SIZE(bt_standards), bt->standards);
            printf(" flags:");
            print_flags(bt_flags, ARRAY_SIZE(bt_flags), bt->flags);

            break;
        }
    }

    printf("]\n");
}

void v4l2_subdev_print_pad_dv(struct media_entity* entity, unsigned int pad, enum v4l2_subdev_format_whence which)
{
    struct v4l2_dv_timings_cap caps;
    int ret;

    caps.pad = pad;
    ret = v4l2_subdev_get_dv_timings_caps(entity, &caps);
    if (ret != 0) {
        return;
    }

    printf("\t\t[dv.caps:%s", v4l2_dv_type_to_string(caps.type));

    switch (caps.type) {
        case V4L2_DV_BT_656_1120:
            printf(" min:%ux%u@%llu max:%ux%u@%llu", caps.bt.min_width, caps.bt.min_height, caps.bt.min_pixelclock,
                   caps.bt.max_width, caps.bt.max_height, caps.bt.max_pixelclock);

            printf(" stds:");
            print_flags(bt_standards, ARRAY_SIZE(bt_standards), caps.bt.standards);
            printf(" caps:");
            print_flags(bt_capabilities, ARRAY_SIZE(bt_capabilities), caps.bt.capabilities);

            break;
    }

    printf("]\n");
}

void v4l2_subdev_print_subdev_dv(struct media_entity* entity)
{
    struct v4l2_dv_timings timings;
    int ret;

    ret = v4l2_subdev_query_dv_timings(entity, &timings);
    switch (ret) {
        case -ENOLINK:
            printf("\t\t[dv.query:no-link]\n");
            break;
        case -ENOLCK:
            printf("\t\t[dv.query:no-lock]\n");
            break;
        case -ERANGE:
            printf("\t\t[dv.query:out-of-range]\n");
            break;
        case 0:
            v4l2_subdev_print_dv_timings(&timings, "detect");
            break;
        default:
            return;
    }

    ret = v4l2_subdev_get_dv_timings(entity, &timings);
    if (ret == 0) {
        v4l2_subdev_print_dv_timings(&timings, "current");
    }
}

const char* media_entity_type_to_string(unsigned type)
{
    static const struct {
        __u32 type;
        const char* name;
    } types[] = {
        {MEDIA_ENT_T_DEVNODE, "Node"},
        {MEDIA_ENT_T_V4L2_SUBDEV, "V4L2 subdev"},
    };

    unsigned int i;

    type &= MEDIA_ENT_TYPE_MASK;

    for (i = 0; i < ARRAY_SIZE(types); i++) {
        if (types[i].type == type) {
            return types[i].name;
        }
    }

    return "Unknown";
}

const char* media_entity_subtype_to_string(unsigned type)
{
    static const char* node_types[] = {
        "Unknown", "V4L", "FB", "ALSA", "DVB",
    };
    static const char* subdev_types[] = {
        "Unknown", "Sensor", "Flash", "Lens", "Decoder", "Tuner",
    };

    unsigned int subtype = type & MEDIA_ENT_SUBTYPE_MASK;

    switch (type & MEDIA_ENT_TYPE_MASK) {
        case MEDIA_ENT_T_DEVNODE:
            if (subtype >= ARRAY_SIZE(node_types)) {
                subtype = 0;
            }
            return node_types[subtype];

        case MEDIA_ENT_T_V4L2_SUBDEV:
            if (subtype >= ARRAY_SIZE(subdev_types)) {
                subtype = 0;
            }
            return subdev_types[subtype];
        default:
            return node_types[0];
    }
}

const char* media_pad_type_to_string(unsigned flag)
{
    static const struct {
        __u32 flag;
        const char* name;
    } flags[] = {
        {MEDIA_PAD_FL_SINK, "Sink"},
        {MEDIA_PAD_FL_SOURCE, "Source"},
    };

    unsigned int i;

    for (i = 0; i < ARRAY_SIZE(flags); i++) {
        if (flags[i].flag & flag) {
            return flags[i].name;
        }
    }

    return "Unknown";
}

void media_print_pad_text(struct media_entity* entity, const struct media_pad* pad)
{
    if (media_entity_type(entity) != MEDIA_ENT_T_V4L2_SUBDEV) {
        return;
    }

    v4l2_subdev_print_format(entity, pad->index, V4L2_SUBDEV_FORMAT_ACTIVE);
    v4l2_subdev_print_pad_dv(entity, pad->index, V4L2_SUBDEV_FORMAT_ACTIVE);

    if (pad->flags & MEDIA_PAD_FL_SOURCE) {
        v4l2_subdev_print_subdev_dv(entity);
    }
}