§ Каркас SDL2

Наверное, самой сложной темой тут будет создание каркаса для того, чтобы выводить видеоданные на SDL2, а не сам видеоадаптер и верилятор.
Как обычно, начну с makefile:
all:
	g++ -o tb tb.cc -lSDL2
Мы будем создавать приложение, которое использует возможности SDL2 для отображения информации на дисплее и постепенно это приложение улучшать и дополнять по мере разработки процессора и компьютера.
Надо создать новый файл tb.cc, который и будет testbench для проекта, где и будет все тестироваться. Я не буду поступать по канонам языка C++ и буду делать как получится.
#include <stdlib.h>
#include "app.cc"

int main(int argc, char **argv) {

    App* app = new App();
    while (app->main()) { /* Обработчик */ }
    app->destroy();
    return 0;
}
Это главный файл, в котором подключается библиотеке stdlib на всякий случай, и класс для работы с SDL2, который сейчас будем разрабатывать. Этот класс подключается в коде main, создается объект app. В цикле while обращается к методу main, который будет выдавать 1, если прошло 20 мс с последнего раза, и 0, если была нажата кнопка "закрыть" окно.
При создании объекта App будет создаваться графическое окно SDL2.
Теперь рассмотрим общий план класса App в файле app.cc:
#include <SDL2/SDL.h>

class App {

protected:

    int width, height, frame_length, frame_prev_ticks;

    SDL_Surface*        screen_surface;
    SDL_Window*         sdl_window;
    SDL_Renderer*       sdl_renderer;
    SDL_PixelFormat*    sdl_pixel_format;
    SDL_Texture*        sdl_screen_texture;
    SDL_Event           evt;
    Uint32*             screen_buffer;

public:

    // Реализация методов
};
В области protected я традиционно записываю различные переменные, которые касаются объекта класса.
Краткое пояснение, какие переменные за что отвечают:
  • screen_surface — объект поверхности окна
  • sdl_window — объект самого окна
  • sdl_renderer — с помощью него происходит рендеринг (отображение данных)
  • sdl_pixel_format — задание формата пикселей
  • sdl_screen_texture — текстура, с которой копируется на поверхность окна
  • evt — возникающие события
  • screen_buffer — непосредственно, сами данные, куда будут записываться цвета, для рендера на окне

§ Конструктор класса

Код конструктора класса будет достаточно объемным:
App() {

    width        = 2*640;   // Удвоение пикселей
    height       = 2*400;
    frame_length = 50;      // 20 кадров в секунду
    frame_prev_ticks = 0;

    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO)) {
        exit(1);
    }

    SDL_ClearError();

    screen_buffer       = (Uint32*) malloc(width * height * sizeof(Uint32));
    sdl_window          = SDL_CreateWindow("Verilated VGA Display", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_SHOWN);
    sdl_renderer        = SDL_CreateRenderer(sdl_window, -1, SDL_RENDERER_PRESENTVSYNC);
    sdl_pixel_format    = SDL_AllocFormat(SDL_PIXELFORMAT_BGRA32);
    sdl_screen_texture  = SDL_CreateTexture(sdl_renderer, SDL_PIXELFORMAT_BGRA32, SDL_TEXTUREACCESS_STREAMING, width, height);
    SDL_SetTextureBlendMode(sdl_screen_texture, SDL_BLENDMODE_NONE);
}
Вначале проставляется размер окна. Поскольку я буду нацелен только на 640 x 400, то размер окна будет таким. То есть, не совсем таким, а в 2 раза больше, поэтому 1 пиксель с виртуального экрана будет занимать 2 пикселя на реальном, чтобы изображение было кратно 2.
Теперь, по порядку, что создается и для чего:
  • SDL_ClearError - убирает предыдущие ошибки SDL, если они там были
  • frame_length = 20, это количество миллисекунд между событием, когда возвращается 1 из метода. Это нужно для периодического обновления экрана. То есть, в методе main() будет ожидать 20 мс, прежде чем будет выход из этого метода.
  • SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) — инициализация SDL фреймворка. Если не получилось, то программа будет экстренно завершена.
  • screen_buffer — выделяется область памяти необходимого размера для содержания там данных о фреймбуфере
  • sdl_window — создание окна SDL2 c именем окна "Verilated VGA Display", по центру, размером width x height, окно будет сразу же показано
  • sdl_renderer — создается рендерер, который будет рисовать текстуру на поверхности окна
  • sdl_pixel_format — формат пикселей 32 бита RGBA
  • sdl_screen_texture — собственно, сама текстура, которая создается на основе объекта sdl_renderer, размер текстуры будет совпадать с размером окна (width x height), а также текстура будет находится в быстрой памяти (SDL_TEXTUREACCESS_STREAMING), не загружаясь в видеопамять
  • SDL_SetTextureBlendMode — удаляет всякое смешивание для текстуры, чтобы не просвечивалась прозрачность при наложении
Хорошо бы, после исполнения каждой процедуры, проверять, не вернулся ли там NULL, но тут все на страх и риск сделано, чтобы много не писать кода.

