基于LVGL的视频播放器

### 创建基于LVGL框架的视频播放器

#### 使用LVGL集成FFmpeg库解码视频流

为了实现在嵌入式设备上使用LVGL显示视频，通常需要借助外部库来处理视频解码工作。一种常见做法是利用FFmpeg作为底层支持工具来进行音视频编解码操作[^1]。

// 初始化 FFmpeg 库
av_register_all();

#### 构建图形界面并加载视频帧到图像对象中

通过定义一个定时回调函数周期性地从解码后的数据源获取最新一帧画面，并将其转换成适合于LCD屏幕渲染的颜色格式（如RGB565）。之后调用`lv_img_set_src()`方法更新控件上的视觉内容[^2]。

static void periodic_update(lv_task_t * task)
{
    // 获取下一帧图片...
    
    lv_img_set_src(img, &next_frame);
}

#### 实现基本控制功能如暂停/恢复播放进度条拖动等交互逻辑

除了核心部分外还需要考虑用户体验方面的需求，在界面上添加必要的按钮用于管理媒体文件的状态变化；同时提供滑竿让用户能够方便快捷地定位至任意时间点观看指定片段[^3]。

lv_obj_t * btn_play_pause;
btn_play_pause = lv_btn_create(scr, NULL);

lv_obj_t * slider_time;
slider_time = lv_slider_create(scr, NULL);

相关问题

lvgl音乐播放器进度条

### 创建音乐播放器进度条

在LVGL框架中创建音乐播放器进度条可以通过使用`lv_bar`组件来实现。下面是一个详细的教程，介绍如何构建一个简单的音乐播放器进度条。

#### 初始化LVGL环境
为了确保可以正常显示进度条，首先需要完成LVGL库的初始化工作[^3]：

#include "lvgl/lvgl.h"

int main(void) {
    lv_init();
    
    // 假设已经完成了显示器和输入设备驱动程序的注册
    
    lv_obj_t * screen = lv_disp_get_scr_act(NULL);
}

#### 创建进度条对象
接下来定义并创建进度条对象，将其放置于当前激活屏幕上:

// 定义全局变量用于存储进度条指针以及最大时间长度(单位:s)
static lv_obj_t * progress_bar;
#define MUSIC_DURATION 180     // 歌曲总时长为三分钟

void create_music_player_progressbar(lv_obj_t* parent){
    progress_bar = lv_bar_create(parent, NULL);  
    lv_obj_set_size(progress_bar, LV_PCT(90), 20);       // 设置大小比例宽度占父容器90%
    lv_obj_align(progress_bar,LV_ALIGN_CENTER,0,-50);      // 居中对齐偏移量(-y方向上移动50像素)

    lv_bar_set_range(progress_bar, 0, MUSIC_DURATION);   // 设定范围从0到歌曲结束秒数
    lv_bar_set_value(progress_bar, 0, LV_ANIM_ON);        // 初始状态设置为第零秒位置，并开启动画效果过渡
}

#### 更新进度条数值
为了让进度条能够动态反映音乐播放的位置变化，还需要编写定时更新逻辑。这里假设有一个外部函数可以获得当前已播放的时间（以秒为单位），通过该值调整进度条显示:

extern int get_current_play_time();                       // 获取当前播放时刻接口声明

void update_progress(){
    static uint32_t last_update_tick=0;                   // 上次刷新滴答计数器
    if((lv_tick_elaps(last_update_tick)>100)){            // 如果距离上次超过100ms则继续往下执行
        last_update_tick=lv_tick_get();

        int current_pos=get_current_play_time();          // 调用获取当前位置的方法
        lv_bar_set_value(progress_bar,current_pos,LV_ANIM_OFF); // 更改进度条刻度至新位置关闭动画
        
        char buf[16];
        snprintf(buf,sizeof(buf),"%.2fs/%ds",current_pos,MUSIC_DURATION); // 构造字符串描述格式化输出
        lv_label_set_text_fmt(label,buf);                 // 将构造好的文本赋给标签控件显示出来
    }
}

while (true) {                                            // 主循环体内部不断调用事件处理器保持图形界面响应
    lv_task_handler();
    usleep(5 * 1000);                                    // 防止CPU占用过高适当休眠一段时间
}

