// Copyright 2020-2021 Beken
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <os/os.h>
#include <os/str.h>
#include <os/mem.h>
#include <components/log.h>
#include <common/bk_include.h>
#include <driver/int.h>
#include <driver/dvp_camera_types.h>
#include <driver/pwr_clk.h>

#include <components/video_transfer.h>

#include "media_core.h"
#include "media_evt.h"
#include "media_app.h"
#include "transfer_act.h"
#include "camera_act.h"
#include "lcd_act.h"
#include "draw_blend.h"

#include "storage_act.h"

#include "media_mailbox_list_util.h"
#include "camera_driver.h"

#ifdef CONFIG_BT_REUSE_MEDIA_MEMORY
#include "components/bluetooth/bk_ble.h"
#include "components/bluetooth/bk_dm_ble.h"
#include "components/bluetooth/bk_dm_bluetooth.h"
#endif

#define TAG "media_app"

#define LOGI(...) BK_LOGW(TAG, ##__VA_ARGS__)
#define LOGW(...) BK_LOGW(TAG, ##__VA_ARGS__)
#define LOGE(...) BK_LOGE(TAG, ##__VA_ARGS__)
#define LOGD(...) BK_LOGD(TAG, ##__VA_ARGS__)

static app_camera_type_t app_camera_type = APP_CAMERA_INVALIED;
static char *capture_name = NULL;
static media_modules_state_t *media_modules_state = NULL;

#if CONFIG_CHERRY_USB && CONFIG_USB_DEVICE
extern void usbd_video_h264_init();
extern void usbd_video_h264_deinit();
#endif

static beken_thread_t media_app_th_hd = NULL;
static beken_queue_t media_app_msg_queue = NULL;
static uvc_device_info_t uvc_device_info_cb = NULL;
static compress_ratio_t compress_factor = {0};

typedef struct {
	media_rotate_t rotate;
} jpeg_decode_pipeline_param_t;

static jpeg_decode_pipeline_param_t jpeg_decode_pipeline_param = {0};

bk_err_t media_send_msg_sync(uint32_t event, uint32_t param)
{
	int ret = BK_FAIL;
	ret = msg_send_req_to_media_app_mailbox_sync(event, param, NULL);
	if (ret != BK_OK)
	{
		LOGE("%s failed 0x%x\n", __func__, ret);
	}
	return ret;
}

uint32_t media_send_msg_sync_return_param(uint32_t event, uint32_t in_param, uint32_t *out_param)
{
	int ret = BK_FAIL;

	ret = msg_send_req_to_media_app_mailbox_sync(event, in_param, out_param);
	if (ret != BK_OK)
	{
		LOGE("%s failed 0x%x\n", __func__, ret);
	}

	return ret;
}

bk_err_t media_app_camera_open(media_camera_device_t *device)
{
	int ret = BK_FAIL;

	if (CAMERA_STATE_DISABLED != media_modules_state->cam_state)
	{
		LOGI("%s already opened\n", __func__);
		return BK_OK;
	}
	if (device->dualstream == 1)
	{
		device->num_uvc_dev = 2;
	}
	else
	{
		device->num_uvc_dev = 1;
	}

	{
		device->uvc_device[0].mode                   = device->mode;
		device->uvc_device[0].fmt                    = device->fmt;
		device->uvc_device[0].info.fps               = device->info.fps;
		device->uvc_device[0].info.resolution.width  = device->info.resolution.width;
		device->uvc_device[0].info.resolution.height = device->info.resolution.height;
	}

	if (device->num_uvc_dev == 1) {
		LOGI("%s, %d-%d, mode:%d, type:%d\r\n", __func__, device->uvc_device[0].info.resolution.width, device->uvc_device[0].info.resolution.height,
		device->uvc_device[0].mode, device->type);
	} else {
        device->uvc_device[1].mode                   = device->d_mode;
        device->uvc_device[1].fmt                    = device->d_fmt;
        device->uvc_device[1].info.fps               = device->d_info.fps;
        device->uvc_device[1].info.resolution.width  = device->d_info.resolution.width;
        device->uvc_device[1].info.resolution.height = device->d_info.resolution.height;

        LOGI("%s, %d-%d, mode:%d, type:%d\r\n", __func__, device->uvc_device[0].info.resolution.width, device->uvc_device[0].info.resolution.height,
                device->uvc_device[0].mode, device->type);
        LOGI("%s, %d-%d, mode:%d, type:%d\r\n", __func__, device->uvc_device[1].info.resolution.width, device->uvc_device[1].info.resolution.height,
                device->uvc_device[1].mode, device->type);
    }

#ifdef CONFIG_BT_REUSE_MEDIA_MEMORY
#if CONFIG_BLUETOOTH
	bk_bluetooth_deinit();
#endif
#endif

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_JPEG_EN, PM_POWER_MODULE_STATE_ON);

	if (compress_factor.enable)
	{
		ret = media_send_msg_sync(EVENT_CAM_COMPRESS_IND, (uint32_t)&compress_factor);
		if (ret != BK_OK)
		{
			LOGI("%s set error, %d\r\n", __func__, __LINE__);
		}
	}

	switch (device->type)
	{
		case DVP_CAMERA:
			ret = media_send_msg_sync(EVENT_CAM_DVP_OPEN_IND, (uint32_t)device);
			break;

		case UVC_CAMERA:
			ret = media_send_msg_sync(EVENT_CAM_UVC_OPEN_IND, (uint32_t)device);
			break;

		case NET_CAMERA:
			ret = media_send_msg_sync(EVENT_CAM_NET_OPEN_IND, (uint32_t)device);
			break;

		default:
			break;
	}

	switch (device->mode)
	{
		case JPEG_MODE:
		case JPEG_YUV_MODE:
			app_camera_type = APP_CAMERA_DVP_JPEG;
			break;

		case H264_MODE:
		case H264_YUV_MODE:
		case H265_MODE:
			app_camera_type = APP_CAMERA_DVP_H264_ENC_LCD;
			break;

		default:
			break;
	}

	if (ret == BK_OK)
	{
		media_modules_state->cam_state = CAMERA_STATE_ENABLED;
	}

	LOGI("%s complete\n", __func__);

	return ret;
}

