amt630h-sdk-beta/amt630h-freertos/lib/vg_driver/vg_driver_wrapper.c

#include <stdarg.h>

#include "FreeRTOS.h"
#include "board.h"
#include "chip.h"

#include "rtos.h"
#include "romfile.h"
#include "vg_driver.h"

#ifndef VG_ONLY
#include "lvgl/lvgl.h"
#endif

#ifdef VG_DRIVER
#include "xm_base.h"

uint32_t FS_FWrite(const void * pData, uint32_t Size, uint32_t N, void * pFile)
{
	return 0;
}

int32_t FS_FTell(void * pFile)
{
	return 0;
}

DWORD XM_GetTickCount (void)
{
	return OS_GetTime();
}

unsigned int xm_vg_get_width (void)
{
	return VG_W;
}

unsigned int xm_vg_get_height (void)
{
	return VG_H;
}

unsigned int xm_vg_get_stride (void)
{
	return VG_OSD_W * VG_BPP / 8;
}

unsigned int xm_vg_get_bpp (void)
{
	return VG_BPP;
}

#if defined(REVERSE_TRACK)
int xm_vg_is_valid_gpu_fb (unsigned int base)
{
	int i;

	for (i = 0; i < VIDEO_DISPLAY_BUF_NUM; i++) {
		unsigned fb_base = ulVideoDisplayGetBufferAddr(i);
		unsigned vg_base = fb_base + VG_Y * VG_OSD_W * VG_BPP / 8 + VG_X *  VG_BPP / 8;

		if (base == vg_base)
			return 1;
	}

	return 0;
}
#else
int xm_vg_is_valid_gpu_fb (unsigned int base)
{
	unsigned fb_base = ark_lcd_get_virt_addr();
	unsigned vg_base = fb_base + VG_Y * VG_OSD_W * VG_BPP / 8 + VG_X *  VG_BPP / 8;

	if (base == vg_base || base == vg_base + xm_vg_get_stride() * VG_OSD_H)
		return 1;

	return 0;
}
#endif

void* XM_RomAddress (const char *src)
{
	if (!src || src[0] == '\0') return NULL;

	void *ptr;
	RomFile *file = RomFileOpen(src);

	if (!file) {
		printf("open romfile %s fail.\n", src);
		return NULL;
	}
	RomFileRead(file, NULL, file->size);
	ptr = file->buf;
#ifndef ROMFILE_USE_SMALL_MEM
	RomFileClose(file);
#endif

	return ptr;
}


#ifdef LVGL_VG_GPU
unsigned int xm_vg_require_gpu_fb (void)
{
    lv_disp_t * disp = lv_disp_get_default();
	unsigned int vg_frame_base = 0;

	if (disp) {
	    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
	    lv_color_t * disp_buf = vdb->buf_act;
		vg_frame_base = (unsigned int)disp_buf;
	} else {
		vg_frame_base = ark_lcd_get_virt_addr();
	}

	vg_frame_base += VG_Y * VG_OSD_W * VG_BPP / 8 + VG_X *  VG_BPP / 8;
	return 	vg_frame_base;
}

#else

#if defined(VG_ONLY)


#ifdef AWTK

#include "fb_queue.h"

static fb_queue_s *curr_fb = NULL;
unsigned int xm_vg_require_gpu_fb (void)
{
	fb_queue_s *fb_unit = NULL;
	while (!fb_unit)
	{
		fb_unit = fb_queue_get_free_unit();
		if(fb_unit)
			break;
		OS_Delay (1);
	}
	curr_fb = fb_unit;
	//XM_lock();
	//printf ("req %x\n", fb_unit->fb_base);
	//XM_unlock();
	return fb_unit->fb_base;
}

void xm_vg_release_gpu_fb (void)
{
	fb_queue_s *fb_unit = curr_fb;
	if(fb_unit)
	{
		curr_fb = NULL;
		fb_queue_set_ready (fb_unit);
		//XM_lock();
		//printf ("rdy %x\n", fb_unit->fb_base);
		//XM_unlock();
	}
}

#else

static int fb_index = 0;
unsigned int xm_vg_require_gpu_fb (void)
{
	unsigned fb_base = ark_lcd_get_virt_addr();
	fb_base += fb_index * VG_OSD_W * VG_OSD_H *  VG_BPP / 8;
	return fb_base;
}

void xm_vg_release_gpu_fb (void)
{
	unsigned fb_base = xm_vg_require_gpu_fb();
	CP15_clean_dcache_for_dma((uint32_t)fb_base, VG_OSD_W * VG_OSD_H *  VG_BPP / 8 + (uint32_t)fb_base);
	ark_lcd_set_osd_yaddr(LCD_UI_LAYER, (unsigned int)fb_base);
	ark_lcd_set_osd_sync(LCD_UI_LAYER);

	ark_lcd_wait_for_vsync();
	fb_index = (fb_index + 1) & 1;
}

