zxc/MAG160C
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9db940a615bf5c0f103df76eaa59127942a12aa4
MAG160C/csdk/src/mag160c_render.c
T
ZXCLI 9db940a615 demo3 迁移到 mag160c_render 抽象库（v6）；render 库加手动 FFC/NUC 访问器/钩子 
- mag160c_demo3.c 从内联管线重写为 render API 调用：删除 DDT 加载/NUC/
  LUT/gray/2x/FFC 状态机实现（~700 行），保留 USB 取帧/GDI/探针/附加环节
- 附加环节（0x230 帧差/0x41fe8 隔行平滑/0x30 gray 覆盖）经 render 的
  post_nuc/post_gray 钩子挂接，编译开关与运行时按键 0/8/9 不变
- mag160c_render 新增 mag160c_render_request_ffc / get_nuc 访问器
- 实测无回归：FFC 时序 init@20→FFC(1)@28→漂移触发，与 v5 一致；
  stats 正常，auto BMP 生成正常；全开关版本编译通过
- linux_demo 修帧组装（38400px+28B 尾），快门=31492 sel=2 正常
2026-08-19 15:41:34 +08:00

691 lines
25 KiB
C
Raw Blame History

/* mag160c_render.c - official pipeline, platform-independent.
* Migrated from csdk/tools/mag160c_demo3.c (pixel-verified vs
* CoreSDKLib.dll). Feed it USB frames; get 320x240 RGB24. */
#include "mag160c/mag160c_render.h"
#include "mag160c_official_palette256.h"
#include "mag160c_official_t2e.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define MAG_T2E_OFFSET 0x249f0
#define TEMP_C 5797
#define OFF_N0 4
#define OFF_N1 5
#define OFF_N2 4
struct mag160c_render_t {
uint16_t w, h;
int npix;
/* DDT state */
int ep_count, nsegs, c5c, c60;
int dev24, dev4c_shift, dev48, dev8c, dev47950, dev47948;
int shift;
int ep_temps[64];
int blind_cnt[64];
short *ep_thr[64];
unsigned short *ep_gain[64];
unsigned int *ep_blind[64];
int sel;
short *thr_work;
unsigned short *gain_work;
unsigned int *blind_work;
int blind_count;
/* frame/FFC state */
int ffc_idx, global_frames, shutter, shutter_at_ffc, manual_ffc;
int has_ref, ref_cnt, startup_ffc_done, ref_reset;
unsigned short *ref;
unsigned int *ref_acc;
unsigned short *nuc;
unsigned char *gray160, *gray320;
/* render state */
unsigned int hist1024[1024];
unsigned int cdf[1024];
unsigned char lut[1024];
int win_lo, win_hi;
int stat_min, stat_max, stat_mean, stat_std;
int center_prev, mean_prev;
/* config */
mag160c_render_ffc_cb_t ffc_cb;
void *ffc_user;
mag160c_render_post_nuc_cb_t post_nuc_cb;
void *post_nuc_user;
mag160c_render_post_gray_cb_t post_gray_cb;
void *post_gray_user;
int ffc_period, ffc_drift, warm_frames, cdf_pivot_75, force75;
};
static int counts_to_temp_mc(int counts) {
int64_t x = (int64_t)counts * 3 - TEMP_C;
if (x < 0) x = 0;
int lo = 0, hi = 645;
while (lo < hi) {
int mid = (lo + hi + 1) >> 1;
if (mag160c_official_t2e[mid] <= x) lo = mid;
else hi = mid - 1;
}
int i = lo;
if (i > 644) i = 644;
int64_t diff = x - mag160c_official_t2e[i];
int64_t t2 = mag160c_official_t2e[i + 1] - mag160c_official_t2e[i];
int64_t slope = t2 ? (0x1000000 + t2 / 2) / t2 : 0;
int64_t temp = ((slope * diff) >> 12) + ((int64_t)i << 12) - MAG_T2E_OFFSET;
return (int)temp;
}
/* ---------------- DDT loading (official 0x18000f130 v3) ---------------- */
static int load_ddt(mag160c_render_t *r, const char *path) {
FILE *f = fopen(path, "rb");
if (!f) return 0;
unsigned char hdr[256];
if (fread(hdr, 1, 0x100, f) < 0x98) { fclose(f); return 0; }
unsigned magic = *(unsigned *)(hdr + 0);
unsigned w = *(unsigned *)(hdr + 4), hh = *(unsigned *)(hdr + 8);
if (magic != 0x5aa50003 && magic != 0x5aa50004) { fclose(f); return 0; }
if (w != r->w || hh != r->h) { fclose(f); return 0; }
r->ep_count = *(int *)(hdr + 12);
r->nsegs = *(int *)(hdr + 16);
if (r->ep_count < 2 || r->ep_count > 64 || r->nsegs < 1 || r->nsegs > 8) {
fclose(f); return 0;
}
int v4 = (magic == 0x5aa50004);
r->dev24 = *(int *)(hdr + 20);
r->dev4c_shift = 3;
if (!v4) {
r->c5c = *(int *)(hdr + 28);
r->c60 = *(int *)(hdr + 32);
if (r->c5c > 0x10000) r->c5c = 0;
} else {
r->c5c = *(int *)(hdr + 0x2c + 0x120);
r->c60 = *(int *)(hdr + 0x30 + 0x120);
}
if (r->c5c & 1) r->c5c &= ~1;
int arro = v4 ? 0x120 + 36 : 36;
if (fseek(f, arro, SEEK_SET)) { fclose(f); return 0; }
if (fread(r->ep_temps, 4, r->ep_count, f) != (size_t)r->ep_count) { fclose(f); return 0; }
unsigned tmp[64];
if (fread(tmp, 4, r->ep_count, f) != (size_t)r->ep_count) { fclose(f); return 0; }
if (fread(tmp, 4, r->ep_count, f) != (size_t)r->ep_count) { fclose(f); return 0; }
if (fread(r->blind_cnt, 4, r->ep_count - 1, f) != (size_t)(r->ep_count - 1)) { fclose(f); return 0; }
r->blind_cnt[r->ep_count - 1] = 0;
for (int i = 0; i < r->ep_count; ++i)
if (r->blind_cnt[i] > 4096) r->blind_cnt[i] = 4096;
size_t thr_sz = (size_t)(r->nsegs - 1) * r->npix + r->c5c / 2;
size_t gain_sz = (size_t)r->nsegs * r->npix * 2;
for (int e = 0; e < r->ep_count; ++e) {
r->ep_thr[e] = malloc(thr_sz * 2);
r->ep_gain[e] = malloc(gain_sz * 2);
r->ep_blind[e] = malloc((size_t)r->blind_cnt[e] * 40);
if (!r->ep_thr[e] || !r->ep_gain[e] ||
(r->blind_cnt[e] && !r->ep_blind[e])) { fclose(f); return 0; }
if (fread(r->ep_thr[e], 2, thr_sz, f) != thr_sz) { fclose(f); return 0; }
if (fread(r->ep_gain[e], 2, gain_sz, f) != gain_sz) { fclose(f); return 0; }
}
for (int e = 0; e < r->ep_count - 1; ++e) {
if (r->blind_cnt[e] &&
fread(r->ep_blind[e], 40, r->blind_cnt[e], f) != (size_t)r->blind_cnt[e]) {
fclose(f); return 0;
}
}
fclose(f);
r->shift = 12;
return 1;
}
static int select_endpoint(mag160c_render_t *r, int shutter) {
int sel = 0;
if (r->ep_count != 2) {
while (sel < r->ep_count - 2 && shutter > r->ep_temps[sel + 1]) sel++;
}
return sel;
}
static void interp_i16(const short *a, const short *b, short *dst, int n, int t) {
for (int i = 0; i < n; ++i)
dst[i] = (short)((int)a[i] + (((int)b[i] - (int)a[i]) * t >> 12));
}
static void interp_u16(const unsigned short *a, const unsigned short *b,
unsigned short *dst, int n, int t) {
for (int i = 0; i < n; ++i)
dst[i] = (unsigned short)((int)a[i] + (((int)b[i] - (int)a[i]) * t >> 12));
}
static void rebuild_tables(mag160c_render_t *r, int shutter) {
r->sel = select_endpoint(r, shutter);
int sel = r->sel;
int t = ((shutter - r->ep_temps[sel]) << 12) / (r->ep_temps[sel + 1] - r->ep_temps[sel]);
if (t > 0x3fff) t = 0x3fff;
if (t < -0x3fff) t = -0x3fff;
interp_i16(r->ep_thr[sel], r->ep_thr[sel + 1], r->thr_work,
(r->nsegs - 1) * r->npix + r->c5c / 2, t);
interp_u16(r->ep_gain[sel], r->ep_gain[sel + 1], r->gain_work,
r->nsegs * r->npix * 2, t);
r->blind_work = r->ep_blind[sel];
r->blind_count = r->blind_cnt[sel];
}
/* ---------------- ref smoother (mode = 4-frame mean) ---------------- */
static void ref_push(mag160c_render_t *r, const unsigned short *frame) {
if (r->ref_cnt == 0) {
for (int i = 0; i < r->npix; ++i) r->ref_acc[i] = frame[i];
} else {
for (int i = 0; i < r->npix; ++i) r->ref_acc[i] += frame[i];
}
r->ref_cnt++;
if (r->ref_cnt >= OFF_N0) {
for (int i = 0; i < r->npix; ++i)
r->ref[i] = (unsigned short)(r->ref_acc[i] >> 2);
r->ref_cnt = 0;
r->has_ref = 1;
}
}
/* ---------------- NUC + blind (0x180017200 + 0x180017330) ---------------- */
static void nuc_and_blind(mag160c_render_t *r, const unsigned short *f20,
unsigned short *out) {
const short *thr = r->thr_work;
const unsigned short *gg = r->gain_work;
for (int i = 0; i < r->npix; ++i) {
int d2 = ((int)f20[i] - (int)r->ref[i]) >> 1;
int seg = 0;
if (d2 > thr[i * 2]) {
seg = 1;
if (d2 > thr[i * 2 + 1]) seg = 2;
}
const unsigned short *p = gg + (seg * r->npix + i) * 2;
int v = (int)p[1] + ((int)p[0] * d2 >> 12);
if (v < 0) v = 0;
if (v > 65535) v = 65535;
out[i] = (unsigned short)v;
}
if (r->blind_work && r->blind_count > 0) {
for (int k = 0; k < r->blind_count; ++k) {
const unsigned int *rec = r->blind_work + k * 10;
unsigned target = rec[0], typ = rec[1];
const unsigned int *ng = rec + 2;
if (target >= (unsigned)r->npix || typ < 3 || typ > 8) continue;
long sum = 0;
for (unsigned j = 0; j < typ; ++j) sum += out[ng[j]];
if (typ == 8) out[target] = (unsigned short)(sum >> 3);
else if (typ == 4) out[target] = (unsigned short)(sum >> 2);
else out[target] = (unsigned short)(sum / typ);
}
}
}
/* ---------------- stats + window (0x180010780 + 0x1800109c0) ---------------- */
static void stats_window(mag160c_render_t *r, const unsigned short *nuc) {
unsigned long long ssum = 0, s2sum = 0;
unsigned mn = 0xffff, mx = 0;
for (int i = 0; i < r->npix; ++i) {
unsigned v = nuc[i];
ssum += v;
s2sum += (unsigned long long)v * v;
if (v < mn) mn = v;
if (v > mx) mx = v;
}
r->stat_min = (int)mn;
r->stat_max = (int)mx;
r->stat_mean = (int)(ssum / r->npix);
double dmean = (double)ssum / r->npix;
double var = (double)s2sum / r->npix - dmean * dmean;
r->stat_std = (int)sqrt(var > 0 ? var : 0);
if (mn == mx) {
r->win_lo = r->win_hi = (int)mn;
memset(r->lut, 0x80, sizeof(r->lut));
memset(r->gray160, 0x80, r->npix);
return;
}
int base = (r->dev24 * 1000) >> r->dev4c_shift;
if (base < 0x80) base = 0x80;
int half = base >> 1;
int lo = r->stat_mean - half;
if ((unsigned)lo > (unsigned)r->stat_min) lo = r->stat_min;
if (lo < 0) lo = 0;
int hi = r->stat_mean + half;
if ((unsigned)hi < (unsigned)r->stat_max) hi = r->stat_max;
if (hi > 65535) hi = 65535;
r->win_lo = lo;
r->win_hi = hi;
if (r->win_hi <= r->win_lo) r->win_hi = r->win_lo + 1;
}
/* ---------------- LUT1024 rebuild (0x180011950 + 0x180011ee0) ---------------- */
static void lut_rebuild(mag160c_render_t *r, const unsigned short *nuc) {
int span = r->win_hi - r->win_lo;
unsigned S = 0xFFC00000u / (unsigned)span;
memset(r->hist1024, 0, sizeof(r->hist1024));
for (int i = 0; i < r->npix; ++i) {
unsigned idx = ((unsigned)nuc[i] - (unsigned)r->win_lo) * S >> 0x16;
if (idx < 1024) r->hist1024[idx]++;
}
for (int i = 0; i < 1023; i += 3) {
r->hist1024[i] = (r->hist1024[i + 1] + r->hist1024[i]) >> 1;
r->hist1024[i + 1] = (r->hist1024[i + 2] + r->hist1024[i + 1]) >> 1;
r->hist1024[i + 2] = (r->hist1024[i + 3] + r->hist1024[i + 2]) >> 1;
}
unsigned total = 0;
for (int i = 0; i < 1024; ++i) total += r->hist1024[i];
unsigned u21 = total >> 12;
if (u21 == 0) u21 = 1;
int lres = ((r->stat_mean - r->win_lo) * 0x3ff) / span;
if (lres < 0) lres = 0;
if (lres > 1023) lres = 1023;
if (r->cdf_pivot_75) {
unsigned acc = 0;
int k = 0;
while (k < 1024) {
acc += r->hist1024[k];
if (acc >= (total * 3 >> 2)) break;
k++;
}
if (k < 1024 && k > lres) lres = k;
}
unsigned u11 = 0, u13 = 0;
for (int k = lres; k >= 0; --k) {
u11 += r->hist1024[k];
if (u21 <= u11) { u13 += 0x100; u11 = 0; }
r->cdf[k] = ((0x10000 / u21) * u11 >> 8) + u13;
}
u11 = 0; u13 = 0;
for (int k = lres + 1; k < 1024; ++k) {
u11 += r->hist1024[k];
if (u11 < u21 * 8) {
if (u21 <= u11) { u13 += 0x100; u11 = 0; }
} else {
u13 += 0x200;
u11 = 0;
}
r->cdf[k] = ((0x10000 / u21) * u11 >> 8) + u13;
}
static unsigned curve[1024];
for (int k = 0; k < 1024; ++k) {
unsigned v = (0x300000u + (unsigned)k * 0x800) >> 0xd;
curve[k] = v ? v : 1;
}
int iv6 = (r->dev48 * 0x155) / 200;
int iv7 = iv6 + 0x155;
int iv26 = iv7;
if (iv6 + 0x156 > 0x331) iv26 = 0x330;
int iv10 = 0x332;
int b3 = 1;
unsigned iv22 = 0xFFC00000u / (unsigned)span;
while (iv26 + 1 < iv10) {
iv7 = (iv10 + iv26) / 2;
if (b3) { b3 = 0; iv7 = iv26; }
unsigned u5 = r->cdf[0];
if (u5 != 0) {
unsigned u21v = (unsigned)(iv7 * 0x10 + 0x10);
for (int k = lres; k >= 0; --k) {
unsigned u12 = (unsigned)(iv7 * 0x10 + 0x10) -
(r->cdf[k] * ((iv7 * 0x40000u + 0x40000u) / u5) >> 0xe);
if (curve[k] < u21v - u12) u12 = u21v - curve[k];
r->lut[k] = (unsigned char)(u12 >> 6);
u21v = u12;
}
}
u5 = r->cdf[1023];
if (u5 != 0) {
unsigned u21v = (unsigned)(iv7 * 0x10);
for (int k = lres + 1; k < 1024; ++k) {
unsigned u12 = (r->cdf[k] * ((0xffc0000u - iv7 * 0x40000u) / u5) >> 0xe) +
(unsigned)(iv7 * 0x10);
if (curve[k] < u12 - u21v) u12 = curve[k] + u21v;
r->lut[k] = (unsigned char)(u12 >> 6);
u21v = u12;
}
}
int iv4 = iv7;
unsigned bfmin = ((unsigned)r->stat_min - (unsigned)r->win_lo) * iv22 >> 0x16;
unsigned bfmax = ((unsigned)r->stat_max - (unsigned)r->win_lo) * iv22 >> 0x16;
if (bfmin < 1024 && bfmax < 1024 &&
r->lut[bfmin] == 0 && r->lut[bfmax] != 0xff) {
iv4 = iv10;
iv26 = iv7;
}
iv10 = iv4;
}
int dm = r->stat_mean - r->mean_prev;
if (dm < 0) dm = -dm;
r->mean_prev = r->stat_mean;
int iv18 = iv10 + ((dm & 0xffff) << r->dev4c_shift) * 2 + r->stat_mean;
if (iv18 < 0x9c4) {
if (iv18 < 100) iv18 = 100;
iv7 = (iv18 * iv7 + r->center_prev * 500) / (iv18 + 500);
r->center_prev = iv7;
unsigned u5 = r->cdf[0];
if (u5 != 0) {
unsigned u21v = (unsigned)(iv7 * 0x10 + 0x10);
for (int k = lres; k >= 0; --k) {
unsigned u12 = (unsigned)(iv7 * 0x10 + 0x10) -
(r->cdf[k] * ((iv7 * 0x40000u + 0x40000u) / u5) >> 0xe);
if (curve[k] < u21v - u12) u12 = u21v - curve[k];
r->lut[k] = (unsigned char)(u12 >> 6);
u21v = u12;
}
}
u5 = r->cdf[1023];
if (u5 != 0) {
unsigned u21v = (unsigned)(iv7 * 0x10);
for (int k = lres + 1; k < 1024; ++k) {
unsigned u12 = (r->cdf[k] * ((0xffc0000u - iv7 * 0x40000u) / u5) >> 0xe) +
(unsigned)(iv7 * 0x10);
if (curve[k] < u12 - u21v) u12 = curve[k] + u21v;
r->lut[k] = (unsigned char)(u12 >> 6);
u21v = u12;
}
}
}
}
/* ---------------- gray + 2x upscale (0x180019740) ---------------- */
static void gray_map(mag160c_render_t *r, const unsigned short *nuc) {
unsigned S = 0xFFC00000u / (unsigned)(r->win_hi - r->win_lo);
for (int i = 0; i < r->npix; ++i) {
unsigned v = nuc[i];
unsigned idx;
if (v <= (unsigned)r->win_lo) idx = 0;
else if (v >= (unsigned)r->win_hi) idx = 1023;
else idx = (v - (unsigned)r->win_lo) * S >> 0x16;
if (idx > 1023) idx = 1023;
r->gray160[i] = r->lut[idx];
}
}
static void upscale2x(mag160c_render_t *r) {
const unsigned char *s = r->gray160;
unsigned char *o = r->gray320;
int W = r->w, H = r->h, W2 = W * 2;
for (int y = 0; y < H - 1; ++y) {
const unsigned char *r0 = s + y * W, *r1 = r0 + W;
unsigned char *o0 = o + y * W2 * 2, *o1 = o0 + W2;
int x;
for (x = 0; x < W - 2; x += 2) {
unsigned a0 = r0[x], a1 = r0[x + 1], a2 = r0[x + 2];
unsigned b0 = r1[x], b1 = r1[x + 1], b2 = r1[x + 2];
int c = x * 2;
o0[c] = (unsigned char)a0;
o0[c + 1] = (unsigned char)((a0 + a1) >> 1);
o0[c + 2] = (unsigned char)a1;
o0[c + 3] = (unsigned char)((a2 + a1) >> 1);
o1[c] = (unsigned char)((b0 + a0) >> 1);
o1[c + 1] = (unsigned char)((b0 + b1 + a0 + a1) >> 2);
o1[c + 2] = (unsigned char)((b1 + a1) >> 1);
o1[c + 3] = (unsigned char)((b2 + b1 + a2 + a1) >> 2);
}
unsigned a0 = r0[W - 2], a1 = r0[W - 1];
unsigned b0 = r1[W - 2], b1 = r1[W - 1];
int c = (W - 2) * 2;
o0[c] = (unsigned char)a0;
o0[c + 1] = (unsigned char)((a1 + a0) >> 1);
o1[c] = (unsigned char)((b0 + a0) >> 1);
o1[c + 1] = (unsigned char)((a1 + b1 + b0 + a0) >> 2);
c = (W - 1) * 2;
o0[c] = (unsigned char)a1;
o0[c + 1] = (unsigned char)((3 * a1 >> 2) + (a0 >> 2));
o1[c] = (unsigned char)((b1 + a1) >> 1);
o1[c + 1] = (unsigned char)((3 * (b1 + a1) + b0 + a0) >> 3);
}
{
int y = H - 1;
const unsigned char *r0 = s + y * W, *r1 = r0 - W;
unsigned char *o0 = o + y * W2 * 2, *o1 = o0 + W2;
int x;
for (x = 0; x < W - 2; x += 2) {
unsigned a0 = r0[x], a1 = r0[x + 1], a2 = r0[x + 2];
unsigned u0 = r1[x], u1 = r1[x + 1], u2 = r1[x + 2];
int c = x * 2;
o0[c] = (unsigned char)a0;
o0[c + 1] = (unsigned char)((a0 + a1) >> 1);
o0[c + 2] = (unsigned char)a1;
o0[c + 3] = (unsigned char)((a2 + a1) >> 1);
o1[c] = (unsigned char)((3 * a0 >> 2) + (u0 >> 2));
o1[c + 1] = (unsigned char)((3 * (a0 + a1) + u0 + u1) >> 3);
o1[c + 2] = (unsigned char)((3 * a1 >> 2) + (u1 >> 2));
o1[c + 3] = (unsigned char)((3 * (a2 + a1) + u2 + u1) >> 3);
}
unsigned a0 = r0[W - 2], a1 = r0[W - 1];
unsigned u0 = r1[W - 2], u1 = r1[W - 1];
int c = (W - 2) * 2;
o0[c] = (unsigned char)a0;
o0[c + 1] = (unsigned char)((a1 + a0) >> 1);
o1[c] = (unsigned char)((3 * a0 >> 2) + (u0 >> 2));
o1[c + 1] = (unsigned char)((3 * (a0 + a1) + u0 + u1) >> 3);
c = (W - 1) * 2;
o0[c] = (unsigned char)a1;
o0[c + 1] = (unsigned char)((3 * a1 + a0) >> 2);
o1[c] = (unsigned char)((3 * a1 + u1) >> 2);
o1[c + 1] = (unsigned char)((o0[c + 1] + o1[c] + a1) / 3);
}
}
/* ---------------- FFC state machine (0x180009ee0) ----------------
* Returns: 0 = render this frame
* 1 = hidden frame (startup/rebuild window), freeze display
* 2 = ref collection frame (type-1 window): caller must push
* the decoded pixels through ref_push before freezing. */
static int ffc_step(mag160c_render_t *r, int shutter) {
if (r->ffc_idx < 0) {
if (r->ffc_cb) r->ffc_cb(r->ffc_user, 0);
r->ffc_idx = 0;
r->shutter_at_ffc = shutter;
}
r->ffc_idx++;
int idx = r->ffc_idx;
if (idx <= OFF_N1) {
if (idx == 1) rebuild_tables(r, r->shutter_at_ffc);
return 1;
}
if (idx <= OFF_N0 + OFF_N1) {
if (idx == OFF_N0 + OFF_N1) {
if (r->ffc_cb) r->ffc_cb(r->ffc_user, 1);
}
if (idx == OFF_N1 + 1) {
r->ref_cnt = 0;
r->has_ref = 0;
}
return 2; /* ref collection window */
}
if (idx <= OFF_N0 + OFF_N2 + OFF_N1) return 1;
/* normal frame: FFC condition */
{
int drift = shutter - r->shutter_at_ffc;
if (drift < 0) drift = -drift;
int cool = OFF_N0 + OFF_N2 + OFF_N1;
int do_ffc = 0;
if (r->manual_ffc) {
r->manual_ffc = 0;
do_ffc = 1;
}
if (r->force75 && !r->startup_ffc_done && idx == 75) {
r->startup_ffc_done = 1;
do_ffc = 1;
}
if (idx >= OFF_N0 + r->ffc_period)
do_ffc = 1;
else if (idx >= cool + 30 && drift > r->ffc_drift)
do_ffc = 1;
if (do_ffc) {
if (r->ffc_cb) r->ffc_cb(r->ffc_user, 0);
r->ffc_idx = 0;
r->shutter_at_ffc = shutter;
return 1;
}
}
return 0;
}
/* ---------------- public API ---------------- */
mag160c_error_t mag160c_render_init(mag160c_render_t **out,
const mag160c_render_cfg_t *cfg) {
if (!out || !cfg || !cfg->ddt_path) return MAG160C_ERR_INVALID_ARGUMENT;
mag160c_render_t *r = calloc(1, sizeof(*r));
if (!r) return MAG160C_ERR_NO_MEMORY;
r->w = cfg->width ? cfg->width : 160;
r->h = cfg->height ? cfg->height : 120;
r->npix = r->w * r->h;
r->ffc_cb = cfg->ffc_cb;
r->ffc_user = cfg->ffc_user;
r->post_nuc_cb = cfg->post_nuc_cb;
r->post_nuc_user = cfg->post_nuc_user;
r->post_gray_cb = cfg->post_gray_cb;
r->post_gray_user = cfg->post_gray_user;
r->ffc_period = cfg->ffc_period ? cfg->ffc_period : 1800;
r->ffc_drift = cfg->ffc_drift ? cfg->ffc_drift : 250;
r->warm_frames = cfg->warm_frames ? cfg->warm_frames : 20;
r->cdf_pivot_75 = cfg->cdf_pivot_75;
r->force75 = cfg->startup_force_ffc;
r->dev24 = 5;
r->dev4c_shift = 3;
r->dev48 = 0;
r->dev47950 = 0;
r->dev47948 = -50000;
r->ffc_idx = -1;
r->center_prev = 341;
r->mean_prev = 0;
r->thr_work = malloc((r->npix * 2 + 4096) * sizeof(short));
r->gain_work = malloc((size_t)r->npix * 6 * sizeof(unsigned short));
r->ref = malloc((size_t)r->npix * 2);
r->ref_acc = malloc((size_t)r->npix * 4);
r->nuc = malloc((size_t)r->npix * 2);
r->gray160 = malloc((size_t)r->npix);
r->gray320 = malloc((size_t)r->npix * 4);
if (!r->thr_work || !r->gain_work || !r->ref || !r->ref_acc ||
!r->nuc || !r->gray160 || !r->gray320) {
mag160c_render_destroy(r);
return MAG160C_ERR_NO_MEMORY;
}
if (!load_ddt(r, cfg->ddt_path)) {
mag160c_render_destroy(r);
return MAG160C_ERR_NOT_INITIALIZED;
}
*out = r;
return MAG160C_OK;
}
mag160c_error_t mag160c_render_frame(mag160c_render_t *r, const uint8_t *frame,
int has_hdr, uint8_t *out_rgb) {
if (!r || !frame || !out_rgb) return MAG160C_ERR_INVALID_ARGUMENT;
r->global_frames++;
if (r->global_frames < r->warm_frames) return MAG160C_ERR_NOT_READY;
int shutter = r->shutter;
if (has_hdr) {
unsigned len = (unsigned)frame[8] | ((unsigned)frame[9] << 8) |
((unsigned)frame[10] << 16) | ((unsigned)frame[11] << 24);
if (len == (unsigned)(r->npix * 2)) {
const uint8_t *tail = frame + 0x1c + len;
shutter = (int)((unsigned)tail[8] | ((unsigned)tail[9] << 8) |
((unsigned)tail[10] << 16) | ((unsigned)tail[11] << 24));
}
}
r->shutter = shutter;
int st = ffc_step(r, shutter);
if (st != 0) {
if (st == 2) {
/* ref window: push decoded pixels (type-1 calibration frames) */
const uint8_t *px = has_hdr ? frame + 0x1c : frame;
for (int i = 0; i < r->npix; ++i)
r->nuc[i] = (unsigned short)(px[i * 2] | ((unsigned)px[i * 2 + 1] << 8));
ref_push(r, r->nuc);
}
return MAG160C_ERR_NOT_READY;
}
/* decode pixels (frame + 0x1c when header present) */
const uint8_t *px = has_hdr ? frame + 0x1c : frame;
unsigned short *live = r->nuc;
for (int i = 0; i < r->npix; ++i)
live[i] = (unsigned short)(px[i * 2] | ((unsigned)px[i * 2 + 1] << 8));
if (!r->has_ref) return MAG160C_ERR_NOT_READY;
nuc_and_blind(r, live, r->nuc);
if (r->post_nuc_cb)
r->post_nuc_cb(r->post_nuc_user, r->nuc);
stats_window(r, r->nuc);
lut_rebuild(r, r->nuc);
gray_map(r, r->nuc);
if (r->post_gray_cb)
r->post_gray_cb(r->post_gray_user, r->gray160);
upscale2x(r);
/* palette colorize 320x240 */
for (int i = 0; i < r->npix * 4; ++i) {
unsigned char gv = r->gray320[i];
out_rgb[i * 3 + 0] = mag160c_official_palette256[gv][0];
out_rgb[i * 3 + 1] = mag160c_official_palette256[gv][1];
out_rgb[i * 3 + 2] = mag160c_official_palette256[gv][2];
}
return MAG160C_OK;
}
void mag160c_render_set_shutter(mag160c_render_t *r, int shutter) {
if (r) r->shutter = shutter;
}
void mag160c_render_get_stats(mag160c_render_t *r, int *win_lo, int *win_hi,
int *fmin, int *fmax, int *mean, int *stddev) {
if (!r) return;
if (win_lo) *win_lo = r->win_lo;
if (win_hi) *win_hi = r->win_hi;
if (fmin) *fmin = r->stat_min;
if (fmax) *fmax = r->stat_max;
if (mean) *mean = r->stat_mean;
if (stddev) *stddev = r->stat_std;
}
int mag160c_render_get_shutter(mag160c_render_t *r) { return r ? r->shutter : 0; }
int mag160c_render_get_endpoint(mag160c_render_t *r) { return r ? r->sel : 0; }
int mag160c_render_get_frame_index(mag160c_render_t *r) { return r ? r->ffc_idx : 0; }
int mag160c_render_has_reference(mag160c_render_t *r) { return r ? r->has_ref : 0; }
mag160c_error_t mag160c_render_probe_temp(mag160c_render_t *r, uint32_t x, uint32_t y,
int32_t *out_temp_mc) {
if (!r || !out_temp_mc || x >= r->w || y >= r->h) return MAG160C_ERR_INVALID_ARGUMENT;
*out_temp_mc = counts_to_temp_mc(r->nuc[y * r->w + x]);
return MAG160C_OK;
}
void mag160c_render_destroy(mag160c_render_t *r) {
if (!r) return;
for (int e = 0; e < r->ep_count; ++e) {
free(r->ep_thr[e]);
free(r->ep_gain[e]);
free(r->ep_blind[e]);
}
free(r->thr_work);
free(r->gain_work);
free(r->ref);
free(r->ref_acc);
free(r->nuc);
free(r->gray160);
free(r->gray320);
free(r);
}
void mag160c_render_request_ffc(mag160c_render_t *r) {
if (r) r->manual_ffc = 1;
}
uint32_t mag160c_render_get_nuc(mag160c_render_t *r, uint32_t idx) {
if (!r || !r->has_ref || idx >= (uint32_t)r->npix) return 0;
return r->nuc[idx];
}
Reference in New Issue View Git Blame Copy Permalink