bk_err_t media_app_camera_close(camera_type_t type)
{
	int ret = BK_FAIL;

	if (CAMERA_STATE_ENABLED != media_modules_state->cam_state)
	{
		LOGI("%s already closed\n", __func__);
		return BK_OK;
	}

	switch (type)
	{
		case DVP_CAMERA:
			ret = media_send_msg_sync(EVENT_CAM_DVP_CLOSE_IND, 0);
			break;

		case UVC_CAMERA:
			ret = media_send_msg_sync(EVENT_CAM_UVC_CLOSE_IND, 0);
			break;

		case NET_CAMERA:
			ret = media_send_msg_sync(EVENT_CAM_NET_CLOSE_IND, 0);
			break;

		default:
			break;
	}

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_JPEG_EN, PM_POWER_MODULE_STATE_OFF);

	if (ret == BK_OK)
	{
		media_modules_state->cam_state = CAMERA_STATE_DISABLED;
	}

	os_memset(&compress_factor, 0, sizeof(compress_ratio_t));

	LOGI("%s complete\n", __func__);

	return ret;
}

bk_err_t media_app_get_h264_encode_config(h264_base_config_t *config)
{
	int ret = BK_FAIL;

	if (CAMERA_STATE_ENABLED != media_modules_state->cam_state)
	{
		LOGI("%s h264 function not open!\n", __func__);
		return ret;
	}

	ret = media_send_msg_sync(EVENT_CAM_GET_H264_INFO_IND, (uint32_t)config);

	LOGI("%s complete\n", __func__);

	return ret;
}

bk_err_t media_app_uvc_register_info_notify_cb(uvc_device_info_t cb)
{
	int ret = BK_FAIL;

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_JPEG_EN, PM_POWER_MODULE_STATE_ON);

	uvc_device_info_cb = cb;

	ret = media_send_msg_sync(EVENT_CAM_REG_UVC_INFO_CB_IND, 0);

	return ret;
}

bk_err_t media_app_set_uvc_device_param(bk_uvc_config_t *config)
{
	int ret = BK_FAIL;

	if (config == NULL)
	{
		LOGI("%s param not init\n", __func__);
		return ret;
	}

	if (CAMERA_STATE_ENABLED != media_modules_state->cam_state)
	{
		LOGE("%s uvc not open\n", __func__);
		return ret;
	}

	ret = media_send_msg_sync(EVENT_CAM_SET_UVC_PARAM_IND, (uint32_t)config);

	return ret;
}

bk_err_t media_app_set_compression_ratio(compress_ratio_t *ratio)
{
	int ret = BK_FAIL;

	os_memcpy(&compress_factor, ratio, sizeof(compress_ratio_t));

	if (CAMERA_STATE_DISABLED == media_modules_state->cam_state)
	{
		LOGI("%s cam not opened\n", __func__);
		return BK_OK;
	}

	ret = media_send_msg_sync(EVENT_CAM_COMPRESS_IND, (uint32_t)ratio);

	LOGI("%s complete\n", __func__);

	return ret;
}

bk_err_t media_app_rtsp_open(video_config_t *config)
{
	int ret = BK_FAIL;

	if (CAMERA_STATE_DISABLED != media_modules_state->cam_state)
	{
		LOGI("%s already opened\n", __func__);
		return BK_OK;
	}

	LOGI("%s, %d-%d, mode:%d, type:%d\r\n", __func__, config->device->info.resolution.width, config->device->info.resolution.height,
			config->device->mode, config->device->type);
	dvp_camera_dma_config(config);

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_JPEG_EN, PM_POWER_MODULE_STATE_ON);

	ret = media_send_msg_sync(EVENT_CAM_RTSP_OPEN_IND, (uint32_t)config->device);

	switch (config->device->mode)
	{
		case JPEG_MODE:
		case JPEG_YUV_MODE:
			app_camera_type = APP_CAMERA_DVP_JPEG;
			break;

		case H264_MODE:
		case H264_YUV_MODE:
			app_camera_type = APP_CAMERA_DVP_H264_ENC_LCD;
			break;

		default:
			break;
	}

	if (ret == BK_OK)
	{
		media_modules_state->cam_state = CAMERA_STATE_ENABLED;
	}

	LOGI("%s complete\n", __func__);

	return ret;
}

