#include "mpp_osd.h"
#include "mpi_enc.h"
#include "uvc_log.h"


#if MPP_ENC_OSD_ENABLE
/* argb(lower address -> high address) */
const uint32_t rgb888_palette_table[PALETTE_TABLE_LEN] = {
    0xffffffff, 0xd7ffffff, 0xafffffff, 0x87ffffff, 0x5fffffff, 0x00ffffff,
    0xffd7ffff, 0xd7d7ffff, 0xafd7ffff, 0x87d7ffff, 0x5fd7ffff, 0x00d7ffff,
    0xffafffff, 0xd7afffff, 0xafafffff, 0x87afffff, 0x5fafffff, 0x00afffff,
    0xff87ffff, 0xd787ffff, 0xaf87ffff, 0x8787ffff, 0x5f87ffff, 0x0087ffff,
    0xff5fffff, 0xd75fffff, 0xaf5fffff, 0x875fffff, 0x5f5fffff, 0x005fffff,
    0xff00ffff, 0xd700ffff, 0xaf00ffff, 0x8700ffff, 0x5f00ffff, 0x0000ffff,
    0xffffd7ff, 0xd7ffd7ff, 0xafffd7ff, 0x87ffd7ff, 0x5fffd7ff, 0x00ffd7ff,
    0xffd7d7ff, 0xd7d7d7ff, 0xafd7d7ff, 0x87d7d7ff, 0x5fd7d7ff, 0x00d7d7ff,
    0xffafd7ff, 0xd7afd7ff, 0xafafd7ff, 0x87afd7ff, 0x5fafd7ff, 0x00afd7ff,
    0xff87d7ff, 0xd787d7ff, 0xaf87d7ff, 0x8787d7ff, 0x5f87d7ff, 0x0087d7ff,
    0xff5fd7ff, 0xd75fd7ff, 0xaf5fd7ff, 0x875fd7ff, 0x5f5fd7ff, 0x005fd7ff,
    0xff00d7ff, 0xd700d7ff, 0xaf00d7ff, 0x8700d7ff, 0x5f00d7ff, 0x0000d7ff,
    0xffffafff, 0xd7ffafff, 0xafffafff, 0x87ffafff, 0x5fffafff, 0x00ffafff,
    0xffd7afff, 0xd7d7afff, 0xafd7afff, 0x87d7afff, 0x5fd7afff, 0x00d7afff,
    0xffafafff, 0xd7afafff, 0xafafafff, 0x87afafff, 0x5fafafff, 0x00afafff,
    0xff87afff, 0xd787afff, 0xaf87afff, 0x8787afff, 0x5f87afff, 0x0087afff,
    0xff5fafff, 0xd75fafff, 0xaf5fafff, 0x875fafff, 0x5f5fafff, 0x005fafff,
    0xff00afff, 0xd700afff, 0xaf00afff, 0x8700afff, 0x5f00afff, 0x0000afff,
    0xffff87ff, 0xd7ff87ff, 0xafff87ff, 0x87ff87ff, 0x5fff87ff, 0x00ff87ff,
    0xffd787ff, 0xd7d787ff, 0xafd787ff, 0x87d787ff, 0x5fd787ff, 0x00d787ff,
    0xffaf87ff, 0xd7af87ff, 0xafaf87ff, 0x87af87ff, 0x5faf87ff, 0x00af87ff,
    0xff8787ff, 0xd78787ff, 0xaf8787ff, 0x878787ff, 0x5f8787ff, 0x008787ff,
    0xff5f87ff, 0xd75f87ff, 0xaf5f87ff, 0x875f87ff, 0x5f5f87ff, 0x005f87ff,
    0xff0087ff, 0xd70087ff, 0xaf0087ff, 0x870087ff, 0x5f0087ff, 0x000087ff,
    0xffff5fff, 0xd7ff5fff, 0xafff5fff, 0x87ff5fff, 0x5fff5fff, 0x00ff5fff,
    0xffd75fff, 0xd7d75fff, 0xafd75fff, 0x87d75fff, 0x5fd75fff, 0x00d75fff,
    0xffaf5fff, 0xd7af5fff, 0xafaf5fff, 0x87af5fff, 0x5faf5fff, 0x00af5fff,
    0xff875fff, 0xd7875fff, 0xaf875fff, 0x87875fff, 0x5f875fff, 0x00875fff,
    0xff5f5fff, 0xd75f5fff, 0xaf5f5fff, 0x875f5fff, 0x5f5f5fff, 0x005f5fff,
    0xff005fff, 0xd7005fff, 0xaf005fff, 0x87005fff, 0x5f005fff, 0x00005fff,
    0xffff00ff, 0xd7ff00ff, 0xafff00ff, 0x87ff00ff, 0x5fff00ff, 0x00ff00ff,
    0xffd700ff, 0xd7d700ff, 0xafd700ff, 0x87d700ff, 0x5fd700ff, 0x00d700ff,
    0xffaf00ff, 0xd7af00ff, 0xafaf00ff, 0x87af00ff, 0x5faf00ff, 0x00af00ff,
    0xff8700ff, 0xd78700ff, 0xaf8700ff, 0x878700ff, 0x5f8700ff, 0x008700ff,
    0xff5f00ff, 0xd75f00ff, 0xaf5f00ff, 0x875f00ff, 0x5f5f00ff, 0x005f00ff,
    0xff0000ff, 0xd70000ff, 0xaf0000ff, 0x870000ff, 0x5f0000ff, 0x000000ff,
    0xeeeeeeff, 0xe4e4e4ff, 0xdadadaff, 0xd0d0d0ff, 0xc6c6c6ff, 0xbcbcbcff,
    0xb2b2b2ff, 0xa8a8a8ff, 0x9e9e9eff, 0x949494ff, 0x8a8a8aff, 0x767676ff,
    0x6c6c6cff, 0x626262ff, 0x585858ff, 0x4e4e4eff, 0x444444ff, 0x3a3a3aff,
    0x303030ff, 0x262626ff, 0x1c1c1cff, 0x121212ff, 0x080808ff, 0x000080ff,
    0x008000ff, 0x008080ff, 0x800000ff, 0x800080ff, 0x808000ff, 0xc0c0c0ff,
    0x808080ff, 0xffffccff, 0xccccccff, 0x99ccccff, 0x9999ccff, 0x3366ccff,
    0x0033ccff, 0x3300ccff, 0x00ffccff, 0x08000000
};

