mirror of
https://github.com/curioustorvald/tsvm.git
synced 2026-03-07 19:51:51 +09:00
246 lines
8.6 KiB
JavaScript
246 lines
8.6 KiB
JavaScript
// some manual configurations
|
|
//
|
|
let IPFMODE = 3 // 1 or 2
|
|
let TOTAL_FRAMES = 15347
|
|
let FPS = 30 // must be integer
|
|
let WIDTH = 560
|
|
let HEIGHT = 448
|
|
let PATHFUN = (i) => `C:/yain/${(''+i).padStart(5,'0')}.png` // how can be the image file found, if a frame number (starts from 1) were given
|
|
let AUDIOTRACK = 'C:/yain.mp2'
|
|
let AUDIOFORMAT = 'MP2fr' // undefined or PCMu8 or MP2fr
|
|
// to export video to its frames (with automatic scaling and cropping):
|
|
// ffmpeg -i file.mp4 -vf scale=560:448:force_original_aspect_ratio=increase,crop=560:448 file/%05d.png
|
|
//
|
|
// to convert audio to MP2:
|
|
// ffmpeg -i file.mp4 -acodec libtwolame -psymodel 4 -b:a <rate>k -ar 32000 output.mp2
|
|
//
|
|
const FPS_IS_NTSC = true // when set to true, every 1000th frame will be dropped
|
|
const KEYFRAME_DETECTION_THRESHOLD = 0.576
|
|
// end of manual configuration
|
|
let MP2_RATE_INDEX;
|
|
let MP2_PACKETSIZE;
|
|
const DECODE_TIME_FACTOR = 1.000
|
|
|
|
let outfilename = exec_args[1]
|
|
if (!outfilename) {
|
|
println("Usage: encodemov2 <outfile>")
|
|
return 1
|
|
}
|
|
|
|
const FBUF_SIZE = WIDTH * HEIGHT
|
|
let infile = sys.malloc(512000) // somewhat arbitrary
|
|
let imagearea = sys.malloc(FBUF_SIZE*3)
|
|
let decodearea = sys.malloc(FBUF_SIZE)
|
|
let ipfarea1 = sys.malloc(FBUF_SIZE)
|
|
let ipfarea2 = sys.malloc(FBUF_SIZE)
|
|
let ipfDelta = sys.malloc(FBUF_SIZE)
|
|
let gzippedImage = sys.malloc(512000) // somewhat arbitrary
|
|
|
|
|
|
let outfile = files.open(_G.shell.resolvePathInput(outfilename).full)
|
|
|
|
|
|
function appendToOutfile(bytes) {
|
|
outfile.bappend(bytes)
|
|
}
|
|
|
|
function appendToOutfilePtr(ptr, len) {
|
|
outfile.pappend(ptr, len)
|
|
}
|
|
|
|
function audioFormatToAudioPacketType() {
|
|
return ("PCMu8" == AUDIOFORMAT) ? [1, 16]
|
|
: ("MP2fr" == AUDIOFORMAT) ? [255, 17]
|
|
: [255, 16]
|
|
}
|
|
|
|
const videoPacketType = [4, (IPFMODE - 1)]
|
|
const videoPacketTypeIPF1 = [4, (1 - 1)]
|
|
const syncPacket = [255, 255]
|
|
const AUDIO_SAMPLE_SIZE = 2 * (((32000 / FPS) + 1)|0) // times 2 because stereo
|
|
const AUDIO_BLOCK_SIZE = ("MP2fr" == AUDIOFORMAT) ? 0x240 : 0
|
|
const AUDIO_QUEUE_SIZE = ("MP2fr" == AUDIOFORMAT) ? Math.ceil(AUDIO_SAMPLE_SIZE / (2304 * DECODE_TIME_FACTOR)) + 1 : 0
|
|
// write header to the file
|
|
let headerBytes = [
|
|
0x1F, 0x54, 0x53, 0x56, 0x4D, 0x4D, 0x4F, 0x56, // magic
|
|
WIDTH & 255, (WIDTH >> 8) & 255, // width
|
|
HEIGHT & 255, (HEIGHT >> 8) & 255, // height
|
|
FPS & 255, (FPS >> 8) & 255, // FPS
|
|
TOTAL_FRAMES & 255, (TOTAL_FRAMES >> 8) & 255, (TOTAL_FRAMES >> 16) & 255, (TOTAL_FRAMES >> 24) & 255, // frame count
|
|
0xFF, 0x00, // new standard deprecates global type
|
|
AUDIO_BLOCK_SIZE & 255, (AUDIO_BLOCK_SIZE >>> 8) | (AUDIO_QUEUE_SIZE << 4),
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // reserved
|
|
]
|
|
|
|
if (IPFMODE != 3) throw Error("Unknown IPF mode "+IPFMODE)
|
|
|
|
|
|
|
|
let audioBytesRead = 0
|
|
const audioFile = (AUDIOTRACK) ? files.open(_G.shell.resolvePathInput(AUDIOTRACK).full) : undefined
|
|
let audioRemaining = (audioFile) ? audioFile.size : 0
|
|
const audioPacketType = audioFormatToAudioPacketType()
|
|
|
|
|
|
outfile.bwrite(headerBytes)
|
|
|
|
function getRepeatCount(fnum) {
|
|
if ("PCMu8" == AUDIOFORMAT) {
|
|
return (fnum == 1) ? 2 : 1
|
|
}
|
|
else if ("MP2fr" == AUDIOFORMAT) {
|
|
let r = Math.ceil((AUDIO_SAMPLE_SIZE - audioSamplesWrote) / AUDIO_SAMPLE_SIZE) * ((fnum == 1) ? 2 : 1)
|
|
return (fnum == 2) ? 1 : (fnum > TOTAL_FRAMES) ? Math.ceil(audioRemaining / MP2_PACKETSIZE) : r
|
|
}
|
|
}
|
|
|
|
function mp2PacketSizeToRateIndex(packetSize, isMono) {
|
|
let r = (144 == packetSize) ? 0
|
|
: (216 == packetSize) ? 2
|
|
: (252 == packetSize) ? 4
|
|
: (288 == packetSize) ? 6
|
|
: (360 == packetSize) ? 8
|
|
: (432 == packetSize) ? 10
|
|
: (504 == packetSize) ? 12
|
|
: (576 == packetSize) ? 14
|
|
: (720 == packetSize) ? 16
|
|
: (864 == packetSize) ? 18
|
|
: (1008 == packetSize) ? 20
|
|
: (1152 == packetSize) ? 22
|
|
: (1440 == packetSize) ? 24
|
|
: (1728 == packetSize) ? 26 : undefined
|
|
if (r === undefined) throw Error("Unknown MP2 Packet Size: "+packetSize)
|
|
return r + isMono
|
|
}
|
|
|
|
let ipfAreaOld = ipfarea2
|
|
let ipfAreaNew = ipfarea1
|
|
|
|
let audioSamplesWrote = 0
|
|
for (let f = 1; ; f++) {
|
|
|
|
// insert sync packet
|
|
if (f > 1) appendToOutfile(syncPacket)
|
|
|
|
// insert audio track, if any
|
|
if (audioRemaining > 0) {
|
|
|
|
// first frame gets two audio packets
|
|
let rrrr = getRepeatCount(f) // must be called only once
|
|
for (let q = 0; q < rrrr; q++) {
|
|
|
|
print(`Frame ${f}/${TOTAL_FRAMES} (${AUDIOFORMAT}) ->`)
|
|
serial.print(`Frame ${f}/${TOTAL_FRAMES} (${AUDIOFORMAT}) ->`)
|
|
|
|
// read a chunk/mpeg-frame
|
|
let actualBytesToRead;
|
|
if ("PCMu8" == AUDIOFORMAT) {
|
|
actualBytesToRead = Math.min(
|
|
(f % 2 == 1) ? AUDIO_SAMPLE_SIZE : AUDIO_SAMPLE_SIZE + 2,
|
|
audioRemaining
|
|
)
|
|
audioFile.pread(infile, actualBytesToRead, audioBytesRead)
|
|
}
|
|
else if ("MP2fr" == AUDIOFORMAT) {
|
|
if (!MP2_PACKETSIZE) {
|
|
audioFile.pread(infile, 3, 0)
|
|
MP2_PACKETSIZE = audio.mp2GetInitialFrameSize([sys.peek(infile),sys.peek(infile+1),sys.peek(infile+2)])
|
|
audioPacketType[0] = mp2PacketSizeToRateIndex(MP2_PACKETSIZE, sys.peek(infile+4) >> 6 == 3)
|
|
}
|
|
|
|
actualBytesToRead = Math.min(MP2_PACKETSIZE, audioRemaining)
|
|
audioFile.pread(infile, actualBytesToRead, audioBytesRead)
|
|
if (f > 1) audioSamplesWrote += 2304 / DECODE_TIME_FACTOR // a little hack to ensure first 2 or so frames get more MP2 frames than they should
|
|
}
|
|
else if (AUDIOFORMAT !== undefined) throw Error("Unknown audio format: " + AUDIOFORMAT)
|
|
|
|
// writeout
|
|
let audioSize = [
|
|
(actualBytesToRead >>> 0) & 255,
|
|
(actualBytesToRead >>> 8) & 255,
|
|
(actualBytesToRead >>> 16) & 255,
|
|
(actualBytesToRead >>> 24) & 255
|
|
]
|
|
|
|
appendToOutfile(audioPacketType)
|
|
if ("MP2fr" != AUDIOFORMAT) appendToOutfile(audioSize);
|
|
appendToOutfilePtr(infile, actualBytesToRead)
|
|
|
|
|
|
|
|
print(` ${actualBytesToRead} bytes\n`)
|
|
serial.print(` ${actualBytesToRead} bytes\n`)
|
|
|
|
audioBytesRead += actualBytesToRead
|
|
audioRemaining -= actualBytesToRead
|
|
}
|
|
}
|
|
if (FPS_IS_NTSC && f > 0 && f % 1000 == 0) {
|
|
}
|
|
// insert video frame
|
|
else if (f <= TOTAL_FRAMES) {
|
|
let fname = PATHFUN(f)
|
|
let framefile = files.open(_G.shell.resolvePathInput(fname).full)
|
|
let fileLen = framefile.size
|
|
framefile.pread(infile, fileLen)
|
|
|
|
|
|
let [_1, _2, channels, _3] = graphics.decodeImageTo(infile, fileLen, imagearea)
|
|
|
|
print(`Frame ${f}/${TOTAL_FRAMES} (Ch: ${channels}) ->`)
|
|
serial.print(`Frame ${f}/${TOTAL_FRAMES} (Ch: ${channels}) ->`)
|
|
|
|
// graphics.imageToDisplayableFormat(imagearea, decodearea, 560, 448, 3, 1)
|
|
graphics.encodeIpf1(imagearea, ipfAreaNew, WIDTH, HEIGHT, channels, false, 0)
|
|
|
|
// get the difference map
|
|
let patchEncodedSize = graphics.encodeIpf1d(ipfAreaOld, ipfAreaNew, ipfDelta, WIDTH, HEIGHT)
|
|
|
|
if (f < 2 || f == TOTAL_FRAMES || patchEncodedSize > WIDTH * HEIGHT * KEYFRAME_DETECTION_THRESHOLD) patchEncodedSize = 0
|
|
|
|
// decide whether or not the patch encoding should be used
|
|
let gzlen = gzip.compFromTo(
|
|
(patchEncodedSize) ? ipfDelta : ipfAreaNew,
|
|
patchEncodedSize || FBUF_SIZE,
|
|
gzippedImage
|
|
)
|
|
|
|
let frameSize = [
|
|
(gzlen >>> 0) & 255,
|
|
(gzlen >>> 8) & 255,
|
|
(gzlen >>> 16) & 255,
|
|
(gzlen >>> 24) & 255
|
|
]
|
|
|
|
appendToOutfile(patchEncodedSize ? videoPacketType : videoPacketTypeIPF1)
|
|
appendToOutfile(frameSize)
|
|
appendToOutfilePtr(gzippedImage, gzlen)
|
|
|
|
if (patchEncodedSize) {
|
|
print(` ${gzlen} bytes (${100*(patchEncodedSize / (WIDTH * HEIGHT))} %)\n`)
|
|
serial.print(` ${gzlen} bytes (${100*(patchEncodedSize / (WIDTH * HEIGHT))} %)\n`)
|
|
}
|
|
else {
|
|
print(` ${gzlen} bytes\n`)
|
|
serial.print(` ${gzlen} bytes\n`)
|
|
}
|
|
|
|
audioSamplesWrote -= AUDIO_SAMPLE_SIZE
|
|
|
|
// swap two pointers
|
|
let t = ipfAreaOld
|
|
ipfAreaOld = ipfAreaNew
|
|
ipfAreaNew = t
|
|
}
|
|
|
|
// if there is no video and audio remaining, exit the loop
|
|
if (f > TOTAL_FRAMES && audioRemaining <= 0) break
|
|
}
|
|
|
|
sys.free(infile)
|
|
sys.free(imagearea)
|
|
sys.free(decodearea)
|
|
sys.free(ipfarea1)
|
|
sys.free(ipfarea2)
|
|
sys.free(ipfDelta)
|
|
sys.free(gzippedImage) |