bk_err_t media_app_rtsp_close()
{
	int ret = BK_FAIL;

	if (CAMERA_STATE_ENABLED != media_modules_state->cam_state)
	{
		LOGI("%s already closed\n", __func__);
		return BK_OK;
	}
	bk_dvp_dma_deinit();

	ret = media_send_msg_sync(EVENT_CAM_RTSP_CLOSE_IND, 0);

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_JPEG_EN, PM_POWER_MODULE_STATE_OFF);

	if (ret == BK_OK)
	{
		media_modules_state->cam_state = CAMERA_STATE_DISABLED;
	}

	LOGI("%s complete\n", __func__);

	return ret;
}


bk_err_t media_app_h264_pipeline_open(void)
{
	int ret = BK_OK;

#ifdef CONFIG_BT_REUSE_MEDIA_MEMORY
#if CONFIG_BLUETOOTH
	bk_bluetooth_deinit();
#endif
#endif

	ret = media_send_msg_sync(EVENT_PIPELINE_SET_ROTATE_IND, jpeg_decode_pipeline_param.rotate);

	LOGI("%s set rotate %x\n", __func__, ret);

	ret = media_send_msg_sync(EVENT_PIPELINE_H264_OPEN_IND, 0);

	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}

bk_err_t media_app_h264_pipeline_close(void)
{
	int ret = BK_OK;
	ret = media_send_msg_sync(EVENT_PIPELINE_H264_CLOSE_IND, 0);

	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}

bk_err_t media_app_h264_regenerate_idr(camera_type_t type)
{
	int ret = BK_FAIL;

	if (CAMERA_STATE_DISABLED == media_modules_state->cam_state)
	{
		LOGI("%s camera not open\n", __func__);
		return ret;
	}

	if (type == UVC_CAMERA)
	{
		ret = media_send_msg_sync(EVENT_PIPELINE_H264_RESET_IND, 0);
	}
	else
	{
		ret = media_send_msg_sync(EVENT_CAM_H264_RESET_IND, 0);
	}

	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}

bk_err_t media_app_lcd_fmt(pixel_format_t fmt)
{
	bk_err_t ret;

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_LCD, PM_POWER_MODULE_STATE_ON);
	ret = media_send_msg_sync(EVENT_LCD_SET_FMT_IND, fmt);

	LOGI("%s complete\n", __func__);

	return ret;
}

bk_err_t media_app_pipline_set_rotate(media_rotate_t rotate)
{
	int ret = BK_OK;

	jpeg_decode_pipeline_param.rotate = rotate;
	LOGE("%s %d %d\n", __func__, __LINE__, rotate);
	return ret;
}

bk_err_t media_app_lcd_pipeline_open(void *config)
{
    int ret = BK_OK;

    ret = media_app_lcd_pipeline_disp_open(config);
    if (ret != BK_OK) {
        LOGE("%s media_app_lcd_pipeline_disp_open fail\n", __func__);
        return ret;
    }

    ret = media_app_lcd_pipeline_jdec_open();

    return ret;
}

bk_err_t media_app_lcd_pipeline_close(void)
{
    int ret = BK_OK;

    ret = media_app_lcd_pipeline_jdec_close();
    if (ret != BK_OK) {
        LOGE("%s media_app_lcd_pipeline_jdec_close fail\n", __func__);
        return ret;
    }

    ret = media_app_lcd_pipeline_disp_close();

    return ret;
}

bk_err_t media_app_lcd_pipeline_disp_open(void *config)
{
	int ret = BK_OK;

	if (config == NULL) {
		LOGE("malloc lcd_open_t failed\r\n");
		return BK_FAIL;
	}

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_LCD, PM_POWER_MODULE_STATE_ON);

	ret = media_send_msg_sync(EVENT_PIPELINE_LCD_DISP_OPEN_IND, (uint32_t)config);
	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}

bk_err_t media_app_lcd_pipeline_disp_close(void)
{
	int ret = BK_OK;

	ret = media_send_msg_sync(EVENT_PIPELINE_LCD_DISP_CLOSE_IND, 0);

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_LCD, PM_POWER_MODULE_STATE_OFF);

	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}

bk_err_t media_app_lcd_pipeline_jdec_open(void)
{
    int ret = BK_OK;

#ifdef CONFIG_BT_REUSE_MEDIA_MEMORY
#if (CONFIG_BLUETOOTH)
    bk_bluetooth_deinit();
#endif
#endif

    bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_JPEG_DE, PM_POWER_MODULE_STATE_ON);

    ret = media_send_msg_sync(EVENT_PIPELINE_SET_ROTATE_IND, jpeg_decode_pipeline_param.rotate);
    LOGI("%s set rotate %x\n", __func__, ret);

    ret = media_send_msg_sync(EVENT_PIPELINE_LCD_JDEC_OPEN_IND, 0);
    LOGI("%s complete %x\n", __func__, ret);

    return ret;
}

bk_err_t media_app_lcd_pipeline_jdec_close(void)
{
	int ret = BK_OK;

	ret = media_send_msg_sync(EVENT_PIPELINE_LCD_JDEC_CLOSE_IND, 0);

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_JPEG_DE, PM_POWER_MODULE_STATE_OFF);

	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}

bk_err_t media_app_lcd_pipline_scale_open(void *config)
{
	int ret = BK_OK;

#ifdef CONFIG_BT_REUSE_MEDIA_MEMORY
#if CONFIG_BLUETOOTH
	bk_bluetooth_deinit();
#endif
#endif

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_SCALE, PM_POWER_MODULE_STATE_ON);

	ret = media_send_msg_sync(EVENT_PIPELINE_LCD_SCALE_IND, (uint32_t)config);

	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}