/* yuva(lower address -> high address) */
static const uint32_t yuv444_palette_table[PALETTE_TABLE_LEN] = {
    0xff8080eb, 0xff826ee9, 0xff835de6, 0xff854be4, 0xff863ae1, 0xff8a10db,
    0xff908ed2, 0xff927cd0, 0xff936acd, 0xff9559cb, 0xff9647c9, 0xff9a1ec3,
    0xffa09bba, 0xffa28ab7, 0xffa378b5, 0xffa566b2, 0xffa655b0, 0xffaa2baa,
    0xffb0a9a1, 0xffb1979f, 0xffb3859c, 0xffb5749a, 0xffb66297, 0xffba3991,
    0xffc0b689, 0xffc1a586, 0xffc39384, 0xffc58181, 0xffc6707f, 0xffca4679,
    0xffe6d64e, 0xffe7c54c, 0xffe9b349, 0xffeba247, 0xffec9044, 0xfff0663f,
    0xff6e84e4, 0xff7072e1, 0xff7261df, 0xff734fdc, 0xff753eda, 0xff7914d4,
    0xff7e92cb, 0xff8080c9, 0xff826ec6, 0xff835dc4, 0xff854bc1, 0xff8922bb,
    0xff8e9fb3, 0xff908eb0, 0xff927cae, 0xff936aab, 0xff9559a9, 0xff992fa3,
    0xff9ead9a, 0xffa09b98, 0xffa28a95, 0xffa37893, 0xffa56690, 0xffa93d8a,
    0xffaeba81, 0xffb0a97f, 0xffb1977c, 0xffb3857a, 0xffb57477, 0xffb94a72,
    0xffd4da47, 0xffd6c945, 0xffd7b742, 0xffd9a640, 0xffdb943d, 0xffde6a37,
    0xff5d88dc, 0xff5e76da, 0xff6065d7, 0xff6253d5, 0xff6342d2, 0xff6718cd,
    0xff6d96c4, 0xff6e84c1, 0xff7072bf, 0xff7261bc, 0xff734fba, 0xff7726b4,
    0xff7da3ab, 0xff7e92a9, 0xff8080a6, 0xff826ea4, 0xff835da1, 0xff87339b,
    0xff8db193, 0xff8e9f90, 0xff908e8e, 0xff927c8b, 0xff936a89, 0xff974183,
    0xff9dbe7a, 0xff9ead78, 0xffa09b75, 0xffa28a73, 0xffa37870, 0xffa74e6a,
    0xffc3de40, 0xffc4cd3d, 0xffc6bb3b, 0xffc7aa38, 0xffc99836, 0xffcd6e30,
    0xff4b8cd5, 0xff4d7bd3, 0xff4f69d0, 0xff5057ce, 0xff5246cb, 0xff561cc5,
    0xff5b9abd, 0xff5d88ba, 0xff5e76b8, 0xff6065b5, 0xff6253b3, 0xff662aad,
    0xff6ba7a4, 0xff6d96a1, 0xff6e849f, 0xff70729d, 0xff72619a, 0xff753794,
    0xff7bb58b, 0xff7da389, 0xff7e9286, 0xff808084, 0xff826e81, 0xff85457c,
    0xff8bc273, 0xff8db170, 0xff8e9f6e, 0xff908e6b, 0xff927c69, 0xff955263,
    0xffb1e238, 0xffb3d136, 0xffb4bf34, 0xffb6ae31, 0xffb79c2f, 0xffbb7229,
    0xff3a90ce, 0xff3b7fcb, 0xff3d6dc9, 0xff3f5bc6, 0xff404ac4, 0xff4420be,
    0xff4a9eb5, 0xff4b8cb3, 0xff4d7bb0, 0xff4f69ae, 0xff5057ab, 0xff542ea5,
    0xff5aab9d, 0xff5b9a9a, 0xff5d8898, 0xff5e7695, 0xff606593, 0xff643b8d,
    0xff6ab984, 0xff6ba782, 0xff6d967f, 0xff6e847d, 0xff70727a, 0xff744974,
    0xff7ac66c, 0xff7bb569, 0xff7da367, 0xff7e9264, 0xff808062, 0xff84565c,
    0xff9fe631, 0xffa1d52f, 0xffa3c32c, 0xffa4b22a, 0xffa6a027, 0xffaa7621,
    0xff109abc, 0xff1288ba, 0xff1377b7, 0xff1565b5, 0xff1653b3, 0xff1a2aad,
    0xff20a7a4, 0xff2296a1, 0xff23849f, 0xff25729c, 0xff26619a, 0xff2a3794,
    0xff30b58b, 0xff32a389, 0xff339286, 0xff358084, 0xff366e81, 0xff3a457b,
    0xff40c273, 0xff41b170, 0xff439f6e, 0xff458e6b, 0xff467c69, 0xff4a5263,
    0xff50d05a, 0xff51be58, 0xff53ad55, 0xff559b53, 0xff568a50, 0xff5a604a,
    0xff76f020, 0xff77de1d, 0xff79cd1b, 0xff7bbb18, 0xff7caa16, 0xff808010,
    0xff8080dc, 0xff8080d4, 0xff8080cb, 0xff8080c3, 0xff8080ba, 0xff8080b1,
    0xff8080a9, 0xff8080a0, 0xff808098, 0xff80808f, 0xff808087, 0xff808075,
    0xff80806d, 0xff808064, 0xff80805c, 0xff808053, 0xff80804a, 0xff808042,
    0xff808039, 0xff808031, 0xff808028, 0xff80801f, 0xff808017, 0xffb87327,
    0xff4d555f, 0xff854876, 0xff7bb818, 0xffb3ab2f, 0xff488d67, 0xff8080b5,
    0xff80807e, 0xff6a85e2, 0xff8080bf, 0xff826abc, 0xff967b9d, 0xffaf5f77,
    0xffc55a55, 0xffd88238, 0xff7415d2, 0x008080eb
};

/* PixFormat: ARGB => A:bit31~bit24 R:bit23~bit16 G:bit15~bit8 B:bit7~bit0 */
const RK_U32 u32DftARGB8888ColorTblUser[PALETTE_TABLE_LEN] = {
    0x00ffffff, 0xff5e6060, 0xffe9491e, 0xfff4bc1f, 0xff1ca2dd, 0xff87bd43,//logo--transparency/gray/red/earthy yellow /blue
    0xffff1f1f, 0xff0000af, 0xff0000d7, 0xff0000ff, 0xff005f00, 0xff005f5f,//mute red
    0xff005f87, 0xff005faf, 0xff005fd7, 0xff005fff, 0xff008000, 0xff008080,
    0xff008700, 0xff00875f, 0xff008787, 0xff0087af, 0xff0087d7, 0xff0087ff,
    0xff00af00, 0xff00af5f, 0xff00af87, 0xff00afaf, 0xff00afd7, 0xff00afff,
    0xff00d700, 0xff00d75f, 0xff00d787, 0xff00d7af, 0xff00d7d7, 0xff00d7ff,
    0xff00ff00, 0xff00ff28, 0xff00ff5f, 0xff00ff87, 0xff00ffaf, 0xff00ffd7,
    0xff00ffff, 0xff00ffff, 0xff080808, 0xff121212, 0xff1c1c1c, 0xff262626,
    0xff303030, 0xff3a3a3a, 0xff444444, 0xff4e4e4e, 0xff585858, 0xff5f0000,
    0xff5f005f, 0xff5f0087, 0xff5f00af, 0xff5f00d7, 0xff5f00ff, 0xff5f5f00, //10
    0xff5f5f5f, 0xff5f5f87, 0xff5f5faf, 0xff5f5fd7, 0xff5f5fff, 0xff5f8700,
    0xff5f875f, 0xff5f8787, 0xff5f87af, 0xff5f87d7, 0xff5f87ff, 0xff5faf00,
    0xff5faf5f, 0xff5faf87, 0xff5fafaf, 0xff5fafd7, 0xff5fafff, 0xff5fd700,
    0xff5fd75f, 0xff5fd787, 0xff5fd7af, 0xff5fd7d7, 0xff5fd7ff, 0xff5fff00,
    0xff5fff5f, 0xff5fff87, 0xff5fffaf, 0xff5fffd7, 0xff5fffff, 0xff626262,
    0xff6c6c6c, 0xff767676, 0xff800000, 0xff800080, 0xff808000, 0xff808080,
    0xff808080, 0xff870000, 0xff87005f, 0xff870087, 0xff8700af, 0xff8700d7,
    0xff8700ff, 0xff875f00, 0xff875f5f, 0xff875f87, 0xff875faf, 0xff875fd7,
    0xff875fff, 0xff878700, 0xff87875f, 0xff878787, 0xff8787af, 0xff8787d7,
    0xff8787ff, 0xff87af00, 0xff87af5f, 0xff87af87, 0xff87afaf, 0xff87afd7,//20
    0xff87afff, 0xff87d700, 0xff87d75f, 0xff87d787, 0xff87d7af, 0xff87d7d7,
    0xff87d7ff, 0xff87ff00, 0xff87ff5f, 0xff87ff87, 0xff87ffaf, 0xff87ffd7,
    0xff87ffff, 0xff8a8a8a, 0xff949494, 0xff9e9e9e, 0xffa8a8a8, 0xffaf0000,
    0xffaf005f, 0xffaf0087, 0xffaf00af, 0xffaf00d7, 0xffaf00ff, 0xffaf5f00,
    0xffaf5f5f, 0xffaf5f87, 0xffaf5faf, 0xffaf5fd7, 0xffaf5fff, 0xffaf8700,
    0xffaf875f, 0xffaf8787, 0xffaf87af, 0xffaf87d7, 0xffaf87ff, 0xffafaf00,
    0xffafaf5f, 0xffafaf87, 0xffafafaf, 0xffafafd7, 0xffafafff, 0xffafd700,
    0xffafd75f, 0xffafd787, 0xffafd7af, 0xffafd7d7, 0xffafd7ff, 0xffafff00,
    0xffafff5f, 0xffafff87, 0xffafffaf, 0xffafffd7, 0xffafffff, 0xffb2b2b2,
    0xffbcbcbc, 0xffc0c0c0, 0xffc6c6c6, 0xffd0d0d0, 0xffd70000, 0xffd7005f,
    0xffd70087, 0xffd700af, 0xffd700d7, 0xffd700ff, 0xffd75f00, 0xffd75f5f,
    0xffd75f87, 0xffd75faf, 0xffd75fd7, 0xffd75fff, 0xffd78700, 0xffd7875f,
    0xffd78787, 0xffd787af, 0xffd787d7, 0xffd787ff, 0xffd7af00, 0xffd7af5f,
    0xffd7af87, 0xffd7afaf, 0xffd7afd7, 0xffd7afff, 0xffd7d700, 0xffd7d75f,
    0xffd7d787, 0xffd7d7af, 0xffd7d7d7, 0xffd7d7ff, 0xffd7ff00, 0xffd7ff5f,
    0xffd7ff87, 0xffd7ffaf, 0xffd7ffd7, 0xffd7ffff, 0xffdadada, 0xffe4e4e4,
    0xffeeeeee, 0xffff0000, 0xffff0028, 0xffff005f, 0xffff0087, 0xffff00af,
    0xffff00d7, 0xffff00ff, 0xffff00ff, 0xffff5f00, 0xffff5f5f, 0xffff5f87,
    0xffff5faf, 0xffff5fd7, 0xffff5fff, 0xffff8700, 0xffff875f, 0xffff8787,
    0xffff87af, 0xffff87d7, 0xffff87ff, 0xffffaf00, 0xffffaf5f, 0xffffaf87,
    0xffffafaf, 0xffffafd7, 0xffffafff, 0xffffd700, 0xffffd75f, 0xffffd787,
    0xffffd7af, 0xffffd7d7, 0xffffd7ff, 0xffffff00, 0xffffff28, 0xffffff5f,
    0xffffff87, 0xffffffaf, 0xffffffd7, 0xffffffff,
};


