Merge pull request #32 from cobaltgit/last-reworks

Pre-release polishing

Author: cobaltgit

quark.nimble

@@ -5,13 +5,20 @@ author         = "cobaltgit"
 description    = "Quark stock mod for TrimUI Smart"
 license        = "GPL-3.0"
 srcDir         = "src"
-bin            = @["fbscreenshot/fbscreenshot", "quark_hotkeyd/quark_hotkeyd", "sysjson_monitor/sysjson_monitor", "mainui_game_picker/mainui_game_picker", "bootlogo/bootlogo", "display/display"]
 
 requires "nim >= 2.0.0"
 requires "nimPNG >= 0.3.1"
 
 const Root = getCurrentDir()
 const BinDir = Root / "dist" / "System" / "bin"
+const Bins = {
+  "fbscreenshot.nim": "fbscreenshot",
+  "quark_hotkeyd/main.nim": "quark_hotkeyd",
+  "sysjson_monitor/main.nim": "sysjson_monitor",
+  "mainui_game_picker.nim": "mainui_game_picker",
+  "bootlogo.nim": "bootlogo",
+  "display.nim": "display",
+}.toTable()
 const Threads = gorge("nproc")
 
 # Import task files
@@ -20,9 +27,8 @@ include "tasks/dist.nims"
 include "tasks/locale.nims"
 
 task buildBins, "Build binaries":
-    for exe in bin:
-        let binName = exe.split("/")[^1]
-        selfExec &"c -o:{BinDir}/{binName} {srcDir}/{exe}.nim"
+    for src, output in Bins:
+        selfExec &"c -o:{BinDir}/{output} {srcDir}/{src}"
 
 task cleanup, "Cleanup all":
   exec "nimble clean"

src/bootlogo/bootlogo.nim src/bootlogo.nimsrc/bootlogo/bootlogo.nim renamed to src/bootlogo.nim

@@ -1,6 +1,6 @@
 import std/[cmdline, os, posix]
-import ../common/[bootlogo, reboot]
-import ../display/display
+import common/[bootlogo, reboot]
+import display
 
 when isMainModule:
   var shouldReboot = false

src/common/fb.nim

@@ -32,16 +32,10 @@ const
       arr[i] = uint8(i shr 2)
     arr
 
-  RowOffsets*: array[FbHeight, int] = block:
-    var arr: array[FbHeight, int]
-    for y in 0..<FbHeight:
-      arr[y] = y * FbWidth
-    arr
-
-  RotationXMap*: array[FbHeight, int] = block:
+  FbXBase*: array[FbHeight, int] = block:
     var arr: array[FbHeight, int]
     for x in 0..<FbHeight:
-      arr[x] = 319 - x
+      arr[x] = (FbHeight - 1 - x) * FbWidth
     arr
 
 {.push optimization:speed, checks:off, warnings:off.}
@@ -74,18 +68,19 @@ proc fbscreenshot*(output: string) =
 
   var rotatedPixels = newSeqUninit[uint8](FbPixels * 4)
 
-  var srcIdx = 0
-  for y in 0..<FbHeight:
-    for x in 0..<FbWidth:
-      let pixel = uint16(fbData[srcIdx]) or (uint16(fbData[srcIdx + 1]) shl 8)
-      srcIdx += 2
+  for x in 0..<FbWidth:
+    let colBase = x * FbHeight
+    var srcBase = x * 2
+
+    for y in 0..<FbHeight:
+      let pixel = uint16(fbData[srcBase]) or (uint16(fbData[srcBase + 1]) shl 8)
+      srcBase += FbWidth * 2
 
       let r = (pixel shr 11) and 0x1F
       let g = (pixel shr 5) and 0x3F
       let b = pixel and 0x1F
 
-      let dstIdx = (x * FbHeight + (FbHeight - 1 - y)) * 4
-
+      let dstIdx = (colBase + FbHeight - 1 - y) * 4
       rotatedPixels[dstIdx] = FiveToEight[r]
       rotatedPixels[dstIdx + 1] = SixToEight[g]
       rotatedPixels[dstIdx + 2] = FiveToEight[b]