bk_err_t media_app_lcd_pipline_scale_close(void)
{
	int ret = BK_OK;

	ret = media_send_msg_sync(EVENT_PIPELINE_LCD_SCALE_IND, 0);

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_SCALE, PM_POWER_MODULE_STATE_OFF);

	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}


bk_err_t media_app_mailbox_test(void)
{
	bk_err_t ret = BK_FAIL;
	uint32_t param = 0x88888888;

	LOGI("%s +++\n", __func__);

	ret = media_send_msg_sync(EVENT_LCD_DEFAULT_CMD, param);

	LOGI("%s ---\n", __func__);

	return ret;
}

bk_err_t media_app_register_read_frame_callback(pixel_format_t fmt, frame_cb_t cb)
{
	int ret = BK_OK;

	LOGI("%s\n", __func__);

	if (media_modules_state->trs_state == TRS_STATE_ENABLED)
	{
		LOGI("%s, transfer have been opened!\r\n", __func__);
		return ret;
	}

	ret = transfer_app_task_init(cb);
	if (ret != BK_OK)
	{
		return ret;
	}

	ret = media_send_msg_sync(EVENT_TRANSFER_OPEN_IND, (uint32_t)fmt);

	if (ret == BK_OK)
	{
		media_modules_state->trs_state = TRS_STATE_ENABLED;
	}

	LOGI("%s complete\n", __func__);

	return ret;
}


bk_err_t media_app_transfer_pause(bool pause)
{
	int ret = kNoErr;

	ret = media_send_msg_sync(EVENT_TRANSFER_PAUSE_IND, pause);

	return ret;
}

bk_err_t media_app_unregister_read_frame_callback(void)
{
	bk_err_t ret = BK_OK;

	media_mailbox_msg_t mb_msg;

	if (media_modules_state->trs_state == TRS_STATE_DISABLED)
	{
		LOGI("%s, transfer have been closed!\r\n", __func__);
		return ret;
	}

	LOGI("%s\n", __func__);

	ret = media_send_msg_sync(EVENT_TRANSFER_CLOSE_IND, 0);

	mb_msg.event = EVENT_TRANSFER_CLOSE_IND;
	transfer_app_event_handle(&mb_msg);

	if (ret == BK_OK)
	{
		media_modules_state->trs_state = TRS_STATE_DISABLED;
	}

	LOGI("%s complete\n", __func__);

	return ret;
}

bk_err_t media_app_usb_open(video_setup_t *setup_cfg)
{
	int ret = kNoErr;
#if CONFIG_CHERRY_USB && CONFIG_USB_DEVICE

	uint32_t param_fmt = FB_INDEX_H264;

	app_camera_type_t type = setup_cfg->open_type;

	usbd_video_h264_init();

	ret = usb_app_task_init((video_setup_t *)setup_cfg);
	if (ret != kNoErr)
	{
		LOGE("usb_app_task_init failed\r\n");
		return ret;
	}

	switch (type)
	{
		case APP_CAMERA_DVP_H264_TRANSFER:
			param_fmt = FB_INDEX_H264;
			break;
		case APP_CAMERA_DVP_JPEG:
			param_fmt = FB_INDEX_JPEG;

		default:
			LOGE("unsupported format! \r\n");
			break;
	}

	LOGI("%s, %d %d\n", __func__, type, param_fmt);

	ret = media_send_msg_sync(EVENT_TRANSFER_USB_OPEN_IND, param_fmt);

	LOGI("%s complete\n", __func__);
#endif

	return ret;
}

bk_err_t media_app_usb_close(void)
{
	bk_err_t ret = BK_OK;

#if CONFIG_CHERRY_USB && CONFIG_USB_DEVICE
	media_mailbox_msg_t mb_msg;

	LOGI("%s\n", __func__);

	usbd_video_h264_deinit();

	mb_msg.event = EVENT_TRANSFER_USB_CLOSE_IND;
	usb_app_event_handle(&mb_msg);

	ret = media_send_msg_sync(EVENT_TRANSFER_USB_CLOSE_IND, 0);
#endif

	return ret;
}

bk_err_t media_app_lcd_rotate(media_rotate_t rotate)
{
	bk_err_t ret;

	LOGI("%s\n", __func__);
	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_LCD, PM_POWER_MODULE_STATE_ON);
	ret = media_send_msg_sync(EVENT_LCD_ROTATE_ENABLE_IND, rotate);

	LOGI("%s complete\n", __func__);

	return ret;
}

bk_err_t media_app_lcd_decode(media_decode_mode_t decode_mode)
{
	bk_err_t ret;

	LOGI("%s\n", __func__);
	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_LCD, PM_POWER_MODULE_STATE_ON);

	ret = media_send_msg_sync(EVENT_LCD_DECODE_MODE_IND, decode_mode);

	LOGI("%s complete\n", __func__);

	return ret;
}

bk_err_t media_app_lcd_display_beken(void *lcd_display)
{
	bk_err_t ret;

	lcd_display_t *ptr = NULL;
	ptr = (lcd_display_t *)os_malloc(sizeof(lcd_display_t));
	os_memcpy(ptr, (lcd_display_t *)lcd_display, sizeof(lcd_display_t));

	ret = media_send_msg_sync(EVENT_LCD_BEKEN_LOGO_DISPLAY, (uint32_t)ptr);
	LOGI("%s complete\n", __func__);
	os_free(ptr);
	ptr =NULL;

	return ret;
}