上述代码片段展示了如何利用LVGL中的`lv_bar`组件创建一个可交互式的音乐播放器进度条，并实现了基本的功能需求。需要注意的是实际项目里可能涉及到更多细节处理比如样式定制、触摸反馈等特性扩展。

写一个基于LVGL的游戏

好的，我可以给你一个简单的基于LVGL的游戏示例。这个游戏是一个简单的打砖块游戏，玩家需要控制一条板子来反弹球，消灭所有的砖块。

首先，我们需要引入LVGL库并初始化它：

#include "lvgl/lvgl.h"

void lvgl_init(void) {
    lv_init();

    lv_disp_drv_t disp_drv;
    lv_disp_drv_init(&disp_drv);
    disp_drv.disp_flush = lvgl_disp_flush;
    lv_disp_drv_register(&disp_drv);

    lv_indev_drv_t indev_drv;
    lv_indev_drv_init(&indev_drv);
    indev_drv.type = LV_INDEV_TYPE_POINTER;
    indev_drv.read_cb = lvgl_input_read;
    lv_indev_drv_register(&indev_drv);
}

接下来，我们需要定义一些常量和结构体来表示游戏中的元素，如球、板子、砖块等：

#define BALL_RADIUS 5
#define BRICK_WIDTH 40
#define BRICK_HEIGHT 20
#define BOARD_WIDTH 80
#define BOARD_HEIGHT 10

typedef struct {
    int x;
    int y;
    int vx;
    int vy;
    int radius;
    lv_obj_t* obj;
} ball_t;

typedef struct {
    int x;
    int y;
    int width;
    int height;
    lv_obj_t* obj;
} brick_t;

typedef struct {
    int x;
    int y;
    int width;
    int height;
    lv_obj_t* obj;
} board_t;

然后，我们需要定义一些全局变量来表示游戏状态，如分数、生命值、当前球的位置和速度等：

#define MAX_BRICKS 20

static int score = 0;
static int lives = 3;
static ball_t ball;
static board_t board;
static brick_t bricks[MAX_BRICKS];
static int num_bricks = 0;

接下来，我们需要实现一些函数来初始化游戏元素，如球、板子和砖块等：

static void init_ball(void) {
    ball.x = LV_HOR_RES / 2;
    ball.y = LV_VER_RES / 2;
    ball.vx = 3;
    ball.vy = 3;
    ball.radius = BALL_RADIUS;
    ball.obj = lv_obj_create(lv_scr_act(), NULL);
    lv_obj_set_size(ball.obj, ball.radius * 2, ball.radius * 2);
    lv_obj_set_pos(ball.obj, ball.x - ball.radius, ball.y - ball.radius);
    lv_obj_set_style(ball.obj, &lv_style_plain);
}

static void init_board(void) {
    board.x = LV_HOR_RES / 2 - BOARD_WIDTH / 2;
    board.y = LV_VER_RES - BOARD_HEIGHT - 10;
    board.width = BOARD_WIDTH;
    board.height = BOARD_HEIGHT;
    board.obj = lv_obj_create(lv_scr_act(), NULL);
    lv_obj_set_size(board.obj, board.width, board.height);
    lv_obj_set_pos(board.obj, board.x, board.y);
    lv_obj_set_style(board.obj, &lv_style_plain);
}

static void init_bricks(void) {
    int x = 10;
    int y = 10;
    int i;

    for (i = 0; i < MAX_BRICKS; i++) {
        bricks[i].x = x;
        bricks[i].y = y;
        bricks[i].width = BRICK_WIDTH;
        bricks[i].height = BRICK_HEIGHT;
        bricks[i].obj = lv_obj_create(lv_scr_act(), NULL);
        lv_obj_set_size(bricks[i].obj, bricks[i].width, bricks[i].height);
        lv_obj_set_pos(bricks[i].obj, bricks[i].x, bricks[i].y);
        lv_obj_set_style(bricks[i].obj, &lv_style_plain);
        num_bricks++;
        x += BRICK_WIDTH + 10;
        if (x + BRICK_WIDTH > LV_HOR_RES) {
            x = 10;
            y += BRICK_HEIGHT + 10;
        }
    }
}

接下来，我们需要实现一个函数来检测球是否与边界或砖块碰撞，并更新球的位置和速度：