// 获取当前正在渲染的OSD framebuffer
//   *no == -1 表示获取当前正在渲染的OSD framebuffer
// 返回值
//		当前正在渲染的OSD framebuffer基址
unsigned int xm_vg_get_osd_fb (int *no)
{
	unsigned fb_base = ark_lcd_get_virt_addr();
	fb_base += fb_index * VG_OSD_W * VG_OSD_H *  VG_BPP / 8;
	if(*no == (-1))
	{
		*no = fb_index;
		return fb_base;
	}
	else
	{
		if(*no >= 2)
			return 0;
		else
			return fb_base;
	}
}

#endif

#elif defined(REVERSE_TRACK)

static unsigned int gpu_fb_addr = 0;

void xm_vg_set_gpu_fb_addr(unsigned int addr)
{
	gpu_fb_addr = addr;
}

unsigned int xm_vg_require_gpu_fb (void)
{
	unsigned int vg_frame_base;

	vg_frame_base = gpu_fb_addr ? gpu_fb_addr : ulVideoDisplayGetBufferAddr(0);

	vg_frame_base += VG_Y * VG_OSD_W * VG_BPP / 8 + VG_X *  VG_BPP / 8;
	return 	vg_frame_base;
}

#else
unsigned int xm_vg_require_gpu_fb (void)
{
    lv_disp_t * disp = lv_disp_get_default();
    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
    lv_color_t * disp_buf = vdb->buf_act;

	unsigned int vg_frame_base = (unsigned int)disp_buf;

	vg_frame_base += VG_Y * VG_OSD_W * VG_BPP / 8 + VG_X *  VG_BPP / 8;
	return 	vg_frame_base;
}
#endif
#endif



int xm_vg_get_offset_x (void)
{
	return VG_X;
}

int xm_vg_get_offset_y (void)
{
	return VG_Y;
}

unsigned int xm_vg_get_osd_stride (void)
{
	return VG_OSD_W * VG_BPP / 8;
}

void xm_vg_get_osd_window (	unsigned int* x,
										unsigned int* y,
										unsigned int* w,
										unsigned int* h,
										unsigned int* stride
									)
{
	*x = VG_X;
	*y = VG_Y;
	*w = VG_W;
	*h = VG_H;
	*stride = xm_vg_get_stride();
}

void* xm_vg_get_gpu_background_image (void)
{
	static RomFile *bgfile = NULL;

	if(!bgfile) {
		bgfile = RomFileOpen("vg_bg.rgb");
		if (!bgfile)
			return NULL;
		RomFileRead(bgfile, NULL, bgfile->size);
	}
	char *bk = (char*)bgfile->buf;
	if(bk)
		bk += (VG_H - 1) * VG_W * VG_BPP / 8;
	return (void *)bk;
}

unsigned int vg_get_framebuffer (void)
{
	return xm_vg_require_gpu_fb();	
}

#define	XM_PRINTF_SIZE		128
void XM_printf (char *fmt, ...)
{
	static char xm_info[XM_PRINTF_SIZE + 4];

	va_list ap;
	xm_info[XM_PRINTF_SIZE] = 0;
	va_start(ap, fmt);
	//vsprintf (xm_info, fmt, ap);
	vsnprintf (xm_info, XM_PRINTF_SIZE, fmt, ap);
	va_end(ap);

	printf ("%s", xm_info);
}

void XM_printf_ (char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	printf(fmt, ap);
	va_end(ap);
}

#include "xm_base.h"
#include "rtc.h"
// 时间设置/读取函数
//		返回1表示系统时间已设置
//		返回0表示系统时间未设置，系统返回缺省定义时间
int	XM_GetLocalTime	(XMSYSTEMTIME* pSystemTime)
{
	SystemTime_t t;
	iGetLocalTime (&t);
	pSystemTime->wDay = t.tm_mday;
	pSystemTime->wDayOfWeek = t.tm_wday;
	pSystemTime->wHour = t.tm_hour;
	pSystemTime->wMilliseconds = 0;
	pSystemTime->wMinute = t.tm_min;
	pSystemTime->wMonth = t.tm_mon;
	pSystemTime->wSecond = t.tm_sec;
	pSystemTime->wYear = t.tm_year;
	return 1;
}
//		返回1设置系统时间成功
//    返回0设置系统时间失败
int	XM_SetLocalTime	(const XMSYSTEMTIME *pSystemTime)
{
	SystemTime_t t;
	t.tm_mday = pSystemTime->wDay;
	t.tm_wday = pSystemTime->wDayOfWeek ;
	t.tm_hour = pSystemTime->wHour;
	t.tm_min = pSystemTime->wMinute;
	t.tm_mon = pSystemTime->wMonth;
	t.tm_sec = pSystemTime->wSecond;
	t.tm_year = pSystemTime->wYear;
	vSetLocalTime (&t);
	return 1;
}

#ifndef LVGL_VG_GPU