// step 1
uint32_t media_app_get_lcd_devices_num(void)
{
	uint32_t num;
	bk_err_t ret;
	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_GET_MEDIA_MSG, PM_POWER_MODULE_STATE_ON);
	ret = media_send_msg_sync_return_param(EVENT_LCD_GET_DEVICES_NUM_IND, 0, &num);
	if (ret != BK_OK)
	{
		LOGE("%s error\n", __func__);
	}
	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_GET_MEDIA_MSG, PM_POWER_MODULE_STATE_OFF);
	return num;
}

// step 2
uint32_t media_app_get_lcd_devices_list(void)
{
	uint32_t device_addr = 0;
	bk_err_t ret;
	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_GET_MEDIA_MSG, PM_POWER_MODULE_STATE_ON);
	ret = media_send_msg_sync_return_param(EVENT_LCD_GET_DEVICES_LIST_IND, 0, &device_addr);
	if (ret != BK_OK)
	{
		LOGE("%s error\n", __func__);
	}
	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_GET_MEDIA_MSG, PM_POWER_MODULE_STATE_OFF);
	return device_addr;
}

uint32_t media_app_get_lcd_device_by_id(uint32_t id)
{
	uint32_t lcd_device = 0;
	bk_err_t ret;
	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_GET_MEDIA_MSG, PM_POWER_MODULE_STATE_ON);
	ret = media_send_msg_sync_return_param(EVENT_LCD_GET_DEVICES_IND, id, &lcd_device);
	if (ret != BK_OK)
	{
		LOGE("%s error\n", __func__);
	}
	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_GET_MEDIA_MSG, PM_POWER_MODULE_STATE_OFF);
	return lcd_device;
}

bk_err_t media_app_get_lcd_status(void)
{
	uint32_t lcd_status = 0;
	bk_err_t ret;
	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_GET_MEDIA_MSG, PM_POWER_MODULE_STATE_ON);
	ret = media_send_msg_sync_return_param(EVENT_LCD_GET_STATUS_IND, 0, &lcd_status);
	if (ret != BK_OK)
	{
		LOGE("%s error\n", __func__);
	}
	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_GET_MEDIA_MSG, PM_POWER_MODULE_STATE_OFF);
	return lcd_status;
}

bk_err_t media_app_get_uvc_camera_status(void)
{
	uint32_t camera_status = 0;
	bk_err_t ret;
	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_GET_MEDIA_MSG, PM_POWER_MODULE_STATE_ON);
	ret = media_send_msg_sync_return_param(EVENT_GET_UVC_STATUS_IND, 0, &camera_status);
	if (ret != BK_OK)
	{
		LOGE("%s error\n", __func__);
	}
	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_GET_MEDIA_MSG, PM_POWER_MODULE_STATE_OFF);
	return camera_status;
}

bk_err_t media_app_lcd_open(void *lcd_open)
{
	int ret = kNoErr;
	lcd_open_t *ptr = NULL;

	ptr = (lcd_open_t *)os_malloc(sizeof(lcd_open_t));
	if (ptr == NULL) {
		LOGE("malloc lcd_open_t failed\r\n");
		return kGeneralErr;
	}
	os_memcpy(ptr, (lcd_open_t *)lcd_open, sizeof(lcd_open_t));

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_LCD, PM_POWER_MODULE_STATE_ON);

	ret = media_send_msg_sync(EVENT_LCD_OPEN_IND, (uint32_t)ptr);

	if (ptr) {
		os_free(ptr);
		ptr =NULL;
	}

	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}

bk_err_t media_app_lcd_display_file(char *file_name)
{
	int ret;

	LOGI("%s ,%s\n", __func__,file_name);

	if (file_name != NULL)
	{
		uint32_t len = os_strlen(file_name) + 1;

		if (len > 31)
		{
			len = 31;
		}

		if (capture_name == NULL)
		{
			capture_name = (char *)os_malloc(len);
		}
		else
		{
			os_free(capture_name);
			capture_name = NULL;
			capture_name = (char *)os_malloc(len);
		}
		os_memset(capture_name, 0, len);
		os_memcpy(capture_name, file_name, len);
		capture_name[len - 1] = '\0';
	}

	ret = media_send_msg_sync(EVENT_LCD_DISPLAY_FILE_IND, 0);

	return ret;

}

bk_err_t read_storage_file_to_mem_handle(media_mailbox_msg_t *msg)
{
	int ret = BK_OK;
	LOGI("%s\n", __func__);

	media_mailbox_msg_t *resd_storage_node = msg;
	frame_buffer_t *frame = (frame_buffer_t  *)msg->param;
	if (capture_name == NULL)
	{
		LOGE("%s  display file is none \n", __func__);
		return BK_FAIL;
	}

#if (CONFIG_FATFS)
	ret = sdcard_read_to_mem((char *)capture_name, (uint32_t *)frame->frame, &frame->length );
#endif

	os_free(capture_name);
	capture_name = NULL;

	resd_storage_node->param = (uint32_t)frame;
	resd_storage_node->event = EVENT_LCD_PICTURE_ECHO_NOTIFY;
	resd_storage_node->result = ret;
	ret = msg_send_rsp_to_media_app_mailbox(resd_storage_node, ret);

	return ret;
}