/* PixFormat: ARGB => A:bit31~bit24 R:bit23~bit16 G:bit15~bit8 B:bit7~bit0 */
const RK_U32 u32DftARGB8888ColorTbl[PALETTE_TABLE_LEN] = {
    0x00000000, 0xff000000, 0xff000000, 0xff00005f, 0xff000080, 0xff000087,//0x00ffffff
    0xff0000af, 0xff0000d7, 0xff0000ff, 0xff0000ff, 0xff005f00, 0xff005f5f,
    0xff005f87, 0xff005faf, 0xff005fd7, 0xff005fff, 0xff008000, 0xff008080,
    0xff008700, 0xff00875f, 0xff008787, 0xff0087af, 0xff0087d7, 0xff0087ff,
    0xff00af00, 0xff00af5f, 0xff00af87, 0xff00afaf, 0xff00afd7, 0xff00afff,
    0xff00d700, 0xff00d75f, 0xff00d787, 0xff00d7af, 0xff00d7d7, 0xff00d7ff,
    0xff00ff00, 0xff00ff28, 0xff00ff5f, 0xff00ff87, 0xff00ffaf, 0xff00ffd7,
    0xff00ffff, 0xff00ffff, 0xff080808, 0xff121212, 0xff1c1c1c, 0xff262626,
    0xff303030, 0xff3a3a3a, 0xff444444, 0xff4e4e4e, 0xff585858, 0xff5f0000,
    0xff5f005f, 0xff5f0087, 0xff5f00af, 0xff5f00d7, 0xff5f00ff, 0xff5f5f00,
    0xff5f5f5f, 0xff5f5f87, 0xff5f5faf, 0xff5f5fd7, 0xff5f5fff, 0xff5f8700,
    0xff5f875f, 0xff5f8787, 0xff5f87af, 0xff5f87d7, 0xff5f87ff, 0xff5faf00,
    0xff5faf5f, 0xff5faf87, 0xff5fafaf, 0xff5fafd7, 0xff5fafff, 0xff5fd700,
    0xff5fd75f, 0xff5fd787, 0xff5fd7af, 0xff5fd7d7, 0xff5fd7ff, 0xff5fff00,
    0xff5fff5f, 0xff5fff87, 0xff5fffaf, 0xff5fffd7, 0xff5fffff, 0xff626262,
    0xff6c6c6c, 0xff767676, 0xff800000, 0xff800080, 0xff808000, 0xff808080,
    0xff808080, 0xff870000, 0xff87005f, 0xff870087, 0xff8700af, 0xff8700d7,
    0xff8700ff, 0xff875f00, 0xff875f5f, 0xff875f87, 0xff875faf, 0xff875fd7,
    0xff875fff, 0xff878700, 0xff87875f, 0xff878787, 0xff8787af, 0xff8787d7,
    0xff8787ff, 0xff87af00, 0xff87af5f, 0xff87af87, 0xff87afaf, 0xff87afd7,
    0xff87afff, 0xff87d700, 0xff87d75f, 0xff87d787, 0xff87d7af, 0xff87d7d7,
    0xff87d7ff, 0xff87ff00, 0xff87ff5f, 0xff87ff87, 0xff87ffaf, 0xff87ffd7,
    0xff87ffff, 0xff8a8a8a, 0xff949494, 0xff9e9e9e, 0xffa8a8a8, 0xffaf0000,
    0xffaf005f, 0xffaf0087, 0xffaf00af, 0xffaf00d7, 0xffaf00ff, 0xffaf5f00,
    0xffaf5f5f, 0xffaf5f87, 0xffaf5faf, 0xffaf5fd7, 0xffaf5fff, 0xffaf8700,
    0xffaf875f, 0xffaf8787, 0xffaf87af, 0xffaf87d7, 0xffaf87ff, 0xffafaf00,
    0xffafaf5f, 0xffafaf87, 0xffafafaf, 0xffafafd7, 0xffafafff, 0xffafd700,
    0xffafd75f, 0xffafd787, 0xffafd7af, 0xffafd7d7, 0xffafd7ff, 0xffafff00,
    0xffafff5f, 0xffafff87, 0xffafffaf, 0xffafffd7, 0xffafffff, 0xffb2b2b2,
    0xffbcbcbc, 0xffc0c0c0, 0xffc6c6c6, 0xffd0d0d0, 0xffd70000, 0xffd7005f,
    0xffd70087, 0xffd700af, 0xffd700d7, 0xffd700ff, 0xffd75f00, 0xffd75f5f,
    0xffd75f87, 0xffd75faf, 0xffd75fd7, 0xffd75fff, 0xffd78700, 0xffd7875f,
    0xffd78787, 0xffd787af, 0xffd787d7, 0xffd787ff, 0xffd7af00, 0xffd7af5f,
    0xffd7af87, 0xffd7afaf, 0xffd7afd7, 0xffd7afff, 0xffd7d700, 0xffd7d75f,
    0xffd7d787, 0xffd7d7af, 0xffd7d7d7, 0xffd7d7ff, 0xffd7ff00, 0xffd7ff5f,
    0xffd7ff87, 0xffd7ffaf, 0xffd7ffd7, 0xffd7ffff, 0xffdadada, 0xffe4e4e4,
    0xffeeeeee, 0xffff0000, 0xffff0028, 0xffff005f, 0xffff0087, 0xffff00af,
    0xffff00d7, 0xffff00ff, 0xffff00ff, 0xffff5f00, 0xffff5f5f, 0xffff5f87,
    0xffff5faf, 0xffff5fd7, 0xffff5fff, 0xffff8700, 0xffff875f, 0xffff8787,
    0xffff87af, 0xffff87d7, 0xffff87ff, 0xffffaf00, 0xffffaf5f, 0xffffaf87,
    0xffffafaf, 0xffffafd7, 0xffffafff, 0xffffd700, 0xffffd75f, 0xffffd787,
    0xffffd7af, 0xffffd7d7, 0xffffd7ff, 0xffffff00, 0xffffff28, 0xffffff5f,
    0xffffff87, 0xffffffaf, 0xffffffd7, 0xffffffff,
};

