NanamiAdmin/Hatsune-Miku-s-Shoshitsu-in-Terminal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add lyricResolve for resole .lrc file

Browse Source 
feat: add backgroundDisplay for play ascii video in terminal
	feat: add musicPlayer for play music in terminal
This commit is contained in:
NanamiAdmin
2026-08-30 11:35:47 +08:00
parent fdfbf5262f
commit 00b7c0b324
16 changed files with 97267 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/backgroundDisplay.cpp
+510
View File
@@ -0,0 +1,510 @@
// backgroundDisplay.cpp
//
// Decodes a video file with FFmpeg and plays it in the terminal as truecolor
// ASCII art. See backgroundDisplay.h for the API and the adjustable/not-
// adjustable terminal sizing logic.
//
// Decoding runs on a background thread; frames are scaled straight to the
// final grid size and pushed into a small bounded queue that always keeps the
// newest frame (dropping old ones), so the producer never blocks. The calling
// thread paces rendering at the video's frame rate.
#include "backgroundDisplay.h"
#include <algorithm>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
#ifdef _WIN32
#include <io.h>
#include <windows.h>
#else
#include <sys/ioctl.h>
#include <unistd.h>
#endif
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/error.h>
#include <libavutil/imgutils.h>
#include <libavutil/log.h>
#include <libavutil/pixfmt.h>
#include <libswscale/swscale.h>
}
namespace bd {
// --- low-level terminal access --------------------------------------------
namespace {
void writeRaw(const std::string& s) {
fwrite(s.data(), 1, s.size(), stdout);
fflush(stdout);
}
std::string ansiCursorTo(int row, int col) {
return "\x1b[" + std::to_string(row) + ";" + std::to_string(col) + "H";
}
std::string ansiResize(int rows, int cols) {
return "\x1b[8;" + std::to_string(rows) + ";" + std::to_string(cols) + "t";
}
} // namespace
bool isTerminal() {
#ifdef _WIN32
return _isatty(_fileno(stdout)) != 0;
#else
return isatty(STDOUT_FILENO) != 0;
#endif
}
TermSize terminalSize() {
TermSize ts;
#ifdef _WIN32
HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO csbi;
if (h != INVALID_HANDLE_VALUE && GetConsoleScreenBufferInfo(h, &csbi)) {
ts.cols = csbi.srWindow.Right - csbi.srWindow.Left + 1;
ts.rows = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
ts.ok = (ts.cols > 0 && ts.rows > 0);
}
#else
struct winsize ws;
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_col > 0 && ws.ws_row > 0) {
ts.cols = static_cast<int>(ws.ws_col);
ts.rows = static_cast<int>(ws.ws_row);
ts.ok = true;
}
#endif
return ts;
}
bool resizeTerminal(int rows, int cols) {
if (!isTerminal()) return false;
const TermSize before = terminalSize();
if (!before.ok) return false;
writeRaw(ansiResize(rows, cols));
// Give the terminal emulator a moment to honour the request.
std::this_thread::sleep_for(std::chrono::milliseconds(150));
const TermSize after = terminalSize();
// Adjustable = the terminal actually changed size in response.
return after.ok && (after.rows != before.rows || after.cols != before.cols);
}
bool isTerminalAdjustable() {
if (!isTerminal()) return false;
const TermSize ts = terminalSize();
if (!ts.ok) return false;
// Probe with a different height than the current one, so any response is
// unambiguous, then restore the original size.
const int probeRows = ts.rows + 1;
writeRaw(ansiResize(probeRows, ts.cols));
std::this_thread::sleep_for(std::chrono::milliseconds(150));
const TermSize after = terminalSize();
const bool adjustable = after.ok && after.rows != ts.rows;
writeRaw(ansiResize(ts.rows, ts.cols));
return adjustable;
}
GridSize fitSizeForAspect(int videoW, int videoH, int maxCols, int maxRows) {
GridSize g;
if (videoW <= 0 || videoH <= 0 || maxCols <= 0 || maxRows <= 0) return g;
// Terminal cells are about twice as tall as they are wide, so a video of
// W x H needs roughly `cols * H / (2 * W)` rows.
int cols = maxCols;
int rows = static_cast<int>(std::lround(cols * static_cast<double>(videoH) /
(2.0 * videoW)));
if (rows > maxRows) {
rows = maxRows;
cols = static_cast<int>(std::floor(rows * 2.0 * videoW / videoH));
rows = std::min(rows, static_cast<int>(std::lround(
cols * static_cast<double>(videoH) / (2.0 * videoW))));
}
g.cols = std::max(1, cols);
g.rows = std::max(1, rows);
return g;
}
// --- decode pipeline -------------------------------------------------------
namespace {
// Luminance ramp, darkest -> brightest. Mirrors the reference asciivision
// project's palette.
const char PALETTE[] = " .'`^\",:;Il!i><~+_-?][}{1)(|\\tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$";
const size_t PALETTE_LEN = sizeof(PALETTE) - 1;
struct RgbFrame {
int width = 0;
int height = 0;
std::vector<uint8_t> rgb; // width * height * 3, tightly packed RGB24
};
// Bounded queue that always keeps the newest frame. pushLatest() never blocks
// (drops the oldest), so the producer can't deadlock against the consumer.
class BoundedQueue {
public:
explicit BoundedQueue(size_t capacity) : capacity_(capacity) {}
void pushLatest(RgbFrame frame) {
std::lock_guard<std::mutex> lock(mutex_);
while (queue_.size() >= capacity_) queue_.pop_front();
queue_.push_back(std::move(frame));
cv_.notify_one();
}
// Wait up to `deadline` for the newest frame. Returns false if none
// arrived by then. Drains older frames (only the newest is kept).
bool popLatestUntil(std::chrono::steady_clock::time_point deadline, RgbFrame& out) {
std::unique_lock<std::mutex> lock(mutex_);
cv_.wait_until(lock, deadline, [this] { return !queue_.empty() || finished_; });
if (queue_.empty()) return false;
out = std::move(queue_.back());
queue_.clear();
return true;
}
bool empty() const {
std::lock_guard<std::mutex> lock(mutex_);
return queue_.empty();
}
void setFinished() {
std::lock_guard<std::mutex> lock(mutex_);
finished_ = true;
cv_.notify_all();
}
private:
mutable std::mutex mutex_;
std::condition_variable cv_;
std::deque<RgbFrame> queue_;
size_t capacity_;
bool finished_ = false;
};
struct DecodeContext {
AVFormatContext* fmt = nullptr;
int videoIndex = -1;
AVCodecContext* codec = nullptr;
int srcW = 0;
int srcH = 0;
AVPixelFormat srcPixFmt = AV_PIX_FMT_NONE;
SwsContext* sws = nullptr;
int dstW = 0;
int dstH = 0;
std::vector<uint8_t> dstBuf;
uint8_t* dstData[4] = {};
int dstLinesize[4] = {};
AVFrame* frame = nullptr;
AVPacket* pkt = nullptr;
bool loop = false;
BoundedQueue* queue = nullptr;
const std::atomic<bool>* stop = nullptr;
std::atomic<bool>* finished = nullptr;
};
void freeDecode(DecodeContext& dc) {
if (dc.pkt) av_packet_free(&dc.pkt);
if (dc.frame) av_frame_free(&dc.frame);
if (dc.codec) avcodec_free_context(&dc.codec);
if (dc.fmt) avformat_close_input(&dc.fmt);
if (dc.sws) sws_freeContext(dc.sws);
dc.pkt = nullptr;
dc.frame = nullptr;
dc.codec = nullptr;
dc.fmt = nullptr;
dc.sws = nullptr;
}
// Open the file, pick the best video stream and open its decoder. Outputs the
// source dimensions and the (approximate) frame rate. Returns 0 on success.
int probeVideo(const std::string& path, DecodeContext& dc, int& outW, int& outH,
double& outFps) {
// FFmpeg logs to stderr by default, which would corrupt the TUI.
av_log_set_level(AV_LOG_QUIET);
if (avformat_open_input(&dc.fmt, path.c_str(), nullptr, nullptr) < 0) return -1;
if (avformat_find_stream_info(dc.fmt, nullptr) < 0) return -1;
const int index = av_find_best_stream(dc.fmt, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
if (index < 0) return -1;
dc.videoIndex = index;
AVStream* stream = dc.fmt->streams[index];
const AVCodec* codec = avcodec_find_decoder(stream->codecpar->codec_id);
if (!codec) return -1;
dc.codec = avcodec_alloc_context3(codec);
if (avcodec_parameters_to_context(dc.codec, stream->codecpar) < 0) return -1;
if (avcodec_open2(dc.codec, codec, nullptr) < 0) return -1;
dc.srcW = dc.codec->width;
dc.srcH = dc.codec->height;
dc.srcPixFmt = dc.codec->pix_fmt;
const AVRational rate = av_guess_frame_rate(dc.fmt, stream, nullptr);
double fps = (rate.num > 0 && rate.den > 0) ? static_cast<double>(rate.num) / rate.den
: 0.0;
if (fps <= 0.0 || fps > 120.0) fps = 24.0;
outW = dc.srcW;
outH = dc.srcH;
outFps = fps;
return 0;
}
int setupScaler(DecodeContext& dc, int dstW, int dstH) {
dc.dstW = dstW;
dc.dstH = dstH;
dc.sws = sws_getCachedContext(nullptr, dc.srcW, dc.srcH, dc.srcPixFmt, dstW, dstH,
AV_PIX_FMT_RGB24, SWS_BILINEAR, nullptr, nullptr,
nullptr);
if (!dc.sws) return -1;
// Tightly packed RGB24 (align = 1), so row y starts at y * width * 3.
dc.dstBuf.resize(static_cast<size_t>(dstW) * dstH * 3);
if (av_image_fill_arrays(dc.dstData, dc.dstLinesize, dc.dstBuf.data(),
AV_PIX_FMT_RGB24, dstW, dstH, 1) < 0) {
return -1;
}
dc.frame = av_frame_alloc();
dc.pkt = av_packet_alloc();
return (dc.frame && dc.pkt) ? 0 : -1;
}
void scaleAndPush(DecodeContext& dc) {
sws_scale(dc.sws, dc.frame->data, dc.frame->linesize, 0, dc.frame->height,
dc.dstData, dc.dstLinesize);
RgbFrame frame;
frame.width = dc.dstW;
frame.height = dc.dstH;
frame.rgb.assign(dc.dstBuf.begin(), dc.dstBuf.end());
dc.queue->pushLatest(std::move(frame));
}
void decoderThreadFn(DecodeContext& dc) {
while (!(dc.stop && dc.stop->load())) {
const int r = av_read_frame(dc.fmt, dc.pkt);
if (r == AVERROR_EOF) {
// Flush whatever is buffered in the decoder.
avcodec_send_packet(dc.codec, nullptr);
while (avcodec_receive_frame(dc.codec, dc.frame) == 0) scaleAndPush(dc);
if (dc.loop && !(dc.stop && dc.stop->load())) {
av_seek_frame(dc.fmt, -1, 0, AVSEEK_FLAG_BACKWARD);
avcodec_flush_buffers(dc.codec);
continue;
}
break;
}
if (r < 0) break; // non-EOF read error
if (dc.pkt->stream_index == dc.videoIndex) {
avcodec_send_packet(dc.codec, dc.pkt);
while (avcodec_receive_frame(dc.codec, dc.frame) == 0) scaleAndPush(dc);
}
av_packet_unref(dc.pkt);
}
if (dc.finished) dc.finished->store(true);
dc.queue->setFinished();
}
void appendColor(std::string& out, bool background, uint8_t r, uint8_t g, uint8_t b) {
char buf[32];
const int n = std::snprintf(buf, sizeof buf, "\x1b[%d;2;%d;%d;%dm",
background ? 48 : 38, r, g, b);
out.append(buf, static_cast<size_t>(n));
}
char asciiFor(uint8_t r, uint8_t g, uint8_t b) {
const double y = 0.299 * r + 0.587 * g + 0.114 * b;
const size_t index = (static_cast<size_t>(y) * (PALETTE_LEN - 1)) / 255;
return PALETTE[index];
}
// Render one RGB frame into `out` as ANSI truecolor cells. The frame is drawn
// at (offsetX, offsetY) (1-based row semantics handled by the caller's cursor
// positioning); when `showLabel` is set the source video size (srcW x srcH)
// is printed on its own line at the top of the terminal first.
void renderRgbFrame(const RgbFrame& frame, float intensity, int offsetX, int offsetY,
bool showLabel, int srcW, int srcH, std::string& out) {
out.clear();
out += ansiCursorTo(1, 1);
if (showLabel) {
out += "\x1b[0m";
out += std::to_string(srcW);
out += 'x';
out += std::to_string(srcH);
out += "\x1b[K"; // erase the rest of the label row
}
out += ansiCursorTo(offsetY + 1, 1);
const uint8_t* base = frame.rgb.data();
const int cols = frame.width;
const int rows = frame.height;
for (int y = 0; y < rows; ++y) {
if (y > 0) out += "\r\n";
if (offsetX > 0) out.append(static_cast<size_t>(offsetX), ' ');
const uint8_t* row = base + static_cast<size_t>(y) * cols * 3;
const float scanline = (y % 2 == 0) ? 0.84f : 1.0f;
const float factor = std::clamp(intensity * scanline, 0.1f, 1.2f);
int lastFg[3] = {-1, -1, -1};
int lastBg[3] = {-1, -1, -1};
for (int x = 0; x < cols; ++x) {
const size_t i = static_cast<size_t>(x) * 3;
const uint8_t r = row[i], g = row[i + 1], b = row[i + 2];
const int fr = static_cast<int>(r * factor);
const int fg = static_cast<int>(g * factor);
const int fb = static_cast<int>(b * factor);
if (fr != lastFg[0] || fg != lastFg[1] || fb != lastFg[2]) {
appendColor(out, false, static_cast<uint8_t>(fr), static_cast<uint8_t>(fg),
static_cast<uint8_t>(fb));
lastFg[0] = fr;
lastFg[1] = fg;
lastFg[2] = fb;
}
const int br = static_cast<int>(r * factor * 0.16f);
const int bg = static_cast<int>(g * factor * 0.16f);
const int bb = static_cast<int>(b * factor * 0.16f);
if (br != lastBg[0] || bg != lastBg[1] || bb != lastBg[2]) {
appendColor(out, true, static_cast<uint8_t>(br), static_cast<uint8_t>(bg),
static_cast<uint8_t>(bb));
lastBg[0] = br;
lastBg[1] = bg;
lastBg[2] = bb;
}
out += asciiFor(r, g, b);
}
}
}
} // namespace
// --- playback --------------------------------------------------------------
int playVideo(const std::string& path, const PlayVideoOptions& opts) {
if (!isTerminal()) return 2;
DecodeContext dc;
int videoW = 0, videoH = 0;
double fps = 24.0;
if (probeVideo(path, dc, videoW, videoH, fps) < 0) {
freeDecode(dc);
return 1;
}
TermSize ts = terminalSize();
if (!ts.ok) {
freeDecode(dc);
return 2;
}
// Decide the ASCII grid size and whether to print the frame-size label.
int gridW = 0, gridH = 0;
int offsetX = 0, offsetY = 0;
bool showLabel = false;
const int bottomRows = opts.bottomRows > 0 ? opts.bottomRows : 0;
bool adjustable = false;
if (opts.tryResize) {
int aspectRows = static_cast<int>(std::lround(
ts.cols * static_cast<double>(videoH) / (2.0 * videoW)));
aspectRows = std::clamp(aspectRows, 2, 200);
adjustable = resizeTerminal(aspectRows + bottomRows, ts.cols);
if (adjustable) {
// The terminal changed; use whatever it actually became.
ts = terminalSize();
}
}
if (adjustable) {
gridW = ts.cols;
gridH = std::max(1, ts.rows - bottomRows);
} else {
// Not adjustable (or resize disabled): fit proportionally into the
// current size. The frame-size label gets its own line at the top, so
// reserve it before fitting; bottom rows are kept free for other
// content (e.g. the lyric line).
const int labelRows = 1;
const int maxRows = std::max(1, ts.rows - bottomRows - labelRows);
GridSize g = fitSizeForAspect(videoW, videoH, ts.cols, maxRows);
gridW = g.cols;
gridH = g.rows;
showLabel = true; // print "WxH" on its own line at the top
offsetX = (ts.cols - gridW) / 2;
offsetY = 1 + (maxRows - gridH) / 2;
}
if (gridW <= 0 || gridH <= 0 || setupScaler(dc, gridW, gridH) < 0) {
freeDecode(dc);
return 1;
}
// Hide the cursor and clear the screen.
writeRaw("\x1b[?25l\x1b[2J\x1b[H");
std::atomic<bool> finished(false);
BoundedQueue queue(4);
dc.queue = &queue;
dc.stop = opts.stop;
dc.finished = &finished;
dc.loop = opts.loop;
std::thread decoder(decoderThreadFn, std::ref(dc));
const auto interval =
std::chrono::microseconds(static_cast<int64_t>(1'000'000.0 / fps));
auto next = std::chrono::steady_clock::now();
std::string out;
out.reserve(static_cast<size_t>(gridW) * gridH * 24);
while (!(opts.stop && opts.stop->load())) {
RgbFrame frame;
if (queue.popLatestUntil(next, frame)) {
renderRgbFrame(frame, opts.intensity, offsetX, offsetY, showLabel, videoW,
videoH, out);
writeRaw(out);
}
if (finished.load() && queue.empty()) break;
next += interval;
const auto now = std::chrono::steady_clock::now();
if (next <= now) next = now + interval; // fell behind: re-anchor
std::this_thread::sleep_until(next);
}
queue.setFinished();
decoder.join();
writeRaw("\x1b[0m\x1b[?25h");
freeDecode(dc);
return 0;
}
} // namespace bd