GK SDK 源码库: XMIPCLinuxV100R005C00SPC030 (kernel/tools/open_source excluded)

sample/tde/Makefile

@@ -0,0 +1,31 @@
+ifeq ($(CFG_XMEDIA_EXPORT_FLAG),)
+        SDK_DIR := $(shell  cd $(CURDIR)/../.. && /bin/pwd)
+endif
+
+include $(SDK_DIR)/build/base.mk
+include $(SAMPLE_DIR)/sample_base.mk
+
+TARGET := sample_tde
+
+LIBS := $(SAMPLE_LIBS) $(SAMPLE_COMMON_LIB)
+
+INCLUDES := $(SAMPLE_INCLUDES)
+INCLUDES += -I$(SDK_DIR)/source/gmp/drv/fb/include
+
+CFLAGS := $(SAMPLE_CFLAGS) $(LIBS) $(INCLUDES)
+
+SRCS := $(wildcard ./*.c)
+
+OBJS := $(patsubst %.c, %.o, $(SRCS))
+
+.PHONY: all clean
+
+all: $(OBJS)
+	$(AT)$(CC) -o $(TARGET) $^ $(CFLAGS)
+
+%.o : %.c
+	$(AT)$(CC) -c -o $@ $< $(CFLAGS)
+
+clean:
+	$(AT)rm -rf $(OBJS) $(TARGET)
+

sample/tde/sample_tde.c

@@ -0,0 +1,470 @@
+/*
+ * Copyright (c) XMEDIA. All rights reserved.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <math.h>
+#include <sys/ioctl.h>
+#include <pthread.h>
+
+#include "sample_comm.h"
+#include "sample_comm_vo.h"
+#include "xmedia_vo.h"
+#include "xmedia_mmz.h"
+#include "xmedia_tde.h"
+#include "gfbg.h"
+
+typedef struct{
+    xmedia_u8 *mmap_vir;
+    xmedia_u32 size;
+}fb_mmap_info;
+
+#define MIN(x,y) ((x) > (y) ? (y) : (x))
+#define MAX(x,y) ((x) > (y) ? (x) : (y))
+
+static const xmedia_char *g_image_names[] =
+{
+    "res/apple.bits",
+    "res/applets.bits",
+    "res/calendar.bits",
+    "res/foot.bits",
+    "res/gmush.bits",
+    "res/gimp.bits",
+    "res/gsame.bits",
+    "res/keys.bits"
+};
+#define BACKGROUND_NAME  "res/background.bits"
+#define N_IMAGES (xmedia_s32)((sizeof (g_image_names) / sizeof (g_image_names[0])))
+#define SCREEN_WIDTH    720
+#define SCREEN_HEIGHT   480
+#define CYCLE_LEN       60
+
+xmedia_s32 g_fb_fd = -1;
+xmedia_s32 g_vo_dev = 0;
+xmedia_s32 g_vo_layer = 0;
+xmedia_s32 g_vo_chn[1] = {0};
+xmedia_s32 g_vo_chn_num = 1;
+xmedia_tde_surface_info *g_fb_background_surface = XMEDIA_NULL;
+xmedia_tde_surface_info *g_fb_images[N_IMAGES] = {0};
+fb_mmap_info g_fb_mmap_info = {0};
+xmedia_bool g_tde_exit = XMEDIA_FALSE;
+
+static xmedia_void *process_keyboard(xmedia_void *arg)
+{
+    xmedia_char ch;
+    xmedia_bool *status = (xmedia_bool *) arg;
+
+    printf("press q to quit\n");
+    printf("press s to suspend and resume\n");
+    while (1) {
+        ch = getchar();
+        if (ch == 's') {
+            system("echo mem > /sys/power/state"); // 进入休眠状态 之后自动唤醒
+        } else if (ch == 'q') {
+            *status = XMEDIA_TRUE;
+            break;
+        } else {
+            printf("press q to quit\n");
+            printf("press s to suspend and resume\n");
+        }
+    }
+
+    return XMEDIA_NULL;
+}
+
+static xmedia_void tde_destroy_surface(xmedia_tde_surface_info *sur_info)
+{
+    if (sur_info->surface.phys_addr[0] == 0) {
+        return;
+    }
+
+    xmedia_mmz_free(sur_info->surface.phys_addr[0]);
+    return;
+}
+
+void sample_tde_handle_sig(xmedia_s32 signo)
+{
+    if (signo == SIGINT || signo == SIGTERM) {
+
+        // 处理资源泄露
+        for (xmedia_s32 i = 0; i < N_IMAGES; i++) {
+            if (g_fb_images[i] != XMEDIA_NULL) {
+                tde_destroy_surface(g_fb_images[i]);
+            }
+        }
+
+        if (g_fb_background_surface != XMEDIA_NULL) {
+            tde_destroy_surface(g_fb_background_surface);
+        }
+
+        if(g_fb_mmap_info.mmap_vir != XMEDIA_NULL){
+            munmap(g_fb_mmap_info.mmap_vir, g_fb_mmap_info.size);
+            g_fb_mmap_info.mmap_vir = XMEDIA_NULL;
+        }
+
+
+        if (g_fb_fd != -1) {
+            close(g_fb_fd);
+        }
+
+        xmedia_tde_exit();
+        sample_comm_vo_stop(g_vo_dev, g_vo_layer, g_vo_chn, g_vo_chn_num);
+        xmedia_vo_exit();
+        printf("\033[0;31mprogram termination abnormally!\033[0;39m\n");
+    }
+    exit(-1);
+}
+
+static xmedia_void circumrotate (xmedia_tde_surface_info *bg, xmedia_tde_surface_info *image,
+    xmedia_tde_surface_info *dst, xmedia_u32 cur_on_show)
+{
+    xmedia_s32 ret;
+    xmedia_s32 handle;
+    xmedia_tde_surface_info *dst_sur_tmp = (cur_on_show == 0) ? dst + 1 : dst;
+    xmedia_tde_surface_info dst_sur = {0};
+    static xmedia_s32 frame_num = 0;
+    xmedia_float f;
+    xmedia_float x_mid, y_mid;
+    xmedia_float radius;
+    xmedia_s32 i;
+    xmedia_tde_operation_attr opt = {0};
+
+    memcpy(&dst_sur, dst_sur_tmp, sizeof(xmedia_tde_surface_info));
+
+    opt.blend_en = XMEDIA_TRUE;
+    opt.blend_attr.pixel_alpha_en = XMEDIA_TRUE;
+    opt.blend_attr.blend_mode = XMEDIA_TDE_BLEND_MODE_SRCOVER;
+
+    ret = xmedia_tde_create_job(&handle);
+    if (ret != XMEDIA_SUCCESS) {
+        SAMPLE_PRT("xmedia_tde_create_job failed !\n");
+        return;
+    }
+
+    bg->rect.x = 0;
+    bg->rect.y = 0;
+    bg->rect.width = SCREEN_WIDTH;
+    bg->rect.height = SCREEN_HEIGHT;
+
+    f = (float) (frame_num % CYCLE_LEN) / CYCLE_LEN;
+    x_mid = bg->rect.width / 2.16f;
+    y_mid = bg->rect.height / 2.304f;
+    radius = MIN (x_mid, y_mid) / 2.0f;
+
+    ret = xmedia_tde_add_task_single_blit(handle, bg, &dst_sur, 0, XMEDIA_NULL);
+    if (ret != XMEDIA_SUCCESS) {
+        SAMPLE_PRT("xmedia_tde_add_task_single_blit failed !\n");
+        xmedia_tde_cancel_job(handle);
+        return;
+    }
+
+    for(i = 0; i < N_IMAGES; i++) {
+        xmedia_float ang;
+        xmedia_float r;
+
+        ang = 2.0f * (xmedia_float) M_PI * (xmedia_float) i / N_IMAGES - f * 2.0f * (xmedia_float) M_PI;
+        r = radius + (radius / 3.0f) * sinf (f * 2.0 * M_PI);
+
+        dst_sur.rect.x = x_mid + r * cosf (ang) - image[i].surface.width / 2.0f;
+        dst_sur.rect.x = x_mid + r * cosf (ang) - image[i].surface.width / 2.0f;;
+        dst_sur.rect.y = y_mid + r * sinf (ang) - image[i].surface.height / 2.0f;
+        dst_sur.rect.width = image[i].surface.width;
+        dst_sur.rect.height = image[i].surface.height;
+
+        /* 4. bitblt image to screen */
+        ret = xmedia_tde_add_task_double_blit(handle, &dst_sur, &image[i], &dst_sur, &opt);
+        if (ret != XMEDIA_SUCCESS) {
+            SAMPLE_PRT("xmedia_tde_add_task_double_blit failed !\n");
+            xmedia_tde_cancel_job(handle);
+            return;
+        }
+
+    }
+
+    ret = xmedia_tde_submit_job(handle);
+    if (ret != XMEDIA_SUCCESS) {
+        SAMPLE_PRT("xmedia_tde_submit_job failed !\n");
+        xmedia_tde_cancel_job(handle);
+        return;
+    }
+
+    frame_num++;
+    return;
+}
+
+static xmedia_s32 tde_create_surface_by_file(const xmedia_char *file_name,
+    xmedia_tde_surface_info *sur_info)
+{
+    FILE *fp;
+    xmedia_u32 buffer_length = 0;
+    xmedia_u8 *vir_addr;
+
+    if (file_name == XMEDIA_NULL || sur_info == XMEDIA_NULL) {
+        SAMPLE_PRT("NULL ptr!\n");
+        return -1;
+    }
+
+    fp = fopen(file_name, "rb");
+    if (fp == XMEDIA_NULL) {
+        SAMPLE_PRT("fopen FILE:%s!\n", file_name);
+        return -1;
+    }
+
+    fread(&sur_info->surface.pixel_format, 1, 4, fp);
+    fread(&sur_info->surface.width, 1, 4, fp);
+    fread(&sur_info->surface.height, 1, 4, fp);
+    fread(&sur_info->surface.stride[0], 1, 4, fp);
+
+    buffer_length = sur_info->surface.stride[0] * sur_info->surface.height;
+    if (buffer_length > 0x7FFFFFFF) {
+        SAMPLE_PRT("fopen FILE:%s!\n", file_name);
+        fclose(fp);
+        return -1;
+    }
+
+    // 分配mmz内存
+    sur_info->surface.phys_addr[0] = xmedia_mmz_alloc(XMEDIA_NULL, XMEDIA_NULL, buffer_length);
+    if (sur_info->surface.phys_addr[0] == 0) {
+        SAMPLE_PRT("xmedia_mmz_alloc failed!\n");
+        fclose(fp);
+        return -1;
+    }
+    vir_addr = xmedia_mmz_map(sur_info->surface.phys_addr[0], buffer_length, XMEDIA_FALSE);
+    if (vir_addr == 0) {
+        SAMPLE_PRT("xmedia_mmz_map failed!\n");
+        xmedia_mmz_free(sur_info->surface.phys_addr[0]);
+        fclose(fp);
+        return -1;
+    }
+
+    fread(vir_addr, 1, buffer_length, fp); // 图片是标准大小，自然对齐
+
+    sur_info->surface.alpha0 = 0x0;
+    sur_info->surface.alpha1 = 0xff;
+    sur_info->surface.is_alpha_ext_1555 = XMEDIA_TRUE;
+
+    sur_info->rect.x = 0;
+    sur_info->rect.y = 0;
+    sur_info->rect.width = sur_info->surface.width;
+    sur_info->rect.height = sur_info->surface.height;
+
+    xmedia_mmz_unmap((void *)vir_addr);
+    fclose(fp);
+    return XMEDIA_SUCCESS;
+}
+
+static xmedia_void tde_get_suface_by_fix_info(struct fb_fix_screeninfo *fix_info,
+    xmedia_tde_surface_info *sur_info, xmedia_u32 index)
+{
+    sur_info->surface.alpha0 = 0x0;
+    sur_info->surface.alpha1 = 0xff;
+    sur_info->surface.clut_phys_addr = 0;
+    sur_info->surface.clut_reload = XMEDIA_FALSE;
+    sur_info->surface.is_alpha_ext_1555 = XMEDIA_TRUE;
+    sur_info->surface.pixel_format = XMEDIA_VIDEO_PIXEL_FMT_ARGB_1555;
+    sur_info->surface.width = SCREEN_WIDTH;
+    sur_info->surface.height = SCREEN_HEIGHT;
+    sur_info->surface.stride[0] = SCREEN_WIDTH * 2;
+    sur_info->surface.phys_addr[0] = (index == 0) ? fix_info->smem_start : fix_info->smem_start + SCREEN_WIDTH * 2 *
+        SCREEN_HEIGHT;
+    sur_info->rect.x = 0;
+    sur_info->rect.y = 0;
+    sur_info->rect.width = sur_info->surface.width;
+    sur_info->rect.height = sur_info->surface.height;
+
+    return;
+}
+
+xmedia_s32 tde_draw_graphic_sample(xmedia_void)
+{
+    xmedia_s32 ret = 0;
+    xmedia_s32 i, j;
+    xmedia_u32 times = 0;
+    xmedia_s32 fb_fd;
+    gfbg_drv_alpha fb_alpha = {0};
+    struct fb_var_screeninfo var_info = {0};
+    struct fb_fix_screeninfo fix_info = {0};
+    struct fb_bitfield red32 = {10, 5, 0};
+    struct fb_bitfield green32 = {5, 5, 0};
+    struct fb_bitfield blue32 = {0, 5, 0};
+    struct fb_bitfield alpha32 = {15, 1, 0};
+    xmedia_u8 *fb_mmap_vir = XMEDIA_NULL;
+    xmedia_bool state = XMEDIA_TRUE;
+
+    xmedia_tde_surface_info bg = {0};
+    xmedia_tde_surface_info image[8] = {0};
+    xmedia_tde_surface_info dst[2] = {0};
+
+    fb_fd = open("/dev/fb0", O_RDWR);
+    if (fb_fd < 0) {
+        SAMPLE_PRT("open fb0 failed !\n");
+        goto GRAPHIC_FAIL0;
+    }
+    g_fb_fd = fb_fd;
+
+    ret = ioctl(fb_fd, GFBG_PUT_ALPHA, &fb_alpha);
+    if (ret < 0) {
+        SAMPLE_PRT("Put alpha info failed !\n");
+        goto GRAPHIC_FAIL1;
+    }
+
+    if (ioctl(fb_fd, FBIOGET_VSCREENINFO, &var_info) < 0) {
+        SAMPLE_PRT("Get variable screen info failed!\n");
+        goto GRAPHIC_FAIL1;
+    }
+
+    var_info.xres_virtual = SCREEN_WIDTH;
+    var_info.yres_virtual = SCREEN_HEIGHT * 2;
+    var_info.xres = SCREEN_WIDTH;
+    var_info.yres = SCREEN_HEIGHT;
+    var_info.activate = FB_ACTIVATE_NOW;
+    var_info.bits_per_pixel	= 16;
+    var_info.xoffset = 0;
+    var_info.yoffset = 0;
+    var_info.red = red32;
+    var_info.green = green32;
+    var_info.blue = blue32;
+    var_info.transp = alpha32;
+
+    if (ioctl(fb_fd, FBIOPUT_VSCREENINFO, &var_info) < 0) {
+        SAMPLE_PRT("FBIOPUT_VSCREENINFO error\n");
+        goto GRAPHIC_FAIL1;
+    }
+
+    if (ioctl(fb_fd, FBIOGET_FSCREENINFO, &fix_info) < 0) {
+        SAMPLE_PRT("FBIOGET_FSCREENINFO error\n");
+        goto GRAPHIC_FAIL1;
+    }
+
+    fb_mmap_vir = mmap(NULL, fix_info.smem_len, PROT_READ|PROT_WRITE, MAP_SHARED, fb_fd, 0);
+    if (fb_mmap_vir == XMEDIA_NULL) {
+        SAMPLE_PRT("mmap fb0 failed!\n");
+        goto GRAPHIC_FAIL1;
+    }
+    memset(fb_mmap_vir, 0x00, fix_info.smem_len);
+    g_fb_mmap_info.mmap_vir = fb_mmap_vir;
+    g_fb_mmap_info.size = fix_info.smem_len;
+
+    ret = tde_create_surface_by_file(BACKGROUND_NAME, &bg);
+    if (ret != XMEDIA_SUCCESS) {
+        SAMPLE_PRT("create bg surface failed!\n");
+        goto GRAPHIC_FAIL2;
+    }
+    g_fb_background_surface = &bg;
+
+    for (i = 0; i < N_IMAGES; i++) {
+        ret = tde_create_surface_by_file(g_image_names[i], &image[i]);
+        if (ret != XMEDIA_SUCCESS) {
+            SAMPLE_PRT("create image[%d] surface failed!\n", i);
+            for (j = i; j > 0; j--) {
+                tde_destroy_surface(&image[j - 1]);
+            }
+            goto GRAPHIC_FAIL3;
+        }
+        g_fb_images[i]= &image[i];
+    }
+
+    tde_get_suface_by_fix_info(&fix_info, &dst[0], 0);
+    tde_get_suface_by_fix_info(&fix_info, &dst[1], 1);
+
+    if (ioctl(fb_fd, GFBG_PUT_SHOW, &state) < 0) {
+        SAMPLE_PRT("FBIOPUT_SHOW failed!\n");
+        goto GRAPHIC_FAIL4;
+    }
+
+    do {
+        circumrotate(&bg, image, dst, times % 2);
+        var_info.yoffset = (times % 2) ? 0 : 480;
+
+        if (ioctl(fb_fd, FBIOPAN_DISPLAY, &var_info) < 0) {
+            SAMPLE_PRT("FBIOPAN_DISPLAY error\n");
+            goto GRAPHIC_FAIL4;
+        }
+
+        times++;
+        sleep(1);
+    } while (g_tde_exit == XMEDIA_FALSE && times < 20);
+
+    SAMPLE_PRT("exit\n");
+    ret = XMEDIA_SUCCESS;
+GRAPHIC_FAIL4:
+    for (j = N_IMAGES; j > 0; j--) {
+        tde_destroy_surface(&image[j - 1]);
+    }
+GRAPHIC_FAIL3:
+    tde_destroy_surface(&bg);
+GRAPHIC_FAIL2:
+    munmap(fb_mmap_vir, fix_info.smem_len);
+    fb_mmap_vir = XMEDIA_NULL;
+GRAPHIC_FAIL1:
+    close(fb_fd);
+    fb_fd = -1;
+GRAPHIC_FAIL0:
+    return ret;
+}
+
+int main()
+{
+    xmedia_s32 ret;
+    sample_vo_config_input vo_input = {0};
+    sample_vo_config vo_config = {0};
+    pthread_t t1;
+
+    signal(SIGINT, sample_tde_handle_sig);
+    signal(SIGTERM, sample_tde_handle_sig);
+
+    ret = xmedia_vo_init();
+    if (ret != XMEDIA_SUCCESS) {
+        SAMPLE_PRT("vo init failed !\n");
+        goto FAIL0;
+    }
+
+    vo_input.intf_sync = XMEDIA_VO_INTF_SYNC_1080P30;
+    vo_input.intf_type = XMEDIA_INTF_TYPE_BT1120;
+    vo_input.square_sort = 1;
+    ret = sample_comm_vo_get_default_config(vo_input, &vo_config);
+    if (ret != XMEDIA_SUCCESS) {
+        SAMPLE_PRT("get vo default config failed !\n");
+        goto FAIL1;
+    }
+
+    ret = sample_comm_vo_start(g_vo_dev, g_vo_layer, g_vo_chn, g_vo_chn_num, XMEDIA_FALSE, &vo_config);
+    if (ret != XMEDIA_SUCCESS) {
+        SAMPLE_PRT("vo start failed !\n");
+        goto FAIL1;
+    }
+
+    ret = xmedia_tde_init();
+    if (ret != XMEDIA_SUCCESS) {
+        SAMPLE_PRT("tde init failed !\n");
+        goto FAIL2;
+    }
+
+    pthread_create(&t1, XMEDIA_NULL, process_keyboard, &g_tde_exit);
+    pthread_detach(t1);
+
+    ret = tde_draw_graphic_sample();
+    if(ret != XMEDIA_SUCCESS) {
+        goto FAIL3;
+    }
+
+    ret = XMEDIA_SUCCESS;
+FAIL3:
+    xmedia_tde_exit();
+FAIL2:
+    sample_comm_vo_stop(g_vo_dev, g_vo_layer, g_vo_chn, g_vo_chn_num);
+FAIL1:
+    xmedia_vo_exit();
+FAIL0:
+    return ret;
+}