static void bmp_to_yuva_map(osd_data_s *data);
static bool osd_get_bmp_info(osd_data_s *draw_data);

void mpp_osd_region_id_enable_set(MpiEncTestData *p, int region_id, int enable)
{
    if (p)
        p->osd_data.region[region_id].enable = enable;
}

int mpp_osd_region_id_enable_get(MpiEncTestData *p, int region_id)
{
    if (p)
        return p->osd_data.region[region_id].enable;
    else
        return -1;
}

void mpp_osd_enable_set(MpiEncTestData *p, bool enable)
{
    int i = 0;
    if (p) {
        p->osd_enable = enable;
        if ((p->type == MPP_VIDEO_CodingAVC || p->type == MPP_VIDEO_CodingHEVC)) {
            if (!enable) {
                for (i = 0; i < OSD_REGIONS_CNT; i ++) {
#ifdef MPP_OSD_ENABLE_SET_HISTORY
                    p->osd_index_enable[i] = p->osd_data.region[i].enable;
#endif
                    mpp_osd_region_id_enable_set(p, i, false);
                }
            } else {
                for (i = 0; i < OSD_REGIONS_CNT; i ++) {
#ifdef MPP_OSD_ENABLE_SET_HISTORY
                    mpp_osd_region_id_enable_set(p, i, p->osd_index_enable[i]);
#else
                    mpp_osd_region_id_enable_set(p, i, true);
#endif
                }
            }
        }
    }
}

bool mpp_osd_enable_get(MpiEncTestData *p)
{
    if (p)
        return p->osd_enable;
    else
        return false;
}

void mpp_osd_run(MpiEncTestData *p, int fd, MppFrame frame)
{
#if 0 //test
    if (!access("/tmp/osd2", 0)) {
        mpp_osd_enable_set(p, !mpp_osd_enable_get(p));
        system("rm /tmp/osd2");
    }
#endif

    if (mpp_osd_enable_get(p)) {// && p->osd_data.num_region && p->osd_data.buf
        if (p->type == MPP_VIDEO_CodingMJPEG) {
#if MJPEG_RGA_OSD_ENABLE
            for (int i = 0; i < p->osd_count; i ++) {
                if (p->osd_cfg[i].set_ok == true) {
                   if (p->osd_cfg[i].type == OSD_REGION_TYPE_PICTURE) {
#if 0 //test
                       if (!access("/tmp/osd0", 0)) {
                           mpp_osd_region_id_enable_set(p, 0, !mpp_osd_region_id_enable_get(p, 0));
                           system("rm /tmp/osd0");
                       } //test
                       if (!access("/tmp/osd1", 0)) {
                           mpp_osd_region_id_enable_set(p, 1, !mpp_osd_region_id_enable_get(p, 1));
                           system("rm /tmp/osd1");
                       }
#endif
                       if (mpp_osd_region_id_enable_get(p, i))
                           mjpeg_rga_osd_process(p, i, fd);
                   } else {
                       LOG_WARN("ost no supprot this type:%d\n", p->osd_cfg[i].type);
                   }
                }
            }
#endif
        } else {
            MppMeta meta = NULL;
            meta = mpp_frame_get_meta(frame);
           // LOG_INFO("MPP Encoder: set osd data(%d regions) to frame\n", p->osd_data.num_region);
#if 0 //test
            if (!access("/tmp/osd0", 0)) {
                mpp_osd_region_id_enable_set(p, 0, !mpp_osd_region_id_enable_get(p, 0));
                system("rm /tmp/osd0");
            } //test
            if (!access("/tmp/osd1", 0)) {
                mpp_osd_region_id_enable_set(p, 1, !mpp_osd_region_id_enable_get(p, 1));
                system("rm /tmp/osd1");
            }
#endif
            mpp_meta_set_ptr(meta, KEY_OSD_DATA, (void*)&p->osd_data);
        }
    }

}

static int mpp_osd_update_region_info(MppEncOSDData *osd, OsdRegionData *region_data)
{
  uint32_t new_size = 0;
  uint32_t old_size = 0;
  uint8_t rid = region_data->region_id;
  uint8_t *region_src = NULL;
  uint8_t *region_dst = NULL;

  if (!region_data->enable) {
      osd->region[rid].enable = 0;
      osd->num_region = 0;
      for (int i = 0; i < OSD_REGIONS_CNT; i++) {
          if (osd->region[i].enable)
              osd->num_region = i + 1;
      }
      assert(osd->num_region <= 8);
      return 0;
  }

  // get buffer size to compare.
  new_size = region_data->width * region_data->height;
  // If there is enough space, reuse the previous buffer.
  // However, the current area must be active, so as to
  // avoid opening up too large a buffer at the beginning,
  // and it will not be reduced later.
  if (osd->region[rid].enable)
    old_size =
      osd->region[rid].num_mb_x * osd->region[rid].num_mb_y * 256;

  // update region info.
  osd->region[rid].enable = region_data->enable;//1;
  osd->region[rid].inverse = region_data->inverse;
  osd->region[rid].start_mb_x = region_data->pos_x / 16;
  osd->region[rid].start_mb_y = region_data->pos_y / 16;
  osd->region[rid].num_mb_x = region_data->width / 16;
  osd->region[rid].num_mb_y = region_data->height / 16;

  // 256 * 16 => 4096 is enough for osd.
  assert(osd->region[rid].start_mb_x <= 256);
  assert(osd->region[rid].start_mb_y <=  256);
  assert(osd->region[rid].num_mb_x <=  256);
  assert(osd->region[rid].num_mb_y <=  256);

  // region[rid] buffer size is enough, copy data directly.
  if (old_size >= new_size) {
      LOG_DEBUG("MPP Encoder: Region[%d] reuse old buff:%u, new_size:%u\n",
                 rid, old_size, new_size);
      region_src = region_data->buffer;
      region_dst = (uint8_t *)mpp_buffer_get_ptr(osd->buf);
      region_dst += osd->region[rid].buf_offset;
      memcpy(region_dst, region_src, new_size);

      return 0;
  }

  // region[rid] buffer size too small, resize buffer.
  MppBuffer new_buff = NULL;
  MppBuffer old_buff = NULL;
  uint32_t old_offset[OSD_REGIONS_CNT] = {0};
  uint32_t total_size = 0;
  uint32_t current_size = 0;

  osd->num_region = 0;
  for (int i = 0; i < OSD_REGIONS_CNT; i++) {
    if (osd->region[i].enable) {
      old_offset[i] = osd->region[i].buf_offset;
      osd->region[i].buf_offset = total_size;
      total_size +=
        osd->region[i].num_mb_x * osd->region[i].num_mb_y * 256;
      osd->num_region = i + 1;
    } else {
      osd->region[i].start_mb_x = 0;
      osd->region[i].start_mb_y = 0;
      osd->region[i].buf_offset = 0;
      osd->region[i].num_mb_x = 0;
      osd->region[i].num_mb_y = 0;
    }
  }

  old_buff = osd->buf;
  int ret = mpp_buffer_get(NULL, &new_buff, total_size);
  if (ret) {
      LOG_ERROR("ERROR: MPP Encoder: get osd %dBytes buffer failed(%d)\n",
                total_size, ret);
      // reset target region.
      osd->region[rid].enable = 0;
      osd->region[rid].start_mb_x = 0;
      osd->region[rid].start_mb_y = 0;
      osd->region[rid].buf_offset = 0;
      return -1;
  }

  for (int i = 0; i < OSD_REGIONS_CNT; i++) {
      if (!osd->region[i].enable)
          continue;

      if (i != rid) {
          // copy other region data to new buffer.
          region_src = (uint8_t *)mpp_buffer_get_ptr(old_buff);
          region_src += old_offset[i];
          region_dst = (uint8_t *)mpp_buffer_get_ptr(new_buff);
          region_dst += osd->region[i].buf_offset;
          current_size =
            osd->region[i].num_mb_x * osd->region[i].num_mb_y * 256;
      } else {
          // copy current region data to new buffer.
          region_src = region_data->buffer;
          region_dst = (uint8_t *)mpp_buffer_get_ptr(new_buff);
          region_dst += osd->region[i].buf_offset;
          current_size = new_size;
      }

      assert(region_src);
      assert(region_dst);
      memcpy(region_dst, region_src, current_size);
  }

  //replace old buff with new buff.
  osd->buf = new_buff;
  if (old_buff)
      mpp_buffer_put(old_buff);

  return 0;
}