static void update_ball(void) {
    ball.x += ball.vx;
    ball.y += ball.vy;
    if (ball.x - ball.radius < 0 || ball.x + ball.radius > LV_HOR_RES) {
        ball.vx = -ball.vx;
    }
    if (ball.y - ball.radius < 0) {
        ball.vy = -ball.vy;
    }
    if (ball.y + ball.radius > LV_VER_RES) {
        lives--;
        lv_label_set_text_fmt(lives_label, "Lives: %d", lives);
        if (lives == 0) {
            game_over();
            return;
        }
        ball.x = LV_HOR_RES / 2;
        ball.y = LV_VER_RES / 2;
        ball.vx = 3;
        ball.vy = 3;
    }
    int i;
    for (i = 0; i < num_bricks; i++) {
        if (bricks[i].obj && ball.x > bricks[i].x && ball.x < bricks[i].x + bricks[i].width &&
            ball.y > bricks[i].y && ball.y < bricks[i].y + bricks[i].height) {
            ball.vy = -ball.vy;
            lv_obj_del(bricks[i].obj);
            bricks[i].obj = NULL;
            num_bricks--;
            score++;
            lv_label_set_text_fmt(score_label, "Score: %d", score);
            if (num_bricks == 0) {
                game_over();
                return;
            }
        }
    }
    if (ball.y + ball.radius > board.y && ball.x > board.x && ball.x < board.x + board.width) {
        ball.vy = -ball.vy;
    }
    lv_obj_set_pos(ball.obj, ball.x - ball.radius, ball.y - ball.radius);
}

最后，我们需要实现一个主循环来更新游戏状态，并处理玩家输入：

static void game_loop(void) {
    while (1) {
        update_ball();
        lv_task_handler();
        lv_tick_inc(10);
        if (lvgl_input_read(NULL, NULL, NULL)) {
            lv_indev_finish_drag(lv_indev_get_act());
        }
        lvgl_disp_flush(NULL, NULL, NULL);
    }
}

完整代码如下：

#include "lvgl/lvgl.h"

#define BALL_RADIUS 5
#define BRICK_WIDTH 40
#define BRICK_HEIGHT 20
#define BOARD_WIDTH 80
#define BOARD_HEIGHT 10
#define MAX_BRICKS 20

typedef struct {
    int x;
    int y;
    int vx;
    int vy;
    int radius;
    lv_obj_t* obj;
} ball_t;

typedef struct {
    int x;
    int y;
    int width;
    int height;
    lv_obj_t* obj;
} brick_t;

typedef struct {
    int x;
    int y;
    int width;
    int height;
    lv_obj_t* obj;
} board_t;

static int score = 0;
static int lives = 3;
static ball_t ball;
static board_t board;
static brick_t bricks[MAX_BRICKS];
static int num_bricks = 0;
static lv_obj_t* score_label;
static lv_obj_t* lives_label;

static void init_ball(void) {
    ball.x = LV_HOR_RES / 2;
    ball.y = LV_VER_RES / 2;
    ball.vx = 3;
    ball.vy = 3;
    ball.radius = BALL_RADIUS;
    ball.obj = lv_obj_create(lv_scr_act(), NULL);
    lv_obj_set_size(ball.obj, ball.radius * 2, ball.radius * 2);
    lv_obj_set_pos(ball.obj, ball.x - ball.radius, ball.y - ball.radius);
    lv_obj_set_style(ball.obj, &lv_style_plain);
}

static void init_board(void) {
    board.x = LV_HOR_RES / 2 - BOARD_WIDTH / 2;
    board.y = LV_VER_RES - BOARD_HEIGHT - 10;
    board.width = BOARD_WIDTH;
    board.height = BOARD_HEIGHT;
    board.obj = lv_obj_create(lv_scr_act(), NULL);
    lv_obj_set_size(board.obj, board.width, board.height);
    lv_obj_set_pos(board.obj, board.x, board.y);
    lv_obj_set_style(board.obj, &lv_style_plain);
}