#if defined(VG_ONLY)
#if	defined(DOUBLE_POINTER_HALO)
extern int double_pointer_halo_init (int width, int height);
extern int double_pointer_halo_draw (void);
#elif defined(SINGLE_POINTER_HALO)
extern int single_pointer_halo_init (int width, int height);
extern int single_pointer_halo_draw (void);
#elif defined(AWTK)
extern int gui_app_start(int lcd_w, int lcd_h);
#endif
#include <stdlib.h>
int xm_vg_loop (void *context)
{
#ifdef AWTK
	vTaskPrioritySet(NULL,16);
	gui_app_start (xm_vg_get_width(), xm_vg_get_height());
	return 0;
#else
	int frame_count = 0;
	int vg_draw_tickets = 0;	// 累加VG时间
	int vsync_delay_tickets = 0;	// 累加LCD帧同步等待时间

#if	defined(DOUBLE_POINTER_HALO)	
	double_pointer_halo_init(xm_vg_get_width(), xm_vg_get_height());
#elif defined(SINGLE_POINTER_HALO)
	single_pointer_halo_init(xm_vg_get_width(), xm_vg_get_height());
#endif
	unsigned int start_ticket = XM_GetTickCount();

	while(1)
	{
		// 获取当前正在渲染使用的OSD framebuffer基址及序号
		int fb_no = -1;
		unsigned int fb_base = xm_vg_get_osd_fb(&fb_no);
		
		int t1 = get_timer(0);
#if	defined(DOUBLE_POINTER_HALO)		
		double_pointer_halo_draw();
#elif defined(SINGLE_POINTER_HALO)
		single_pointer_halo_draw();
#endif
		int t2 = get_timer(0);
		vg_draw_tickets += abs(t2 - t1);
		
		// 释放当前渲染的GPU帧, 并等待LCD刷新该帧
		xm_vg_release_gpu_fb ();
		int t3 = get_timer(0);
		vsync_delay_tickets += abs(t3 - t2);
		
		frame_count ++;
		
		if(frame_count == 1000)
		{
			unsigned int t = XM_GetTickCount() - start_ticket;
			printf ("fps = %4.1f , vg_ticket = %d us, vsync_delay_ticket = %d us\r\n", 1000.0*1000.0 / t,  vg_draw_tickets / 1000, vsync_delay_tickets / 1000);
			vg_draw_tickets = 0;
			vsync_delay_tickets = 0;
			frame_count = 0;
			start_ticket = XM_GetTickCount();
		}
		
		//OS_Delay(1);

	}

	//double_pointer_halo_exit();
	//vgFinish();

	return 0;
#endif
}
#else
#ifdef REVERSE_TRACK
static int track_index = 0;
#else
static int pointer_halo_speed = 0;
#endif
static TaskHandle_t vg_task = NULL;
QueueHandle_t vg_done;

void xm_vg_draw_prepare(void *para)
{
	if (para == NULL)
		return;

#ifdef REVERSE_TRACK
	track_index = *(int*)para;
#else
	pointer_halo_speed = *(int*)para;
#endif
}

void xm_vg_draw_start(void)
{
	if (vg_done)
		xQueueReset(vg_done);
	
	if (vg_task)
		xTaskNotify(vg_task, 1, eSetValueWithOverwrite);

	if (vg_done)
		xQueueReceive(vg_done, NULL, portMAX_DELAY);
}

#ifdef REVERSE_TRACK
extern int reversing_auxiliary_line_init (int width, int height);
extern int reversing_auxiliary_line_draw (int index);
#else
extern int pointer_halo_init (int width, int height);
extern int pointer_halo_draw (int speed);
#endif

int xm_vg_loop (void *context)
{
	uint32_t ulNotifiedValue;
	//uint32_t stick = xTaskGetTickCount();
	//uint32_t framecount = 0;

	vg_task = xTaskGetCurrentTaskHandle();
	
	vg_done = xQueueCreate(1, 0);
	
#ifdef REVERSE_TRACK
	reversing_auxiliary_line_init(xm_vg_get_width(), xm_vg_get_height());
#else
	pointer_halo_init(xm_vg_get_width(), xm_vg_get_height());
#endif

	while(1)
	{
		xTaskNotifyWait( 0x00, /* Don't clear any notification bits on entry. */
				0xffffffff, /* Reset the notification value to 0 on exit. */
				&ulNotifiedValue, /* Notified value pass out in ulNotifiedValue. */
				portMAX_DELAY);			

#ifdef REVERSE_TRACK
		reversing_auxiliary_line_draw(track_index);
#else
		pointer_halo_draw(pointer_halo_speed);
#endif

		/* if (++framecount == 1000) {
			uint32_t tick = xTaskGetTickCount();
			printf("fps %d.\n", 1000 * 1000 / (tick - stick));
			framecount = 0;
			stick = xTaskGetTickCount();
		} */

		xQueueSend(vg_done, NULL, 0);
	}

#ifdef REVERSE_TRACK
	//reversing_auxiliary_line_exit();
#else
	//pointer_halo_exit();
#endif
	//vgFinish();

	return 0;
}
#endif
#endif

#ifdef LVGL_VG_GPU

extern void lvgl_thread(void *data);

int xm_vg_loop (void *context)
{
	lvgl_thread(NULL);

	return 0;
}

#endif

#endif