static int mpp_osd_region_set(MpiEncTestData *p, OsdRegionData *rdata)
{
  if (!rdata)
    return -1;

  LOG_DEBUG("MPP Encoder: setting osd regions...\n");
  if ((rdata->region_id >= OSD_REGIONS_CNT)) {
      LOG_ERROR("ERROR: MPP Encoder: invalid region id(%d), should be [0, %d).\n",
                 rdata->region_id, OSD_REGIONS_CNT);
      return -1;
  }

  if (rdata->enable && !rdata->buffer) {
      LOG_ERROR("ERROR: MPP Encoder: invalid region data");
      return -1;
  }

  if ((rdata->width % 16) || (rdata->height % 16) ||
      (rdata->pos_x % 16) || (rdata->pos_y % 16)) {
      LOG_WARN("WARN: MPP Encoder: osd size must be 16 aligned,w:%d,h:%d,x:%d,y:%d\n",
                rdata->width, rdata->height, rdata->pos_x, rdata->pos_y);
      rdata->width = UPALIGNTO16(rdata->width);
      rdata->height = UPALIGNTO16(rdata->height);
      rdata->pos_x = UPALIGNTO16(rdata->pos_x);
      rdata->pos_y = UPALIGNTO16(rdata->pos_y);
  }

  int ret = mpp_osd_update_region_info(&p->osd_data, rdata);
  return ret;
}

int mpp_enc_gen_osd_plt(MpiEncTestData *p, uint32_t *ptl_data)
{
  if (!ptl_data)
      return -1;

  MppCtx ctx = p->ctx;
  MppApi *mpi = p->mpi;
  MppEncOSDPltCfg osd_plt_cfg;

  //TODO rgba plt to yuva plt.
  for (int k = 0; k < 256; k++)
      p->osd_plt.data[k].val = *(ptl_data + k);//ptl_data[k % 8];//

  p->osd_plt_cfg.change = MPP_ENC_OSD_PLT_CFG_CHANGE_ALL;
  p->osd_plt_cfg.type = MPP_ENC_OSD_PLT_TYPE_USERDEF;
  p->osd_plt_cfg.plt = &p->osd_plt;

  int ret = mpi->control(ctx, MPP_ENC_SET_OSD_PLT_CFG, &p->osd_plt_cfg);
  if (ret)
      LOG_ERROR("ERROR: MPP Encoder: set osd plt failed ret %d\n", ret);

  return ret;
}

int mpp_osd_bmp_to_ayuv_image(MpiEncTestData *p, osd_data_s *draw_data)
{
    int ret = 0;
    int read_len = 0, read_cout = 0, pitch = 0;
    OsdRegionData osd_region_data;

    draw_data->bmp_file = fopen(draw_data->image, "rb");
    if (draw_data->bmp_file == NULL) {
        LOG_ERROR("yuv file open:%s fail!\n", draw_data->image);
        return -1;
    }
    if(!osd_get_bmp_info(draw_data)) {
        LOG_ERROR("osd_get_bmp_info fail!\n");
        ret = -1;
        goto ERR;
    }
    draw_data->width = draw_data->bmp_info_head.biWidth;
    draw_data->height = draw_data->bmp_info_head.biHeight;
    pitch = WIDTHBYTES(draw_data->width * draw_data->bmp_info_head.biBitCount);
    draw_data->size = pitch * draw_data->height;

    LOG_DEBUG("w:%d h:%d d:%d size:%d bfOffBits:%d\n",
               draw_data->width, draw_data->height,
               draw_data->bmp_info_head.biBitCount, draw_data->size,
               draw_data->bmp_bit_head.bfOffBits); //test debug

    draw_data->bmp_data = (uint8_t *)malloc(draw_data->size);

    while (read_len < draw_data->size && read_cout < 10) {//read bmp data
        read_len += fread(&draw_data->bmp_data[read_len], 1, draw_data->size - read_len, draw_data->bmp_file);
        read_cout ++;
    };
    if (read_cout >= 10) {
        LOG_ERROR("yuv read open:%s fail, len=%d!\n", draw_data->image, read_len);
        ret = -1;
        goto ERR;
    }

    LOG_DEBUG("0:%d 1:%d 2:%d 3:%d 4:%d\n",
               draw_data->bmp_data[0],
               draw_data->bmp_data[1],
               draw_data->bmp_data[2],
               draw_data->bmp_data[3],
               draw_data->bmp_data[4]); //test debug

    draw_data->buffer = (uint8_t *)malloc(draw_data->width * draw_data->height);
    bmp_to_yuva_map(draw_data);

    osd_region_data.inverse = 0;
    osd_region_data.enable = draw_data->enable;
    osd_region_data.region_id = draw_data->region_id;
    osd_region_data.pos_x = draw_data->origin_x;
    osd_region_data.pos_y = draw_data->origin_y;
    osd_region_data.width = draw_data->width;
    osd_region_data.height = draw_data->height;
    osd_region_data.buffer = draw_data->buffer;

    LOG_DEBUG("UpdateImage enable %d x %d y %d w %d h %d\n", draw_data->enable,
              draw_data->origin_x, draw_data->origin_y, draw_data->width,
              draw_data->height);
    ret = mpp_osd_region_set(p, &osd_region_data);
ERR:
    if (draw_data->bmp_file)
        fclose(draw_data->bmp_file);
    if (draw_data->bmp_data)
        free(draw_data->bmp_data);
    if (draw_data->buffer)
        free(draw_data->buffer);
    return ret;
}
/* Match an RGB value to a particular palette index */
static bool osd_get_bmp_info(osd_data_s *draw_data)
{
    WORD fileType;
    char tmp[100];
    fread(&fileType, 1, sizeof(WORD), draw_data->bmp_file);
    if (fileType != 0x4d42) {
        LOG_ERROR("file is not .bmp file:%s!", draw_data->image);
        return false;
    }
    fread(&draw_data->bmp_bit_head, 1, sizeof(BITMAPFILEHEADER), draw_data->bmp_file);
    fread(&draw_data->bmp_info_head, 1, sizeof(BITMAPINFOHEADER), draw_data->bmp_file);
    if (draw_data->bmp_bit_head.bfOffBits > 54) {
        fread(tmp, 1, draw_data->bmp_bit_head.bfOffBits - 54, draw_data->bmp_file);
        draw_data->bmp_type = BMP_TYPE_BGRA_2;
    } else {
        draw_data->bmp_type = BMP_TYPE_BGRA_1;
    }

    if (draw_data->bmp_info_head.biBitCount < 24) {
        LOG_ERROR("bmp:%s must be 24/32 depth!", draw_data->image);
        return false;
    }
    return true;
}