static void init_bricks(void) {
    int x = 10;
    int y = 10;
    int i;

    for (i = 0; i < MAX_BRICKS; i++) {
        bricks[i].x = x;
        bricks[i].y = y;
        bricks[i].width = BRICK_WIDTH;
        bricks[i].height = BRICK_HEIGHT;
        bricks[i].obj = lv_obj_create(lv_scr_act(), NULL);
        lv_obj_set_size(bricks[i].obj, bricks[i].width, bricks[i].height);
        lv_obj_set_pos(bricks[i].obj, bricks[i].x, bricks[i].y);
        lv_obj_set_style(bricks[i].obj, &lv_style_plain);
        num_bricks++;
        x += BRICK_WIDTH + 10;
        if (x + BRICK_WIDTH > LV_HOR_RES) {
            x = 10;
            y += BRICK_HEIGHT + 10;
        }
    }
}

static void update_ball(void) {
    ball.x += ball.vx;
    ball.y += ball.vy;
    if (ball.x - ball.radius < 0 || ball.x + ball.radius > LV_HOR_RES) {
        ball.vx = -ball.vx;
    }
    if (ball.y - ball.radius < 0) {
        ball.vy = -ball.vy;
    }
    if (ball.y + ball.radius > LV_VER_RES) {
        lives--;
        lv_label_set_text_fmt(lives_label, "Lives: %d", lives);
        if (lives == 0) {
            game_over();
            return;
        }
        ball.x = LV_HOR_RES / 2;
        ball.y = LV_VER_RES / 2;
        ball.vx = 3;
        ball.vy = 3;
    }
    int i;
    for (i = 0; i < num_bricks; i++) {
        if (bricks[i].obj && ball.x > bricks[i].x && ball.x < bricks[i].x + bricks[i].width &&
            ball.y > bricks[i].y && ball.y < bricks[i].y + bricks[i].height) {
            ball.vy = -ball.vy;
            lv_obj_del(bricks[i].obj);
            bricks[i].obj = NULL;
            num_bricks--;
            score++;
            lv_label_set_text_fmt(score_label, "Score: %d", score);
            if (num_bricks == 0) {
                game_over();
                return;
            }
        }
    }
    if (ball.y + ball.radius > board.y && ball.x > board.x && ball.x < board.x + board.width) {
        ball.vy = -ball.vy;
    }
    lv_obj_set_pos(ball.obj, ball.x - ball.radius, ball.y - ball.radius);
}

static void game_over(void) {
    lv_obj_t* label = lv_label_create(lv_scr_act(), NULL);
    lv_label_set_text(label, "Game Over!");
    lv_obj_align(label, NULL, LV_ALIGN_CENTER, 0, 0);
    lv_task_handler();
    while (1) {
        if (lvgl_input_read(NULL, NULL, NULL)) {
            lv_indev_finish_drag(lv_indev_get_act());
            break;
        }
        lv_task_handler();
        lv_tick_inc(10);
    }
    lv_obj_del(label);
    lv_obj_del(ball.obj);
    lv_obj_del(board.obj);
    int i;
    for (i = 0; i < num_bricks; i++) {
        if (bricks[i].obj) {
            lv_obj_del(bricks[i].obj);
        }
    }
    lv_task_handler();
    while (1) {
        if (lvgl_input_read(NULL, NULL, NULL)) {
            lv_indev_finish_drag(lv_indev_get_act());
            break;
        }
        lv_task_handler();
        lv_tick_inc(10);
    }
    lv_scr_load();
}

void lvgl_init(void) {
    lv_init();

    lv_disp_drv_t disp_drv;
    lv_disp_drv_init(&disp_drv);
    disp_drv.disp_flush = lvgl_disp_flush;
    lv_disp_drv_register(&disp_drv);

    lv_indev_drv_t indev_drv;
    lv_indev_drv_init(&indev_drv);
    indev_drv.type = LV_INDEV_TYPE_POINTER;
    indev_drv.read_cb = lvgl_input_read;
    lv_indev_drv_register(&indev_drv);
}

void lv_app_game(void) {
    lvgl_init();

    lv_obj_t* label;

    label = lv_label_create(lv_scr_act(), NULL);
    lv_label_set_text_fmt(label, "Score: %d", score);
    lv_obj_align(label, NULL, LV_ALIGN_IN_TOP_LEFT, 10, 10);
    score_label = label;

    label = lv_label_create(lv_scr_act(), NULL);
    lv_label_set_text_fmt(label, "Lives: %d", lives);
    lv_obj_align(label, NULL, LV_ALIGN_IN_TOP_RIGHT, -10, 10);
    lives_label = label;

    init_ball();
    init_board();
    init_bricks();

    game_loop();
}