src/common/ffi/amixer.nim

@@ -0,0 +1,45 @@
+const libasound = "libasound.so.2"
+
+type
+  SndMixerT*        = pointer
+  SndMixerElemT*    = pointer
+  SndMixerSelemIdT* = pointer
+
+proc snd_mixer_open*(mixer: ptr SndMixerT, mode: cint): cint
+  {.importc, dynlib: libasound.}
+
+proc snd_mixer_close*(mixer: SndMixerT): cint
+  {.importc, dynlib: libasound.}
+
+proc snd_mixer_attach*(mixer: SndMixerT, name: cstring): cint
+  {.importc, dynlib: libasound.}
+
+proc snd_mixer_load*(mixer: SndMixerT): cint
+  {.importc, dynlib: libasound.}
+
+proc snd_mixer_selem_register*(mixer: SndMixerT,
+                                options: pointer,
+                                classp: pointer): cint
+  {.importc, dynlib: libasound.}
+
+proc snd_mixer_selem_id_sizeof*(): csize_t
+  {.importc, dynlib: libasound.}
+
+proc snd_mixer_selem_id_set_name*(obj: SndMixerSelemIdT, val: cstring)
+  {.importc, dynlib: libasound.}
+
+proc snd_mixer_selem_id_set_index*(obj: SndMixerSelemIdT, val: cuint)
+  {.importc, dynlib: libasound.}
+
+proc snd_mixer_find_selem*(mixer: SndMixerT,
+                            id: SndMixerSelemIdT): SndMixerElemT
+  {.importc, dynlib: libasound.}
+
+proc snd_mixer_selem_get_playback_volume_range*(elem: SndMixerElemT,
+                                                 minVal: ptr clong,
+                                                 maxVal: ptr clong): cint
+  {.importc, dynlib: libasound.}
+
+proc snd_mixer_selem_set_playback_volume_all*(elem: SndMixerElemT,
+                                               value: clong): cint
+  {.importc, dynlib: libasound.}

src/display/stb_truetype.c src/common/ffi/stb_truetype.csrc/display/stb_truetype.c renamed to src/common/ffi/stb_truetype.c

@@ -1,63 +1,58 @@
-import std/[os, posix, strformat, strutils, sets]
+import std/[os, posix, strformat, strutils, sets, tables]
 
-proc killall*(processName: string, signal: cint, excludePid: int = -1): bool =
-  var killed = false
-  
+proc getParentPid(pid: int): int =
+  try:
+    let stat = readFile(&"/proc/{pid}/stat")
+    let afterComm = stat.find(')')
+    if afterComm < 0:
+      return -1
+    let fields = stat[afterComm + 2 .. ^1].splitWhitespace()
+    if fields.len >= 2:
+      result = parseInt(fields[1])
+    else:
+      result = -1
+  except CatchableError:
+    result = -1
+
+proc getProcessMap(): Table[string, seq[int]] =
+  result = initTable[string, seq[int]]()
   for kind, path in walkDir("/proc"):
-    if kind == pcDir:
-      let name = path.extractFilename()
-      try:
-        let pid = parseInt(name)
-        if pid == excludePid:
-          continue
-        
-        let commPath = path / "comm"
-        if fileExists(commPath):
-          let comm = readFile(commPath).strip()
-          
-          if comm == processName:
-            if kill(cint(pid), signal) == 0:
-              killed = true
-      except ValueError:
-        continue
-  
-  result = killed
+    if kind != pcDir:
+      continue
+    let name = path.extractFilename()
+    try:
+      let pid = parseInt(name)
+      let commPath = path / "comm"
+      if fileExists(commPath):
+        let comm = readFile(commPath).strip()
+        if comm notin result:
+          result[comm] = @[]
+        result[comm].add(pid)
+    except CatchableError:
+      continue
+
+proc killall*(processName: string, signal: cint, excludePid: int = -1): bool =
+  let processMap = getProcessMap()
+  if processName notin processMap:
+    return false
+
+  for pid in processMap[processName]:
+    if pid == excludePid:
+      continue
+    if kill(cint(pid), signal) == 0:
+      result = true
 
 proc getProcessChildren*(ppid: int, pids: var HashSet[int]) =
   for kind, path in walkDir("/proc"):