RK_S32 color_tbl_argb_to_avuy(const RK_U32 *pu32RgbaTbl, RK_U32 *pu32AvuyTbl)
{
  unsigned char r, g, b, a;
  unsigned char y, u, v, alpha;

  for (int i = 0; i < PALETTE_TABLE_LEN; i++) {
    a = (pu32RgbaTbl[i] & 0xFF000000) >> 24;
    r = (pu32RgbaTbl[i] & 0x00FF0000) >> 16;
    g = (pu32RgbaTbl[i] & 0x0000FF00) >> 8;
    b = (pu32RgbaTbl[i] & 0x000000FF);

    // BT601
    y = 16 + 0.257 * r + 0.504 * g + 0.098 * b;
    u = 128 - 0.148 * r - 0.291 * g + 0.439 * b;
    v = 128 + 0.439 * r - 0.368 * g - 0.071 * b;
    alpha = a;

    pu32AvuyTbl[i] = (alpha << 24) | (v << 16) | (u << 8) | y;
  }

  return 0;
}

static uint8_t inline find_color(const uint32_t *pal, uint32_t len, uint8_t r,
                                  uint8_t g, uint8_t b)
{
    uint32_t i = 0;
    uint8_t pixel = 0;
    unsigned int smallest = 0;
    unsigned int distance = 0;
    int rd, gd, bd;
    uint8_t rp, gp, bp;

    smallest = ~0;

    for (i = 0; i < len; ++i) {
        bp = (pal[i] & 0xff000000) >> 24;
        gp = (pal[i] & 0x00ff0000) >> 16;
        rp = (pal[i] & 0x0000ff00) >> 8;
        rd = rp - r;
        gd = gp - g;
        bd = bp - b;
        distance = (rd * rd) + (gd * gd) + (bd * bd);
        if (distance < smallest) {
            pixel = i;
            /* Perfect match! */
            if (distance == 0)
              break;
            smallest = distance;
        }
    }

    return pixel;
}

/* Match an RGB value to a particular palette index */
RK_U8 find_argb_color_tbl_by_order(const RK_U32 *pal, RK_U32 len,
                                   RK_U32 u32ArgbColor)
{
  RK_U8 a, r, g, b;
  RK_U32 i = 0;
  RK_U8 pixel = 0;
  RK_U32 smallest = 0;
  RK_U32 distance = 0;
  RK_U8 ap, rp, gp, bp;

  a = (u32ArgbColor & 0xFF000000) >> 24;
  r = (u32ArgbColor & 0x00FF0000) >> 16;
  g = (u32ArgbColor & 0x0000FF00) >> 8;
  b = (u32ArgbColor & 0x000000FF);

  smallest = ~0;
  for (i = 0; i < len; ++i) {
    ap = (pal[i] & 0xFF000000) >> 24;
    rp = (pal[i] & 0x00FF0000) >> 16;
    gp = (pal[i] & 0x0000FF00) >> 8;
    bp = (pal[i] & 0x000000FF);

    distance = abs(ap - a) + abs(rp - r) + abs(gp - g) + abs(bp - b);
    if (distance < smallest) {
      pixel = i;

      /* Perfect match! */
      if (distance == 0)
        break;

      smallest = distance;
    }
  }

  return pixel;
}

static void bmp_to_yuva_map(osd_data_s *data)
{
    LOG_DEBUG("bmp_to_yuva_map depth:%d\n", data->bmp_info_head.biBitCount);
    int k, offset;
    int width = data->width;
    int height = data->height;
    int pitch = WIDTHBYTES(width * data->bmp_info_head.biBitCount);

    switch (data->bmp_info_head.biBitCount) {
        case 24:
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                k = (height - i - 1) * pitch + j * 3;
                offset = i * data->width + j;
                // printf("offset %d k %d\n", offset, k);
                data->buffer[offset] =
                    find_color(rgb888_palette_table, PALETTE_TABLE_LEN, data->bmp_data[k + 2],
                               data->bmp_data[k + 1], data->bmp_data[k]);//
            }
        }
        break;
        case 32: {
            RK_U32 TargetWidth, TargetHeight;
            BMP_DATA ColorValue;
            RK_U32 *BitmapLineStart;
            RK_U8 *CanvasLineStart;
            TargetWidth = data->width;
            TargetHeight = data->height;

            RK_U8 tb_data;
#if OSD_DATA_DEBUG
            FILE *fp_in = NULL, *fp_out = NULL;
            fp_in = fopen("/data/in.bmp","w+b");
            fp_out = fopen("/data/out.bmp","w+b");
#endif
            for (RK_U32 i = 0; i < TargetHeight; i++) {
                BitmapLineStart = (RK_U32 *)data->bmp_data + (TargetHeight - 1 - i) * TargetWidth;
                CanvasLineStart = data->buffer + i * TargetWidth;
                for (RK_U32 j = 0; j < TargetWidth; j++) {
                    ColorValue.data_32 = *(BitmapLineStart + j);
                    if (data->bmp_type == BMP_TYPE_BGRA_1 && ColorValue.data_32 != 0x00ffffff)
                        ColorValue.data_32 |= 0xff000000;
                    else if (data->bmp_type == BMP_TYPE_BGRA_2 && ColorValue.bgra_a == 0x00)
                        ColorValue.data_32 = 0x00ffffff;

                    tb_data = find_argb_color_tbl_by_order(
                          data->plt_table, PALETTE_TABLE_LEN, ColorValue.data_32);
#if FIX_MPP_WHITE_EDGE_VALUE
                    if (tb_data > FIX_MPP_WHITE_EDGE_VALUE) {
                        //LOG_ERROR("data:%d!", tb_data); // test
                        tb_data = 0;
                    }
#endif
                    *(CanvasLineStart + j) = tb_data;
#if OSD_DATA_DEBUG
                    fwrite(&ColorValue.data_32, 1, 4, fp_in);
                    fwrite(&tb_data, 1, 1, fp_out);
#endif
                }
            }
#if OSD_DATA_DEBUG
            fclose(fp_in);
            fclose(fp_out);
            LOG_ERROR("!");
#endif
/*
            for (int i = 0; i < height; i++) {
                for (int j = 0; j < width; j++) {
                    k = (height - i - 1) * pitch + j * 4;
                    offset = i * data->width + j;
                    // printf("offset %d k %d\n", offset, k);
                    data->buffer[offset] =
                        find_color(u32DftARGB8888ColorTbl, PALETTE_TABLE_LEN, data->bmp_data[k + 2],
                                   data->bmp_data[k + 1], data->bmp_data[k]);//rgb888_palette_table
                }
            }*/
        }
        break;
        default:
            LOG_ERROR("bmp must be 24/32 depth!");
        break;
    }
}