bk_err_t media_app_lcd_display(void *lcd_display)
{
	bk_err_t ret;
	lcd_display_t *ptr = NULL;
	ptr = (lcd_display_t *)os_malloc(sizeof(lcd_display_t));
	os_memcpy(ptr, (lcd_display_t *)lcd_display, sizeof(lcd_display_t));

	ret = media_send_msg_sync(EVENT_LCD_DISPLAY_IND, (uint32_t)ptr);
	LOGI("%s complete\n", __func__);

	os_free(ptr);
	return ret;
}



bk_err_t media_app_lcd_blend_open(bool en)
{
	bk_err_t ret = 0;
	ret = media_send_msg_sync(EVENT_LCD_BLEND_OPEN_IND, en);

	LOGI("%s complete\n", __func__);
	return ret;
}

bk_err_t media_app_lcd_blend(void *param)
{
	bk_err_t ret;
	lcd_blend_msg_t *ptr = NULL;
	ptr = (lcd_blend_msg_t *)os_malloc(sizeof(lcd_blend_msg_t));
	os_memcpy(ptr, (lcd_blend_msg_t *)param, sizeof(lcd_blend_msg_t));

	ret = media_send_msg_sync(EVENT_LCD_BLEND_IND, (uint32_t)ptr);

	os_free(ptr);
	return ret;
}

bk_err_t media_app_lcd_scale(void)
{
	bk_err_t ret;

	ret = media_send_msg_sync(EVENT_LCD_SCALE_IND, 0);
	return ret;
}

bk_err_t media_app_lcd_close(void)
{
	bk_err_t ret = 0;

	LOGI("%s\n", __func__);

	ret = media_send_msg_sync(EVENT_LCD_CLOSE_IND, 0);

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_LCD, PM_POWER_MODULE_STATE_OFF);

	LOGI("%s complete\n", __func__);

	return ret;
}


bk_err_t media_app_lcd_set_backlight(uint8_t level)
{
	bk_err_t ret = BK_OK;

	LOGI("%s\n", __func__);

	ret = media_send_msg_sync(EVENT_LCD_SET_BACKLIGHT_IND, level);

	LOGI("%s complete\n", __func__);

	return ret;
}

bk_err_t media_app_storage_enable(app_camera_type_t type, uint8_t enable)
{
	int ret = BK_OK;
	uint32_t param = FB_INDEX_JPEG;
	media_mailbox_msg_t msg = {0};

	if (enable)
	{
		if (media_modules_state->stor_state == STORAGE_STATE_ENABLED)
		{
			LOGD("%s, storage have been opened!\r\n", __func__);
			return ret;
		}

		bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_VIDP_JPEG_EN, PM_POWER_MODULE_STATE_ON);

		msg.event = EVENT_STORAGE_OPEN_IND;
		ret = storage_app_event_handle(&msg);
		if (ret != BK_OK)
		{
			return ret;
		}

		if (type == APP_CAMERA_DVP_H264_LOCAL)
			param = FB_INDEX_H264;

		ret = media_send_msg_sync(EVENT_STORAGE_OPEN_IND, param);

		if (ret == BK_OK)
		{
			media_modules_state->stor_state = STORAGE_STATE_ENABLED;
		}
	}
	else
	{
		if (media_modules_state->stor_state == STORAGE_STATE_DISABLED)
		{
			LOGI("%s, storage have been closed!\r\n", __func__);
			return ret;
		}

		ret = media_send_msg_sync(EVENT_STORAGE_CLOSE_IND, 0);
		if (ret != BK_OK)
		{
			LOGE("storage_major_task deinit failed\r\n");
		}

		msg.event = EVENT_STORAGE_CLOSE_IND;
		ret = storage_app_event_handle(&msg);

		if (ret == BK_OK)
		{
			media_modules_state->stor_state = STORAGE_STATE_DISABLED;
		}
	}

	return ret;
}

bk_err_t media_app_capture(char *name)
{
	int ret = BK_OK;

	if (name == NULL)
	{
		return ret;
	}

	media_app_storage_enable(app_camera_type, 1);

	ret = storage_app_set_frame_name(name);
	if (ret != BK_OK)
	{
		return ret;
	}

	ret = media_send_msg_sync(EVENT_STORAGE_CAPTURE_IND, 0);

	LOGI("%s complete\n", __func__);

	return ret;
}

bk_err_t media_app_save_start(char *name)
{
	int ret = BK_OK;

	if (name == NULL)
	{
		return ret;
	}

	media_app_storage_enable(app_camera_type, 1);

	ret = storage_app_set_frame_name(name);
	if (ret != BK_OK)
	{
		return ret;
	}

	ret = media_send_msg_sync(EVENT_STORAGE_SAVE_START_IND, 0);

	LOGI("%s complete\n", __func__);

	return ret;
}


bk_err_t media_app_save_stop(void)
{
	int ret = BK_OK;
	media_mailbox_msg_t msg = {0};

	if (media_modules_state->stor_state == STORAGE_STATE_DISABLED)
	{
		LOGI("%s storage function not init\n", __func__);
		return ret;
	}

	ret = media_send_msg_sync(EVENT_STORAGE_SAVE_STOP_IND, 0);
	if (ret != BK_OK)
	{
		LOGE("storage_major_task stop save video failed\r\n");
	}

	msg.event = EVENT_STORAGE_SAVE_STOP_IND;
	ret = storage_app_event_handle(&msg);

	LOGI("%s complete\n", __func__);

	return ret;
}