-    if kind == pcDir:
-      let name = path.extractFilename()
-      if name.len > 0 and name[0].isDigit:
-        try:
-          let pid = parseInt(name)
-          let statPath = &"/proc/{pid}/stat"
-          if fileExists(statPath):
-            let stat = readFile(statPath)
-            var fields = 0
-            var parentPid = 0
-            var inParen = false
-            var field = ""
-            
-            for c in stat:
-              if c == '(':
-                inParen = true
-              elif c == ')':
-                inParen = false
-              elif c == ' ' and not inParen:
-                inc fields
-                if fields == 4:
-                  try:
-                    parentPid = parseInt(field)
-                  except ValueError:
-                    discard
-                  break
-                field = ""
-              else:
-                if not inParen or fields > 0:
-                  field.add(c)
-            
-            if parentPid == ppid:
-              pids.incl(pid)
-              getProcessChildren(pid, pids)
-        except:
-          discard
+    if kind != pcDir:
+      continue
+    let name = path.extractFilename()
+    if name.len == 0 or not name[0].isDigit:
+      continue
+    try:
+      let pid = parseInt(name)
+      if getParentPid(pid) == ppid:
+        pids.incl(pid)
+        getProcessChildren(pid, pids)
+    except CatchableError:
+      continue

src/display/stb_truetype.h src/common/ffi/stb_truetype.hsrc/display/stb_truetype.h renamed to src/common/ffi/stb_truetype.h

@@ -2,7 +2,7 @@ import std/posix
 
 const
   SYS_reboot = cast[clong](88)