§ Методы обработки

Обработчик использует "вечный цикл" через for(;;), и ожидает поступления различных событий.
int main() {

    for (;;) {

        Uint32 ticks = SDL_GetTicks();

        while (SDL_PollEvent(& evt)) {
            switch (evt.type) {
                case SDL_QUIT:
                    return 0;
            }
        }

        if (ticks - frame_prev_ticks >= frame_length) {
            frame_prev_ticks = ticks;
            update();
            return 1;
        }

        SDL_Delay(1);
    }
}
В переменной ticks находится текущее время в миллисекундах.
Далее, выполняется цикл while (SDL_PollEvent(& evt)), в котором получаются все новые события, которые пришли с последнего обращения. Если же в процессе сканирования событий было получено событие SDL_QUIT, то происходит досрочный выход из main() с кодом 0. В случае, если события были успешно обработаны, то будет проверено, не прошло ли frame_length миллисекунд с последнего замера.
Если прошло, то будет записан новый замер в frame_prev_ticks, вызван метод update(), который обновит окно, перерисовав screen_buffer на поверхность и окна и далее - досрочный выход из main() с кодом 1.
Если же ни одного значимого события не было, то вызывается ожидание 1 мс, чтобы не нагружать процессор и цикл повторяется снова и снова.
void update() {

    SDL_Rect dstRect;

    dstRect.x = 0;
    dstRect.y = 0;
    dstRect.w = width;
    dstRect.h = height;

    SDL_UpdateTexture       (sdl_screen_texture, NULL, screen_buffer, width * sizeof(Uint32));
    SDL_SetRenderDrawColor  (sdl_renderer, 0, 0, 0, 0);
    SDL_RenderClear         (sdl_renderer);
    SDL_RenderCopy          (sdl_renderer, sdl_screen_texture, NULL, &dstRect);
    SDL_RenderPresent       (sdl_renderer);
}
Что здесь выполняется:
  • Создается объект dstRect, в котором указываются координаты, где будет нарисована текстура.
  • SDL_UpdateTexture — из данных screen_buffer переписывается в текстуру, указывается размер строки, равный в байтах width * sizeof(Uint32)
  • SDL_SetRenderDrawColor — установка RGBA цвета рисования для SDL_RenderClear
  • SDL_RenderClear — очистка области
  • SDL_RenderCopy — копирование из текстуры в окно
  • SDL_RenderPresent — показать результат
void destroy() {

    free(screen_buffer);
    SDL_DestroyTexture(sdl_screen_texture);
    SDL_FreeFormat(sdl_pixel_format);
    SDL_DestroyRenderer(sdl_renderer);
    SDL_DestroyWindow(sdl_window);
    SDL_Quit();
}
Этот метод вызывается перед тем, как завершить программу, освобождаются ранее занятые ресурсы, память, закрывается окно и происходит выход из SDL.
И последняя важная вещь, это рисование в видеобуфере:
void pset(int x, int y, Uint32 cl) {

    if (x < 0 || y < 0 || x >= 640 || y >= 400)
        return;

    for (int i = 0; i < 2; i++)
    for (int j = 0; j < 2; j++)
        screen_buffer[width*(2*y+i) + (2*x+j)] = cl;
}
Записывается точка тогда, когда она находится в пределах x=0..639, y=0..399. Код здесь достаточно очевиден, так что особо комментировать тут нечего, разве что только в screen_buffer информация о пикселях предствляет из себя одномерный массив, который рисует слева направо, сверху вниз. Один элемент массива - один пиксель на экране в формате RGBA.
Скачать код шаблона можно здесь.

§ Создание модуля от верилятора

Вот теперь как раз самое главное, надо скомпилировать файл vga.v в код на C++.
Добавим новый код в makefile:
vga:
	verilator -Wall -Wno-unused -Wno-width -Wno-caseincomplete -cc vga.v
	cd obj_dir && make -f Vvga.mk
Опции -Wno-unused -Wno-width -Wno-caseincomplete устанавливают, что компилятор будет выводить предупреждения, если 1) не совпадают битности при сравнении, 2) есть элементы, которые не используются в схеме, 3) в case используются не все варианты.
После компиляции в obj_dir будут находится нужные компоненты для работы.
Полный вид makefile:
VINC=/usr/share/verilator/include

all: vga
	g++ -o tb -I$(VINC) tb.cc $(VINC)/verilated.cpp obj_dir/Vvga__ALL.a -lSDL2
	./tb
vga:
	verilator -Wall -Wno-unused -Wno-width -Wno-caseincomplete -cc vga.v
	cd obj_dir && make -f Vvga.mk
В первой строке задается путь до файлов для заголовков верилятора, это важно. В опциях компилятора устанавливается путь к -I (включениям), а также компилируется файл verilated.cpp, который там находится и прицепляется сгенерированный файл Vvga__ALL.a из obj_dir. Если модулей больше, то необходимо их все прицеплять сюда, в строку компилятора.
Обязательный минимум это -I$(VINC) и $(VINC)/verilated.cpp
#include <stdlib.h>
#include "app.cc"
#include "obj_dir/Vvga.h"