static MPP_RET mpp_enc_gen_osd_data(MppEncOSDData *osd_data, MppBuffer osd_buf, RK_U32 frame_cnt)
{
    RK_U32 k = 0;
    RK_U32 buf_size = 0;
    RK_U32 buf_offset = 0;
    RK_U8 *buf = mpp_buffer_get_ptr(osd_buf);

    osd_data->num_region = 8;
    osd_data->buf = osd_buf;

    for (k = 0; k < osd_data->num_region; k++) {
        MppEncOSDRegion *region = &osd_data->region[k];
        RK_U8 idx = k;

        region->enable = 1;
        region->inverse = 0;//frame_cnt & 1;
        region->start_mb_x = k * 3;
        region->start_mb_y = k * 2;
        region->num_mb_x = 2;
        region->num_mb_y = 2;

        buf_size = region->num_mb_x * region->num_mb_y * 256;
        buf_offset = k * buf_size;
        osd_data->region[k].buf_offset = buf_offset;

        memset(buf + buf_offset, idx, buf_size);
    }

    return MPP_OK;
}

MPP_RET mpp_osd_default_set(MpiEncTestData *p)
{
    MPP_RET ret = MPP_OK;
    if (p->osd_enable && (p->type == MPP_VIDEO_CodingAVC || p->type == MPP_VIDEO_CodingHEVC)) {
        const RK_U32 *pu32ArgbColorTbl;
        if (p->osd_plt_user)
            pu32ArgbColorTbl = u32DftARGB8888ColorTblUser;
        else
            pu32ArgbColorTbl = u32DftARGB8888ColorTbl;
        color_tbl_argb_to_avuy(pu32ArgbColorTbl, p->plt_table);
        p->osd_idx_size  = p->hor_stride * p->ver_stride / 8;
        ret = mpp_buffer_get(p->pkt_grp, &p->osd_idx_buf, p->osd_idx_size);
        if (ret) {
            LOG_ERROR("failed to get buffer for input osd index ret %d\n", ret);
            goto RET;
        }
#if 1
        /* gen and cfg osd plt */
        ret = mpp_enc_gen_osd_plt(p, p->plt_table);
        if (ret) {
            LOG_ERROR("mpp_enc_gen_osd_plt err:%d\n", ret);
            goto RET;
        }
        osd_data_s osd_data;
        osd_data.plt_table = pu32ArgbColorTbl;

        for (int i = 0; i < p->osd_count; i++) {
            if (p->osd_cfg[i].set_ok == true) {
                if (p->osd_cfg[i].type == OSD_REGION_TYPE_PICTURE) {
                    osd_data.enable = p->osd_cfg[i].enable;
                    osd_data.region_id = i;
                    osd_data.origin_x = p->osd_cfg[i].start_x;
                    osd_data.origin_y = p->osd_cfg[i].start_y;
                    osd_data.image = p->osd_cfg[i].image_path;
                    ret = mpp_osd_bmp_to_ayuv_image(p, &osd_data);
                    if (ret)
                        p->osd_cfg[i].set_ok = false;
                } else {
                    LOG_WARN("ost no supprot this type:%d\n", p->osd_cfg[i].type);
                }
            }
        }
#else // test //
        /* gen and cfg osd plt */
        ret = mpp_enc_gen_osd_plt(p, p->plt_table);
        if (ret) {
            LOG_ERROR("mpp_enc_gen_osd_plt err:%d\n", ret);
            goto RET;
        }
#if 1 //yuv image demo
        osd_data_s osd_data;

        osd_data.plt_table = pu32ArgbColorTbl;
        osd_data.enable = 1;
        osd_data.region_id = 0;
        osd_data.origin_x = 16;
        osd_data.origin_y = 32;
        osd_data.image = "/data/test-32.bmp";
        mpp_osd_bmp_to_ayuv_image(p, &osd_data);

        osd_data.enable = 1;
        osd_data.region_id = 1;
        osd_data.origin_x = 16;
        osd_data.origin_y = 320;
        osd_data.image = "/data/mute-32.bmp";
        mpp_osd_bmp_to_ayuv_image(p, &osd_data);
#else //simple demo
        mpp_enc_gen_osd_data(&p->osd_data, p->osd_idx_buf, p->frame_count);
#endif
#endif
    }
#if MJPEG_RGA_OSD_ENABLE || YUV_RGA_OSD_ENABLE
    else if (p->osd_enable && ((p->type == MPP_VIDEO_CodingMJPEG && MJPEG_RGA_OSD_ENABLE) ||
             (p->type == 0 && YUV_RGA_OSD_ENABLE))) {
        p->rga_osd_drm_fd = -1;
        osd_data_s osd_data;
        for (int i = 0; i < p->osd_count; i++) {
           if (p->osd_cfg[i].set_ok == true) {
               if (p->osd_cfg[i].type == OSD_REGION_TYPE_PICTURE) {
                   osd_data.enable = p->osd_cfg[i].enable;
                   mpp_osd_region_id_enable_set(p, i, osd_data.enable);
                   osd_data.region_id = i;
                   osd_data.origin_x = p->osd_cfg[i].start_x;
                   osd_data.origin_y = p->osd_cfg[i].start_y;
                   osd_data.image = p->osd_cfg[i].image_path;
                   ret = mjpeg_rga_osd_bmp_to_buff(p, &osd_data);
                   if (ret)
                       p->osd_cfg[i].set_ok = false;
               } else {
                   LOG_WARN("ost no supprot this type:%d\n", p->osd_cfg[i].type);
               }
           }
       }
    }
#endif
RET:
    return ret;
}
#endif

#if MJPEG_RGA_OSD_ENABLE || YUV_RGA_OSD_ENABLE
#include <rga/im2d.h>
#include <rga/rga.h>
#include "drm.h"