-    
+
   LINUX_REBOOT_MAGIC1 = cast[clong](0xfee1dead'u32)
   LINUX_REBOOT_MAGIC2 = cast[clong](0x28121969'u32)
 
@@ -12,7 +12,7 @@ const
   RB_ENABLE_CAD* = cast[clong](0x89ABCDEF'u32)
   RB_DISABLE_CAD* = cast[clong](0x00000000'u32)
 
-proc syscall(number: clong, arg1: clong, arg2: clong, arg3: clong, arg4: clong): clong 
+proc syscall(number: clong, arg1: clong, arg2: clong, arg3: clong, arg4: clong): clong
   {.importc, header: "<unistd.h>", varargs.}
 
 proc reboot*(cmd: clong): clong =

src/display/stb_truetype.nim src/common/ffi/stb_truetype.nimsrc/display/stb_truetype.nim renamed to src/common/ffi/stb_truetype.nim

@@ -1,8 +1,8 @@
 import std/[os, posix, strutils]
 import nimPNG
 
-import ../common/[fb, process]
-import stb_truetype
+import common/[fb, process]
+import common/ffi/stb_truetype
 
 const
   ScreenWidth = 320
@@ -26,17 +26,6 @@ proc fromRGB565(pixel: uint16, r, g, b: var uint8) {.inline.} =
   g = SixToEight[(pixel shr 5) and 0x3F]
   b = FiveToEight[pixel and 0x1F]
 
-proc setPixel(fb: ptr UncheckedArray[uint16], x, y: int, color: uint16) {.inline.} =
-  if x >= 0 and x < ScreenWidth and y >= 0 and y < ScreenHeight:
-    let fbIdx = RowOffsets[RotationXMap[x]] + y
-    fb[fbIdx] = color
-
-proc getPixel(fb: ptr UncheckedArray[uint16], x, y: int): uint16 {.inline.} =
-  if x >= 0 and x < SCREEN_WIDTH and y >= 0 and y < SCREEN_HEIGHT:
-    let fbIdx = RowOffsets[RotationXMap[x]] + y
-    return fb[fbIdx]
-  return 0
-
 proc loadFont(path: string): seq[byte] =
   let f = open(path, fmRead)
   defer: f.close()
@@ -88,38 +77,50 @@ proc renderTextLine(fb: ptr UncheckedArray[uint16], font: ptr stbtt_fontinfo,
   var cr, cg, cb: uint8
   fromRGB565(color, cr, cg, cb)
 
+  var bitmapBuf = newSeqUninit[byte](64 * 64)
+
   for i, ch in text:
     var ix0, iy0, ix1, iy1: cint
     stbtt_GetCodepointBitmapBox(font, cint(ch), scale, scale,
                                 addr ix0, addr iy0, addr ix1, addr iy1)
-
     let w = ix1 - ix0
     let h = iy1 - iy0
 
     if w > 0 and h > 0:
-      var bitmap = newSeqUninit[byte](w * h)
-      stbtt_MakeCodepointBitmap(font, cast[ptr UncheckedArray[byte]](addr bitmap[0]),
-                                w, h, w, scale, scale, cint(ch))
-
-      {.push checks:off.}
-      for by in 0..<h:
-        for bx in 0..<w:
-          let alpha = bitmap[by * w + bx]
-          if alpha > 0:
-            let px = x + int(ix0) + bx
-            let py = baseline + int(iy0) + by
-
-            if px >= 0 and px < ScreenWidth and py >= 0 and py < ScreenHeight:
-              let bgPixel = getPixel(fb, px, py)
-
-              var bgR, bgG, bgB: uint8
-              fromRGB565(bgPixel, bgR, bgG, bgB)
-
-              let newR = uint8((uint16(cr) * alpha + uint16(bgR) * (255 - alpha)) div 255)
-              let newG = uint8((uint16(cg) * alpha + uint16(bgG) * (255 - alpha)) div 255)
-              let newB = uint8((uint16(cb) * alpha + uint16(bgB) * (255 - alpha)) div 255)
-
-              setPixel(fb, px, py, toRGB565(newR, newG, newB))
+      let needed = w * h
+      if needed > bitmapBuf.len:
+        bitmapBuf.setLen(needed)
+
+      stbtt_MakeCodepointBitmap(font,
+        cast[ptr UncheckedArray[byte]](addr bitmapBuf[0]),
+        w, h, w, scale, scale, cint(ch))
+
+      let charX = x + int(ix0)
+      let charY = baseline + int(iy0)
+
+      {.push checks: off.}
+      for bx in 0..<w:
+        let px = charX + bx
+        if px < 0 or px >= ScreenWidth: continue
+        let fbBase = FbXBase[px]
+
+        for by in 0..<h:
+          let alpha = bitmapBuf[by * w + bx]
+          if alpha == 0: continue
+          let py = charY + by
+          if py < 0 or py >= ScreenHeight: continue
+
+          if alpha == 255:
+            fb[fbBase + py] = color
+          else:
+            let bgPixel = fb[fbBase + py]
+            var bgR, bgG, bgB: uint8
+            fromRGB565(bgPixel, bgR, bgG, bgB)
+            let inv = 255'u32 - uint32(alpha)
+            let newR = uint8((uint32(cr) * uint32(alpha) + uint32(bgR) * inv) div 255)
+            let newG = uint8((uint32(cg) * uint32(alpha) + uint32(bgG) * inv) div 255)
+            let newB = uint8((uint32(cb) * uint32(alpha) + uint32(bgB) * inv) div 255)
+            fb[fbBase + py] = toRGB565(newR, newG, newB)
       {.pop.}
 
     var advanceWidth, leftSideBearing: cint
@@ -168,7 +169,7 @@ proc display*(text: string,
       let g = png.data[srcIdx + 1]
       let b = png.data[srcIdx + 2]
       srcIdx += 4
-      fb[RowOffsets[RotationXMap[lx]] + ly] = toRGB565(r.uint8, g.uint8, b.uint8)
+      fb[FbXBase[lx] + ly] = toRGB565(r.uint8, g.uint8, b.uint8)
 
   if not fileExists(fontPath):
     raise newException(IOError, "display: font file not found: " & fontPath)