int main(int argc, char **argv) {

    App* app = new App();

    // -------------------------------------
    Verilated::commandArgs(argc, argv);
    Vvga* top = new Vvga;
    // -------------------------------------

    while (app->main()) { if (Verilated::gotFinish()) break; }
    app->destroy();
    return 0;
}
Добавляем новый код в tb.cc:
  • #include "obj_dir/Vvga.h" — включаются заголовки для класса Vvga
  • Verilated::commandArgs(argc, argv); — инициализация модуля Verilated
  • Vvga* top = new Vvga; — создается объект top модуля Vvga
  • if (Verilated::gotFinish()) break; — на случай, если в синтезируемом вериляторе коде есть команда остановки симуляции
В данном коде используется только один модуль. На самом деле можно сделать много модулей, но их необходимо также правильно сцепить между собой.
Чтобы запустить модуль в работу, надо организовать тактовую частоту, а для этого нужно включить в главный цикл код:
for (int i = 0; i < 125000; i++) {

    top->clock = 0; top->eval(); // Низкий сигнал clock
    top->clock = 1; top->eval(); // Позитивный фронт clock
}
В данном примере используется 125k тактов 20 раз в секунду, что равно 2.5 Мгц, или ровно в 10 раз медленнее, чем если бы работало в реальной схеме (там 25 мгц). Можно увеличить скорость, но это создаст большую нагрузку на процессор.
В этом примере выполняется симуляция переброса из clock из 0 в 1 и наоборот.
А теперь одна из важных вещей — это симуляция видеосигнала для 640 x 400 x 70
void vga(int hs, int vs, int color) {

    if (hs) x++;

    // Отслеживание изменений HS/VS
    if (_hs == 0 && hs == 1) { x = 0; y++; }
    if (_vs == 1 && vs == 0) { x = 0; y = 0; }

    // Сохранить предыдущее значение
    _hs = hs; _vs = vs;

    // Вывод на экран
    pset(x-48, y-35, color);
}
Этот метод я добавил в класс App, и его можно вызывать для того, чтобы нарисовать очередную точку в области рисования после каждого такта.
  • hs - это сигнал горизонтальной синхронизации, он на протяжении большей части равен 1, поскольку hsync отрицательной полярности. Когда hs=1, увеличиваем x++
  • При переходе hs от 0 к 1 (начало новой строки), сбрасываем x=0 и увеличивается y++
  • При переходе vs от 1 к 0 (вертикальная развертка), переходим к x=0, y=0
  • Сохраняем _hs, _vs — для того, чтобы отслеживать переход сигнала из одного состояния в другое
  • Рисуется точка. Поскольку область рисования начинается после порожеков, из x вычитается значение заднего порожека 48, а из y вычитается 35.
В связи с тем, что x, y, _hs, _vs должны быть обязательно проинициализированы, в конструктор записывается следующее:
x   = 0;
y   = 0;
_hs = 1; // Важно начать с 1
_vs = 0; // Важно начать с 0
Сигнал _hs крайне важно начать с 1, потому что следующий hs, который придет из видеоадаптера, будет 1. Если _hs будет 0, то на самой же первой линии будет прибавлен y++, что очень нежелательно.
Теперь после каждого такта пиксель-клока необходимо вызывать метод:
app->vga(top->hs, top->vs, top->r*(128*65536) + top->b*(128*256) + top->g*128);
В который передается hs, vs и значение цвета в RGB. Цвет подстроен так же, как он реализован в и "в железе", то есть либо серый, либо черный. Здесь можно использовать любой цвет, но архитектура самого vga-модуля, который я делал ранее, предполагает только такие цвета в данный момент.

§ Блоки памяти

Но, если запустить сейчас этот код, будет показан черный экран и вот почему — нет данных в памяти, там будет на входе data ноль, то есть, выводится ничего не будет. Значит, создаем блок памяти на 4кб и загружаем туда заранее подготовленный файл с данными. Первые 2кб будет заполнены неким "мусором", чтобы было хотя бы что-то для вывода, а вторые 2кб - знакогенератором.
unsigned char memory[4096];

// Чтение 2кб в знакогенератор
FILE* fp = fopen("font.bin", "rb");
fread(memory + 2048, 1, 2048, fp);
fclose(fp);

// Заполнение первичными данными
for (int i = 0; i < 2048; i++)
    memory[i] = i & 255;
И остался самый последний штрих, это чтение данных data из памяти address перед пиксель-клоком:
top->data = memory[ top->address ];
То есть, перед каждым симулятором тактовой частоты, до этого события будет установлено необходимое значение из памяти по адресу address и записано в порт data.

Так выглядит окно SDL, в котором симулируется видеоадаптер. Все в порядке. Так и должно быть.
Код к данному материалу можно скачать тут.

21 апр, 2022
© 2007-2022 Джерри кродеться в парке