int mjpeg_rga_osd_bmp_to_buff(MpiEncTestData *p, osd_data_s *draw_data)
{
    int ret = 0;
    int read_len = 0, read_cout = 0, pitch = 0;
    OsdRegionData osd_region_data;
    uint32_t id = draw_data->region_id;

    draw_data->bmp_file = fopen(draw_data->image, "rb");
    if (draw_data->bmp_file == NULL) {
        LOG_ERROR("yuv file open:%s fail!\n", draw_data->image);
        return -1;
    }
    if(!osd_get_bmp_info(draw_data)) {
        LOG_ERROR("osd_get_bmp_info fail!\n");
        ret = -1;
        goto ERR;
    }
    draw_data->width = draw_data->bmp_info_head.biWidth;
    draw_data->height = draw_data->bmp_info_head.biHeight;
    pitch = WIDTHBYTES(draw_data->width * draw_data->bmp_info_head.biBitCount);
    draw_data->size = pitch * draw_data->height;
    p->osd_cfg[id].width = draw_data->width;
    p->osd_cfg[id].height = draw_data->height;
    p->osd_cfg[id].drm_size = draw_data->size;
    LOG_DEBUG("w:%d h:%d d:%d size:%d bfOffBits:%d bmp_type:%d\n",
               draw_data->width, draw_data->height,
               draw_data->bmp_info_head.biBitCount, draw_data->size,
               draw_data->bmp_bit_head.bfOffBits,
               draw_data->bmp_type); //test debug

    if (draw_data->bmp_info_head.biBitCount != 32) {
        LOG_ERROR("only support 32 bit argb bmp!this biBitCount:%d not support now!\n",
                   draw_data->bmp_info_head.biBitCount);
        ret = -1;
        goto ERR;
    }

    if (p->rga_osd_drm_fd == -1)
        p->rga_osd_drm_fd = drm_open();
    if (p->rga_osd_drm_fd < 0) {
        LOG_ERROR("rga_osd_drm_fd=%d!\n", p->rga_osd_drm_fd);
        ret = -1;
        goto ERR;
    }
    ret = drm_alloc(p->rga_osd_drm_fd, draw_data->size, 16, &p->osd_cfg[id].handle, 0);
    if (ret)
    {
        LOG_ERROR("drm_alloc fail\n");
        goto ERR;
    }
    ret = drm_handle_to_fd(p->rga_osd_drm_fd, p->osd_cfg[id].handle, &p->osd_cfg[id].rga_osd_fd, 0);
    if (ret)
    {
        LOG_ERROR("drm_handle_to_fd fail\n");
        goto ERR;
    }
    p->osd_cfg[id].buffer = (uint8_t *)drm_map_buffer(p->rga_osd_drm_fd, p->osd_cfg[id].handle, p->osd_cfg[id].drm_size);
    LOG_DEBUG("rga_osd_drm_fd=%d,buffer->handle=%d,size=%d\n",
               p->rga_osd_drm_fd, p->osd_cfg[id].handle, p->osd_cfg[id].drm_size);

    draw_data->bmp_data = (uint8_t *)malloc(draw_data->size);

    while (read_len < draw_data->size && read_cout < 10) {//read bmp data
        read_len += fread(&draw_data->bmp_data[read_len], 1, draw_data->size - read_len, draw_data->bmp_file);
        read_cout ++;
    };

    if (read_cout >= 10) {
        LOG_ERROR("yuv read open:%s fail, len=%d!\n", draw_data->image, read_len);
        ret = -1;
        goto ERR;
    }

#if OSD_DATA_DEBUG
    RK_U8 tb_data;
    FILE *fp_out = NULL;
    fp_out = fopen("/data/out.bmp","w+b");
#endif

    RK_U32 TargetWidth, TargetHeight;
    BMP_DATA ColorValue;
    RK_U32 *BitmapLineStart;
    RK_U32 *CanvasLineStart;
    RK_U8 CanvasValue;
    TargetWidth = draw_data->width;
    TargetHeight = draw_data->height;

    if (draw_data->bmp_type == BMP_TYPE_BGRA_1) {
        for (RK_U32 i = 0; i < TargetHeight; i++) {
            BitmapLineStart = (RK_U32 *)draw_data->bmp_data + (TargetHeight - 1 - i) * TargetWidth;
            CanvasLineStart = (RK_U32 *)(p->osd_cfg[id].buffer + i * TargetWidth * 4);
            for (RK_U32 j = 0; j < TargetWidth; j++) {
                ColorValue.data_32 = *(BitmapLineStart + j); //bgra1 format
                if (ColorValue.data_32 == 0x00ffffff)
                    ColorValue.data_32 = 0x00000000; //0x00000000 mean transparency
                else if (ColorValue.data_32 > 0) {
#if FIX_RGA_WHITE_EDGE_VALUE
                    if (ColorValue.bgra_r > FIX_RGA_WHITE_EDGE_VALUE &&
                        ColorValue.bgra_g > FIX_RGA_WHITE_EDGE_VALUE &&
                        ColorValue.bgra_b > FIX_RGA_WHITE_EDGE_VALUE) //fix white edge
                        ColorValue.data_32 = 0x00000000; //0x00000000 mean transparency
                    else
#endif
                        ColorValue.data_32 |= 0xff000000; //0xffxxxxxx mean not transparency
                }
                *(CanvasLineStart + j) = ColorValue.data_32;// bgra -> bgra
            }
        }

    } else if (draw_data->bmp_type == BMP_TYPE_BGRA_2) {
        for (RK_U32 i = 0; i < TargetHeight; i++) {
            BitmapLineStart = (RK_U32 *)draw_data->bmp_data + (TargetHeight - 1 - i) * TargetWidth;
            CanvasLineStart = (RK_U32 *)(p->osd_cfg[id].buffer + i * TargetWidth * 4);
            for (RK_U32 j = 0; j < TargetWidth; j++) {
                ColorValue.data_32 = *(BitmapLineStart + j); //bgra2 format
                if (ColorValue.bgra_a == 0x00)
                    ColorValue.data_32 = 0x00000000; //0x00000000 mean transparency
                else if (ColorValue.data_32 > 0) {
#if FIX_RGA_WHITE_EDGE_VALUE
                    if (ColorValue.bgra_r > FIX_RGA_WHITE_EDGE_VALUE &&
                        ColorValue.bgra_g > FIX_RGA_WHITE_EDGE_VALUE &&
                        ColorValue.bgra_b > FIX_RGA_WHITE_EDGE_VALUE) //fix white edge
                        ColorValue.data_32 = 0x00000000; //0x00000000 mean transparency
                    else
#endif
                        ColorValue.data_32 |= 0xff000000; //0xffxxxxxx mean not transparency
                }
                *(CanvasLineStart + j) = ColorValue.data_32;// bgra -> bgra
            }
        }
    } else {
        LOG_ERROR("no support such bmp type=%d!\n", draw_data->bmp_type);
        ret = -1;
        goto ERR;
    }

#if OSD_DATA_DEBUG
    for (RK_U32 i = 0; i < draw_data->size; i++)
        fwrite(&p->osd_cfg[id].buffer[i], 1, 1, fp_out);
    fclose(fp_out);
    LOG_ERROR("debug osd data ok!");
#endif

    LOG_DEBUG("TargetWidth=%d,TargetHeight=%d,0:%x 1:%x 2:%x 3:%x 4:%x\n",
               TargetWidth, TargetHeight,
               p->osd_cfg[id].buffer[0],
               p->osd_cfg[id].buffer[1],
               p->osd_cfg[id].buffer[2],
               p->osd_cfg[id].buffer[3],
               p->osd_cfg[id].buffer[4]); //test debug

ERR:
    if (draw_data->bmp_file)
        fclose(draw_data->bmp_file);
    if (draw_data->bmp_data)
        free(draw_data->bmp_data);
    if (ret) {
       drm_unmap_buffer(p->osd_cfg[id].buffer, p->osd_cfg[id].drm_size);
       if (p->osd_cfg[id].rga_osd_fd)
           close(p->osd_cfg[id].rga_osd_fd);
       if (p->rga_osd_drm_fd && p->osd_cfg[id].handle)
           drm_free(p->rga_osd_drm_fd, p->osd_cfg[id].handle);
       drm_close(p->rga_osd_drm_fd);
    }
    return ret;
}

void mjpeg_rga_osd_process(MpiEncTestData *p, int id, int src_fd)
{
    rga_buffer_t pat;
    rga_buffer_t src;
    IM_STATUS STATUS;
    src = wrapbuffer_fd(src_fd, p->width, p->height, RK_FORMAT_YCbCr_420_SP);
    pat = wrapbuffer_fd(p->osd_cfg[id].rga_osd_fd, p->osd_cfg[id].width, p->osd_cfg[id].height, RK_FORMAT_BGRA_8888);
    //RK_FORMAT_RGBA_8888 // RK_FORMAT_BGRA_8888

    im_rect pat_rect = {0, 0, p->osd_cfg[id].width, p->osd_cfg[id].height};
    im_rect src_rect = {p->osd_cfg[id].start_x, p->osd_cfg[id].start_y, p->osd_cfg[id].width, p->osd_cfg[id].height};
    STATUS = improcess(src,  src,  pat, src_rect, src_rect, pat_rect, IM_ALPHA_BLEND_DST_OVER);
    //STATUS = imblend(src,  pat, IM_ALPHA_BLEND_DST_OVER, 1);
    //STATUS = imcomposite(src, src, pat, IM_ALPHA_BLEND_DST_OVER, 1);
}
#endif