bk_err_t media_app_dump_display_frame(void)
{
	return media_send_msg_sync(EVENT_LCD_DUMP_DISPLAY_IND, 0);
}

bk_err_t media_app_dump_decoder_frame(void)
{
	return media_send_msg_sync(EVENT_LCD_DUMP_DECODER_IND, 0);
}

bk_err_t media_app_dump_jpeg_frame(void)
{
	return media_send_msg_sync(EVENT_LCD_DUMP_JPEG_IND, 0);
}

bk_err_t media_app_lcd_step_mode(bool enable)
{
	return media_send_msg_sync(EVENT_LCD_STEP_MODE_IND, enable);
}

bk_err_t media_app_lcd_step_trigger(void)
{
	return media_send_msg_sync(EVENT_LCD_STEP_TRIGGER_IND, 0);
}

#if CONFIG_VIDEO_AVI
bk_err_t media_app_avi_open(void)
{
	return media_send_msg_sync(EVENT_AVI_OPEN_IND, 1);
}

bk_err_t media_app_avi_close(void)
{
	return media_send_msg_sync(EVENT_AVI_CLOSE_IND, 0);
}
#endif

bk_err_t media_app_lvgl_open(void *lcd_open)
{
	int ret = BK_OK;
	lcd_open_t *ptr = NULL;

	ptr = (lcd_open_t *)os_malloc(sizeof(lcd_open_t));
	if (ptr == NULL) {
		LOGE("malloc lcd_open_t failed\r\n");
		return BK_ERR_NO_MEM;
	}
	os_memcpy(ptr, (lcd_open_t *)lcd_open, sizeof(lcd_open_t));

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_LVGL, PM_POWER_MODULE_STATE_ON);

	ret = media_send_msg_sync(EVENT_LVGL_OPEN_IND, (uint32_t)ptr);

	if (ptr) {
		os_free(ptr);
		ptr = NULL;
	}

	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}

bk_err_t media_app_lvgl_close(void)
{
	int ret = BK_OK;

	LOGI("%s\n", __func__);

	ret = media_send_msg_sync(EVENT_LVGL_CLOSE_IND, 0);

	bk_pm_module_vote_boot_cp1_ctrl(PM_BOOT_CP1_MODULE_NAME_LVGL, PM_POWER_MODULE_STATE_OFF);

	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}

bk_err_t media_app_lvcam_lvgl_open(void *lcd_open)
{
    bk_err_t ret = 0;
    lcd_open_t *ptr = NULL;

    ptr = (lcd_open_t *)os_malloc(sizeof(lcd_open_t));
    if (ptr == NULL) {
        LOGE("malloc lcd_open_t failed\r\n");
        return BK_ERR_NO_MEM;
    }
    os_memcpy(ptr, (lcd_open_t *)lcd_open, sizeof(lcd_open_t));

    ret =  media_send_msg_sync(EVENT_LVCAM_LVGL_OPEN_IND, (uint32_t)ptr);

    if (ptr) {
        os_free(ptr);
        ptr = NULL;
    }

    LOGI("%s complete\n", __func__);

    return ret;
}

bk_err_t media_app_lvcam_lvgl_close(void)
{
    bk_err_t ret = 0;

    ret =  media_send_msg_sync(EVENT_LVCAM_LVGL_CLOSE_IND, 0);

    LOGI("%s complete\n", __func__);

    return ret;
}

bk_err_t media_app_pipeline_dump(void)
{
	int ret = BK_OK;

	ret = media_send_msg_sync(EVENT_PIPELINE_DUMP_IND, 0);

	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}

bk_err_t media_app_frame_buffer_init(fb_type_t type)
{
	int ret = BK_FAIL;

	if (CAMERA_STATE_DISABLED == media_modules_state->cam_state)
	{
		LOGI("%s camera not opened\n", __func__);
		return ret;
	}

	ret = media_send_msg_sync(EVENT_FRAME_BUFFER_INIT_IND, (uint32_t)type);

	if (ret != BK_OK)
	{
		LOGE("%s, malloc fail\r\n", __func__);
	}

	return ret;
}

frame_buffer_t *media_app_frame_buffer_jpeg_malloc(void)
{
	int ret = BK_FAIL;
	frame_buffer_t *frame = NULL;

	if (CAMERA_STATE_DISABLED == media_modules_state->cam_state)
	{
		LOGI("%s camera not opened!\n", __func__);
		return frame;
	}

	ret = media_send_msg_sync(EVENT_FRAME_BUFFER_JPEG_MALLOC_IND, (uint32_t)&frame);

	if (ret != BK_OK)
	{
		LOGE("%s, malloc fail\r\n", __func__);
	}

	LOGD("%s, %p\r\n", __func__, frame);

	if (frame)
		frame->fmt = PIXEL_FMT_JPEG;

	return frame;
}

frame_buffer_t *media_app_frame_buffer_h264_malloc(void)
{
	int ret = BK_FAIL;
	frame_buffer_t *frame = NULL;

	if (CAMERA_STATE_DISABLED == media_modules_state->cam_state)
	{
		LOGI("%s camera not opened!\n", __func__);
		return frame;
	}

	ret = media_send_msg_sync(EVENT_FRAME_BUFFER_H264_MALLOC_IND, (uint32_t)&frame);

	if (ret != BK_OK)
	{
		LOGE("%s, malloc fail\r\n", __func__);
	}

	if (frame)
		frame->fmt = PIXEL_FMT_H264;

	return frame;
}

bk_err_t media_app_frame_buffer_push(frame_buffer_t *frame)
{
	int ret = BK_FAIL;

	if (CAMERA_STATE_DISABLED == media_modules_state->cam_state)
	{
		LOGI("%s camera not opened!\n", __func__);
		return ret;
	}

	ret = media_send_msg_sync(EVENT_FRAME_BUFFER_PUSH_IND, (uint32_t)frame);

	return ret;
}

bk_err_t media_app_frame_buffer_clear(frame_buffer_t *frame)
{
	int ret = BK_FAIL;

	if (CAMERA_STATE_DISABLED == media_modules_state->cam_state)
	{
		LOGI("%s camera not opened!\n", __func__);
		return ret;
	}

	ret = media_send_msg_sync(EVENT_FRAME_BUFFER_FREE_IND, (uint32_t)frame);

	return ret;
}



#if CONFIG_MEDIA_UNIT_TEST
bk_err_t media_app_pipeline_mem_show(void)
{
	int ret = BK_OK;

	ret = media_send_msg_sync(EVENT_PIPELINE_MEM_SHOW_IND, 0);

	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}

bk_err_t media_app_pipeline_mem_leak(void)
{
	int ret = BK_OK;

	ret = media_send_msg_sync(EVENT_PIPELINE_MEM_LEAK_IND, 0);

	LOGI("%s complete %x\n", __func__, ret);

	return ret;
}
#endif

bk_err_t media_app_send_msg(media_msg_t *msg)
{
	bk_err_t ret;

	if (media_app_msg_queue)
	{
		ret = rtos_push_to_queue(&media_app_msg_queue, msg, BEKEN_NO_WAIT);

		if (kNoErr != ret)
		{
			LOGE("%s failed\n", __func__);
			return kOverrunErr;
		}

		return ret;
	}
	return kNoResourcesErr;
}

static void media_app_message_handle(void)
{
	bk_err_t ret = BK_OK;
	media_msg_t msg;

	while (1)
	{
		ret = rtos_pop_from_queue(&media_app_msg_queue, &msg, BEKEN_WAIT_FOREVER);

		if (BK_OK == ret)
		{
			switch (msg.event)
			{
				case EVENT_UVC_DEVICE_INFO_NOTIFY:
					if (uvc_device_info_cb)
					{
						if (msg.param != 0)
							uvc_device_info_cb((bk_uvc_device_brief_info_t *)msg.param, UVC_CONNECTED);
						else
							uvc_device_info_cb((bk_uvc_device_brief_info_t *)msg.param, UVC_DISCONNECT_ABNORMAL);
					}
					break;

				case EVENT_MEDIA_APP_EXIT_IND:
					goto exit;
					break;

				default:
					break;
			}
		}
	}

exit:

	/* delate msg queue */
	ret = rtos_deinit_queue(&media_app_msg_queue);

	if (ret != BK_OK)
	{
		LOGE("delate message queue fail\n");
	}

	media_app_msg_queue = NULL;

	LOGE("delate message queue complete\n");

	/* delate task */
	media_app_th_hd = NULL;
	rtos_delete_thread(NULL);

}

bk_err_t media_app_init(void)
{
	bk_err_t ret = BK_OK;

	if (media_app_msg_queue != NULL)
	{
		LOGE("%s, media_app_msg_queue already init, exit!\n", __func__);
		goto error;
	}

	if (media_app_th_hd != NULL)
	{
		LOGE("%s, media_app_th_hd already init, exit!\n", __func__);
		goto error;
	}

	if (media_modules_state == NULL)
	{
		media_modules_state = (media_modules_state_t *)os_malloc(sizeof(media_modules_state_t));
		if (media_modules_state == NULL)
		{
			LOGE("%s, media_modules_state malloc failed!\n", __func__);
			return BK_ERR_NO_MEM;
		}
	}

	media_modules_state->aud_state = AUDIO_STATE_DISABLED;
	media_modules_state->cam_state = CAMERA_STATE_DISABLED;
	media_modules_state->lcd_state = LCD_STATE_DISABLED;
	media_modules_state->stor_state = STORAGE_STATE_DISABLED;
	media_modules_state->trs_state = TRS_STATE_DISABLED;

	ret = rtos_init_queue(&media_app_msg_queue,
	                      "media_app_msg_queue",
	                      sizeof(media_msg_t),
	                      20);

	if (ret != kNoErr)
	{
		LOGE("%s, create media minor message queue failed\n", __func__);
		goto error;
	}

	ret = rtos_create_thread(&media_app_th_hd,
	                         BEKEN_DEFAULT_WORKER_PRIORITY,
	                         "media_app_thread",
	                         (beken_thread_function_t)media_app_message_handle,
	                         2048,
	                         NULL);

	if (ret != kNoErr)
	{
		LOGE("create media app thread fail\n");
		goto error;
	}

	LOGI("media app thread startup complete\n");

	return ret;

error:

	if (media_app_msg_queue)
	{
		rtos_deinit_queue(&media_app_msg_queue);
		media_app_msg_queue = NULL;
	}

	return ret;

}