├── .gitignore
├── README.md
├── decode
    ├── apis
    │   ├── bitreader.lua
    │   ├── hexscreen.lua
    │   └── wave.lua
    └── videoplayer.lua
├── encode
    ├── encoder.py
    └── quadtree.py
└── sample
    ├── badapple.nbs
    ├── badapple.qtv
    └── playbadapple.lua


/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__/
2 | *.mp4
3 | *.qtv
4 | *.nbs
5 | *.png
6 | *.txt
7 | !sample/*
8 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # QuadTree Compression for ComputerCraft Videos
 2 | 
 3 | ## Sample
 4 | Go on any ComputerCraft (CC: Tweaked is the only one confirmed to work, earlier versions are probably not going to work) computer and run `pastebin run KMRmKTc1` to play Bad Apple on it. If you have a speaker, it'll use it. If you have a monitor, it'll also use it. It works even on a normal computer since it only uses black and white.
 5 | 
 6 | ## Problem
 7 | Videos are big, like really big. ComputerCraft only has 1 MB of space by default. I want to play Bad Apple!! on them at a decent resolution. I used a QuadTree structure to achieve that.
 8 | 
 9 | ## Requirements
10 | ### For decoding
11 | It's already included, I just wanted to link it.
12 |  - [wave](https://github.com/CrazedProgrammer/wave)
13 | 
14 | ### For encoding
15 | You can install those with pip.
16 |  - numpy
17 |  - moviepy
18 | 
19 | ## How to use
20 | Use `py encoder.py -c quadtree -i <video file> -o <output file>` to convert a file, then get that file on a computer with the video player and run `videoplayer <qtv file>`. The file must have a .qtv extension, and the name given to the Lua program must not include it. It's done this way because to play audio it simply reads a .nbs file with the same name. Not optimal, but I wanted to have something that worked quickly, so some sacrifices had to be made.
21 | 
22 | ## License
23 | Do whatever, use, copy, redistribute, just make sure you're not taking credit for my work.
24 | 
25 | Also, you know the deal, I'm not responsible if you computer blows up.


--------------------------------------------------------------------------------
/decode/apis/bitreader.lua:
--------------------------------------------------------------------------------
  1 | local bit = bit
  2 | 
  3 | local function readBit_b8(self)
  4 | 	if (self.current > 8) then
  5 | 		return false, false
  6 | 	end
  7 | 
  8 | 	self.current = self.current + 1
  9 | 	local v = bit.band(self._value, self._bits[self.current])
 10 | 
 11 | 	return self.current < 8, v > 0
 12 | 
 13 | end
 14 | 
 15 | local function new(self, value)
 16 | 	self.current = 0
 17 | 	self._value = value
 18 | 
 19 | end
 20 | 
 21 | function Bits8()
 22 | 	-- Represents a byte, allows reading a bit at a time.
 23 | 	local self = {}
 24 | 
 25 | 	self.current = 0
 26 | 	self._value = 0
 27 | 	self._bits = {128, 64, 32, 16, 8, 4, 2, 1}
 28 | 
 29 | 	self.readBit = readBit_b8
 30 | 	self.new = new
 31 | 
 32 | 	return self
 33 | 
 34 | end
 35 | 
 36 | 
 37 | 
 38 | local function readBit_br(self)
 39 | 	local s, v = self.cb:readBit()
 40 | 	if (not s) then
 41 | 		self.pointer = self.pointer + 1
 42 | 		self.cb:new(self.data[self.pointer])
 43 | 
 44 | 	end
 45 | 
 46 | 	return v
 47 | 
 48 | end
 49 | 
 50 | local function readBits(self, n)
 51 | 	local bt = self._bittable
 52 | 	for i = 1, n do
 53 | 		bt[i] = self:readBit()
 54 | 		
 55 | 	end
 56 | 	for i = n+1, #bt do
 57 | 		bt[i] = nil
 58 | 		
 59 | 	end
 60 | 
 61 | 	return bt
 62 | 
 63 | end
 64 | 
 65 | local function readNumber(self, n)
 66 | 	local m = 0
 67 | 
 68 | 	local t = self:readBits(n)
 69 | 	for i = 1, #t do
 70 | 		m = m * 2
 71 | 		if (t[i]) then
 72 | 			m = m + 1
 73 | 
 74 | 		end
 75 | 
 76 | 	end
 77 | 
 78 | 	return m
 79 | 
 80 | end
 81 | 
 82 | local function reset(self)
 83 | 	self.cb = Bits8()
 84 | 	self.pointer = 1
 85 | 	self.cb:new(self.data[self.pointer])
 86 | 
 87 | end
 88 | 
 89 | function BitReader(data)
 90 | 	-- Class to read bits individually from a table of bytes.
 91 | 	local self = {}
 92 | 
 93 | 	self.data = data
 94 | 	self.cb = Bits8()
 95 | 	self.pointer = 1
 96 | 	self.cb:new(self.data[self.pointer])
 97 | 
 98 | 	self.readBit = readBit_br
 99 | 	self.readBits = readBits
100 | 	self.readNumber = readNumber
101 | 	self.reset = reset
102 | 
103 | 	self._bittable = {}
104 | 
105 | 	return self
106 | 
107 | end


--------------------------------------------------------------------------------
/decode/apis/hexscreen.lua:
--------------------------------------------------------------------------------
  1 | local table = table
  2 | local string = string
  3 | local term = term
  4 | 
  5 | local function draw(self)
  6 | 	-- Draws the entire visible buffer.
  7 | 	local te = self.term
  8 | 	for y=1, self.height do
  9 | 		te.setCursorPos(1, y)
 10 | 		c0, c1, c2 = self:getLine(y)
 11 | 
 12 | 		te.blit(c0, c1, c2)
 13 | 		
 14 | 	end
 15 | 
 16 | end
 17 | 
 18 | local n
 19 | local b
 20 | 
 21 | local function getCharAt(self, x, y)
 22 | 	n = 0
 23 | 	b = self.buffer
 24 | 	for i=y*3,y*3-2,-1 do
 25 | 		for j=x*2,x*2-1,-1 do
 26 | 			n = n * 2
 27 | 			if (b[i][j]) then
 28 | 				n = n + 1
 29 | 			end
 30 | 			
 31 | 		end
 32 | 
 33 | 	end
 34 | 
 35 | 	return n
 36 | 
 37 | end
 38 | 
 39 | local _t
 40 | local _c
 41 | local _bg
 42 | local _cl
 43 | local cs
 44 | 
 45 | local c
 46 | 
 47 | local function getLine(self, y)
 48 | 	_t = self._text
 49 | 	_c = self._color
 50 | 	_bg = self._bgcolor
 51 | 	_cl = self._charList
 52 | 
 53 | 	cs = self.colors
 54 | 
 55 | 	for x=1,self.width do
 56 | 		c = self:getCharAt(x, y)
 57 | 		_t[x] = _cl[c]
 58 | 
 59 | 		if (c >= 32) then
 60 | 			_c[x] = cs[2]
 61 | 			_bg[x] = cs[1]
 62 | 		else
 63 | 			_c[x] = cs[1]
 64 | 			_bg[x] = cs[2]
 65 | 
 66 | 		end
 67 | 
 68 | 	end
 69 | 
 70 | 	return table.concat(_t), table.concat(_c), table.concat(_bg)
 71 | 
 72 | end
 73 | 
 74 | local tb
 75 | local function setSize(self, w, h)
 76 | 	self.width, self.height = w, h
 77 | 	self.b_width = self.height * 2
 78 | 	self.b_height = self.height * 3
 79 | 
 80 | 	self.buffer = {}
 81 | 
 82 | 	for i=1, self.b_height do
 83 | 		tb = {}
 84 | 		for j=1, self.b_height do
 85 | 			tb[j] = false
 86 | 		end
 87 | 		self.buffer[i] = tb
 88 | 	end
 89 | 
 90 | end
 91 | 
 92 | local function setSizeBuffer(self, w, h)
 93 | 	self:setSize(math.floor(w/2), math.floor(h/3))
 94 | 
 95 | end
 96 | 
 97 | function HexScreen(customTerm)
 98 | 	local self = {}
 99 | 
100 | 	self.term = customTerm or term
101 | 	
102 | 	self.width, self.height = self.term.getSize()
103 | 	self.b_width = self.width * 2
104 | 	self.b_height = self.height * 3
105 | 
106 | 	self.buffer = {}
107 | 
108 | 	for i=1, self.b_height do
109 | 		local t = {}
110 | 		for j=1, self.b_height do
111 | 			table.insert(t, false)
112 | 		end
113 | 		table.insert(self.buffer, t)
114 | 	end
115 | 
116 | 	self._text = {}
117 | 	self._color = {}
118 | 	self._bgcolor = {}
119 | 
120 | 	self.colors = {"0", "f"}
121 | 
122 | 	self._charList = {}
123 | 	for i=0,63 do
124 | 		if (i < 32) then
125 | 			c = string.char(128 + i)
126 | 
127 | 		else
128 | 			c = string.char(191 - i)
129 | 
130 | 		end
131 | 
132 | 		self._charList[i] = c
133 | 
134 | 	end
135 | 
136 | 	self.draw = draw
137 | 	self.getCharAt = getCharAt
138 | 	self.getLine = getLine
139 | 	self.setSize = setSize
140 | 	self.setSizeBuffer = setSizeBuffer
141 | 
142 | 	return self
143 | 
144 | end
145 | 


--------------------------------------------------------------------------------
/decode/apis/wave.lua:
--------------------------------------------------------------------------------
  1 | --[[
  2 | wave version 0.1.5
  3 | 
  4 | The MIT License (MIT)
  5 | Copyright (c) 2020 CrazedProgrammer
  6 | 
  7 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
  8 | associated documentation files (the "Software"), to deal in the Software without restriction,
  9 | including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
 10 | and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do
 11 | so, subject to the following conditions:
 12 | 
 13 | The above copyright notice and this permission notice shall be included in all copies or
 14 | substantial portions of the Software.
 15 | 
 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 17 | INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 18 | PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 19 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 20 | AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 22 | ]]
 23 | 
 24 | -- I'm so happy I don't have to write or understand this code, thanks! - ax.
 25 | 
 26 | 
 27 | local wave = { }
 28 | wave.version = "0.1.5"
 29 | 
 30 | wave._oldSoundMap = {"harp", "bassattack", "bd", "snare", "hat"}
 31 | wave._newSoundMap = {"harp", "bass", "basedrum", "snare", "hat"}
 32 | wave._defaultThrottle = 99
 33 | wave._defaultClipMode = 1
 34 | wave._maxInterval = 1
 35 | wave._isNewSystem = false
 36 | if _HOST then
 37 | 	-- Redoing this, the correct and boring way, otherwise it doesn't work with versions above 1.100 until 1.800. - axisok
 38 | 	-- Likely to break only if CC:Tweaked changes how it writes versions.
 39 | 	local _matches = {}
 40 | 	for s in string.gmatch(_HOST, "%S+") do
 41 | 		_matches[#_matches + 1] = s
 42 | 	end
 43 | 
 44 | 	local _v = _matches[2]
 45 | 	_matches = {}
 46 | 	for s in string.gmatch(_v, "%P+") do
 47 | 		_matches[#_matches + 1] = s
 48 | 	end
 49 | 
 50 | 	local _new = {1, 80}
 51 | 	wave._isNewSystem = true
 52 | 	for i=1, #_new, 1 do
 53 | 		if (i <= #_matches and _new[i] < tonumber(_matches[i])) then
 54 | 			break
 55 | 
 56 | 		elseif (i <= #_matches and _new[i] > tonumber(_matches[i])) then
 57 | 			wave._isNewSystem = false
 58 | 			break
 59 | 		end
 60 | 
 61 | 	end
 62 | 
 63 | 
 64 | end
 65 | 
 66 | wave.context = { }
 67 | wave.output = { }
 68 | wave.track = { }
 69 | wave.instance = { }
 70 | 
 71 | function wave.createContext(clock, volume)
 72 | 	clock = clock or os.clock()
 73 | 	volume = volume or 1.0
 74 | 
 75 | 	local context = setmetatable({ }, {__index = wave.context})
 76 | 	context.outputs = { }
 77 | 	context.instances = { }
 78 | 	context.vs = {0, 0, 0, 0, 0}
 79 | 	context.prevClock = clock
 80 | 	context.volume = volume
 81 | 	return context
 82 | end
 83 | 
 84 | function wave.context:addOutput(...)
 85 | 	local output = wave.createOutput(...)
 86 | 	self.outputs[#self.outputs + 1] = output
 87 | 	return output
 88 | end
 89 | 
 90 | function wave.context:addOutputs(...)
 91 | 	local outs = {...}
 92 | 	if #outs == 1 then
 93 | 		if not getmetatable(outs) then
 94 | 			outs = outs[1]
 95 | 		else
 96 | 			if getmetatable(outs).__index ~= wave.outputs then
 97 | 				outs = outs[1]
 98 | 			end
 99 | 		end
100 | 	end
101 | 	for i = 1, #outs do
102 | 		self:addOutput(outs[i])
103 | 	end
104 | end
105 | 
106 | function wave.context:removeOutput(out)
107 | 	if type(out) == "number" then
108 | 		table.remove(self.outputs, out)
109 | 		return
110 | 	elseif type(out) == "table" then
111 | 		if getmetatable(out).__index == wave.output then
112 | 			for i = 1, #self.outputs do
113 | 				if out == self.outputs[i] then
114 | 					table.remove(self.outputs, i)
115 | 					return
116 | 				end
117 | 			end
118 | 			return
119 | 		end
120 | 	end
121 | 	for i = 1, #self.outputs do
122 | 		if out == self.outputs[i].native then
123 | 			table.remove(self.outputs, i)
124 | 			return
125 | 		end
126 | 	end
127 | end
128 | 
129 | function wave.context:addInstance(...)
130 | 	local instance = wave.createInstance(...)
131 | 	self.instances[#self.instances + 1] = instance
132 | 	return instance
133 | end
134 | 
135 | function wave.context:removeInstance(instance)
136 | 	if type(instance) == "number" then
137 | 		table.remove(self.instances, instance)
138 | 	else
139 | 		for i = 1, #self.instances do
140 | 			if self.instances == instance then
141 | 				table.remove(self.instances, i)
142 | 				return
143 | 			end
144 | 		end
145 | 	end
146 | end
147 | 
148 | function wave.context:playNote(note, pitch, volume)
149 | 	volume = volume or 1.0
150 | 
151 | 	self.vs[note] = self.vs[note] + volume
152 | 	for i = 1, #self.outputs do
153 | 		self.outputs[i]:playNote(note, pitch, volume * self.volume)
154 | 	end
155 | end
156 | 
157 | function wave.context:update(interval)
158 | 	local clock = os.clock()
159 | 	interval = interval or (clock - self.prevClock)
160 | 
161 | 	self.prevClock = clock
162 | 	if interval > wave._maxInterval then
163 | 		interval = wave._maxInterval
164 | 	end
165 | 	for i = 1, #self.outputs do
166 | 		self.outputs[i].notes = 0
167 | 	end
168 | 	for i = 1, 5 do
169 | 		self.vs[i] = 0
170 | 	end
171 | 	if interval > 0 then
172 | 		for i = 1, #self.instances do
173 | 			local notes = self.instances[i]:update(interval)
174 | 			for j = 1, #notes / 3 do
175 | 				self:playNote(notes[j * 3 - 2], notes[j * 3 - 1], notes[j * 3])
176 | 			end
177 | 		end
178 | 	end
179 | end
180 | 
181 | 
182 | 
183 | function wave.createOutput(out, volume, filter, throttle, clipMode)
184 | 	volume = volume or 1.0
185 | 	filter = filter or {true, true, true, true, true}
186 | 	throttle = throttle or wave._defaultThrottle
187 | 	clipMode = clipMode or wave._defaultClipMode
188 | 
189 | 	local output = setmetatable({ }, {__index = wave.output})
190 | 	output.native = out
191 | 	output.volume = volume
192 | 	output.filter = filter
193 | 	output.notes = 0
194 | 	output.throttle = throttle
195 | 	output.clipMode = clipMode
196 | 	if type(out) == "function" then
197 | 		output.nativePlayNote = out
198 | 		output.type = "custom"
199 | 		return output
200 | 	elseif type(out) == "string" then
201 | 		if peripheral.getType(out) == "iron_noteblock" then
202 | 			if wave._isNewSystem then
203 | 				local nb = peripheral.wrap(out)
204 | 				output.type = "iron_noteblock"
205 | 				function output.nativePlayNote(note, pitch, vol)
206 | 					if output.volume * vol > 0 then
207 | 						nb.playSound("minecraft:block.note."..wave._newSoundMap[note], vol, math.pow(2, (pitch - 12) / 12))
208 | 					end
209 | 				end
210 | 				return output
211 | 			end
212 | 		elseif peripheral.getType(out) == "speaker" then
213 | 			if wave._isNewSystem then
214 | 				local nb = peripheral.wrap(out)
215 | 				output.type = "speaker"
216 | 				function output.nativePlayNote(note, pitch, vol)
217 | 					if output.volume * vol > 0 then
218 | 						nb.playNote(wave._newSoundMap[note], vol, pitch)
219 | 					end
220 | 				end
221 | 				return output
222 | 			end
223 | 		end
224 | 	elseif type(out) == "table" then
225 | 		if out.execAsync then
226 | 			output.type = "commands"
227 | 			if wave._isNewSystem then
228 | 				function output.nativePlayNote(note, pitch, vol)
229 | 					out.execAsync("playsound minecraft:block.note."..wave._newSoundMap[note].." record @a ~ ~ ~ "..tostring(vol).." "..tostring(math.pow(2, (pitch - 12) / 12)))
230 | 				end
231 | 			else
232 | 				function output.nativePlayNote(note, pitch, vol)
233 | 					out.execAsync("playsound note."..wave._oldSoundMap[note].." @a ~ ~ ~ "..tostring(vol).." "..tostring(math.pow(2, (pitch - 12) / 12)))
234 | 				end
235 | 			end
236 | 			return output
237 | 		elseif getmetatable(out) then
238 | 			if getmetatable(out).__index == wave.output then
239 | 				return out
240 | 			end
241 | 		end
242 | 	end
243 | end
244 | 
245 | function wave.scanOutputs()
246 | 	local outs = { }
247 | 	if commands then
248 | 		outs[#outs + 1] = wave.createOutput(commands)
249 | 	end
250 | 	local sides = peripheral.getNames()
251 | 	for i = 1, #sides do
252 | 		if peripheral.getType(sides[i]) == "iron_noteblock" then
253 | 			outs[#outs + 1] = wave.createOutput(sides[i])
254 | 		elseif peripheral.getType(sides[i]) == "speaker" then
255 | 			outs[#outs + 1] = wave.createOutput(sides[i])
256 | 		end
257 | 	end
258 | 	return outs
259 | end
260 | 
261 | function wave.output:playNote(note, pitch, volume)
262 | 	volume = volume or 1.0
263 | 
264 | 	if self.clipMode == 1 then
265 | 		if pitch < 0 then
266 | 			pitch = 0
267 | 		elseif pitch > 24 then
268 | 			pitch = 24
269 | 		end
270 | 	elseif self.clipMode == 2 then
271 | 		if pitch < 0 then
272 | 			while pitch < 0 do
273 | 				pitch = pitch + 12
274 | 			end
275 | 		elseif pitch > 24 then
276 | 			while pitch > 24 do
277 | 				pitch = pitch - 12
278 | 			end
279 | 		end
280 | 	end
281 | 	if self.filter[note] and self.notes < self.throttle then
282 | 		self.nativePlayNote(note, pitch, volume * self.volume)
283 | 		self.notes = self.notes + 1
284 | 	end
285 | end
286 | 
287 | 
288 | 
289 | function wave.loadTrack(path)
290 | 	local track = setmetatable({ }, {__index = wave.track})
291 | 	local handle = fs.open(path, "rb")
292 | 	if not handle then return end
293 | 
294 | 	local function readInt(size)
295 | 		local num = 0
296 | 		for i = 0, size - 1 do
297 | 			local byte = handle.read()
298 | 			if not byte then -- dont leave open file handles no matter what
299 | 				handle.close()
300 | 				return
301 | 			end
302 | 			num = num + byte * (256 ^ i)
303 | 		end
304 | 		return num
305 | 	end
306 | 	local function readStr()
307 | 		local length = readInt(4)
308 | 		if not length then return end
309 | 		local data = { }
310 | 		for i = 1, length do
311 | 			data[i] = string.char(handle.read())
312 | 		end
313 | 		return table.concat(data)
314 | 	end
315 | 
316 | 	-- Part #1: Metadata
317 | 	track.length = readInt(2) -- song length (ticks)
318 | 	track.height = readInt(2) -- song height
319 | 	track.name = readStr() -- song name
320 | 	track.author = readStr() -- song author
321 | 	track.originalAuthor = readStr() -- original song author
322 | 	track.description = readStr() -- song description
323 | 	track.tempo = readInt(2) / 100 -- tempo (ticks per second)
324 | 	track.autoSaving = readInt(1) == 0 and true or false -- auto-saving
325 | 	track.autoSavingDuration = readInt(1) -- auto-saving duration
326 | 	track.timeSignature = readInt(1) -- time signature (3 = 3/4)
327 | 	track.minutesSpent = readInt(4) -- minutes spent
328 | 	track.leftClicks = readInt(4) -- left clicks
329 | 	track.rightClicks = readInt(4) -- right clicks
330 | 	track.blocksAdded = readInt(4) -- blocks added
331 | 	track.blocksRemoved = readInt(4) -- blocks removed
332 | 	track.schematicFileName = readStr() -- midi/schematic file name
333 | 
334 | 	-- Part #2: Notes
335 | 	track.layers = { }
336 | 	for i = 1, track.height do
337 | 		track.layers[i] = {name = "Layer "..i, volume = 1.0}
338 | 		track.layers[i].notes = { }
339 | 	end
340 | 
341 | 	local tick = 0
342 | 	while true do
343 | 		local tickJumps = readInt(2)
344 | 		if tickJumps == 0 then break end
345 | 		tick = tick + tickJumps
346 | 		local layer = 0
347 | 		while true do
348 | 			local layerJumps = readInt(2)
349 | 			if layerJumps == 0 then break end
350 | 			layer = layer + layerJumps
351 | 			if layer > track.height then -- nbs can be buggy
352 | 				for i = track.height + 1, layer do
353 | 					track.layers[i] = {name = "Layer "..i, volume = 1.0}
354 | 					track.layers[i].notes = { }
355 | 				end
356 | 				track.height = layer
357 | 			end
358 | 			local instrument = readInt(1)
359 | 			local key = readInt(1)
360 | 			if instrument <= 4 then -- nbs can be buggy
361 | 				track.layers[layer].notes[tick * 2 - 1] = instrument + 1
362 | 				track.layers[layer].notes[tick * 2] = key - 33
363 | 			end
364 | 		end
365 | 	end
366 | 
367 | 	-- Part #3: Layers
368 | 	for i = 1, track.height do
369 | 		local name = readStr()
370 | 		if not name then break end -- if layer data doesnt exist, abort
371 | 		track.layers[i].name = name
372 | 		track.layers[i].volume = readInt(1) / 100
373 | 	end
374 | 
375 | 	handle.close()
376 | 	return track
377 | end
378 | 
379 | 
380 | 
381 | function wave.createInstance(track, volume, playing, loop)
382 | 	volume = volume or 1.0
383 | 	playing = (playing == nil) or playing
384 | 	loop = (loop ~=  nil) and loop
385 | 
386 | 	if getmetatable(track).__index == wave.instance then
387 | 		return track
388 | 	end
389 | 	local instance = setmetatable({ }, {__index = wave.instance})
390 | 	instance.track = track
391 | 	instance.volume = volume or 1.0
392 | 	instance.playing = playing
393 | 	instance.loop = loop
394 | 	instance.tick = 1
395 | 	return instance
396 | end 
397 | 
398 | function wave.instance:update(interval)
399 | 	local notes = { }
400 | 	if self.playing then
401 | 		local dticks = interval * self.track.tempo
402 | 		local starttick = self.tick
403 | 		local endtick = starttick + dticks
404 | 		local istarttick = math.ceil(starttick)
405 | 		local iendtick = math.ceil(endtick) - 1
406 | 		for i = istarttick, iendtick do
407 | 			for j = 1, self.track.height do
408 | 				if self.track.layers[j].notes[i * 2 - 1] then
409 | 					notes[#notes + 1] = self.track.layers[j].notes[i * 2 - 1]
410 | 					notes[#notes + 1] = self.track.layers[j].notes[i * 2]
411 | 					notes[#notes + 1] = self.track.layers[j].volume
412 | 				end
413 | 			end
414 | 		end
415 | 		self.tick = self.tick + dticks
416 | 
417 | 		if endtick > self.track.length then
418 | 			self.tick = 1
419 | 			self.playing = self.loop
420 | 		end
421 | 	end
422 | 	return notes
423 | end
424 | 
425 | 
426 | 
427 | return wave
428 | 


--------------------------------------------------------------------------------
/decode/videoplayer.lua:
--------------------------------------------------------------------------------
  1 | require("apis.hexscreen")
  2 | require("apis.bitreader")
  3 | local wave = require("apis.wave")
  4 | 
  5 | local math = math
  6 | local sleep = sleep
  7 | local string = string
  8 | local screen = term
  9 | 
 10 | local data
 11 | local frame
 12 | 
 13 | local reader
 14 | 
 15 | local width
 16 | local height
 17 | local sleep_ticks
 18 | 
 19 | local _width_bits
 20 | local _height_bits
 21 | 
 22 | local fi
 23 | 
 24 | local arg = {...}
 25 | 
 26 | local function findPer(pName)
 27 | 	if (peripheral.getName) then
 28 | 		local p = peripheral.find(pName)
 29 | 		local n
 30 | 
 31 | 		if (p) then
 32 | 			n = peripheral.getName(p)
 33 | 		end
 34 | 
 35 | 		return n, p
 36 | 
 37 | 	else
 38 | 		local d = {"top", "bottom", "right", "left", "front", "back"}
 39 | 		for i=1, #d do
 40 | 			if (peripheral.getType(d[i]) == pName) then
 41 | 				local p = peripheral.wrap(d[i])
 42 | 				local n = d[i]
 43 | 				return n, p
 44 | 				
 45 | 			end
 46 | 			
 47 | 		end
 48 | 
 49 | 	end
 50 | 
 51 | end
 52 | 
 53 | local function invertQuad(x, y, w, h)
 54 | 	for i=y, y+h-1 do
 55 | 		fi = frame[i]
 56 | 		for j=x, x+w-1 do
 57 | 			fi[j] = not fi[j]
 58 | 
 59 | 		end
 60 | 	end
 61 | 
 62 | 	return frame
 63 | 
 64 | end
 65 | 
 66 | local function readQuad(x, y, w, h)
 67 | 	if (w * h == 0) then
 68 | 		return
 69 | 	end
 70 | 
 71 | 
 72 | 	if (reader:readBit()) then
 73 | 		-- Splits into 4 more quads.
 74 | 		
 75 | 		local cw = math.ceil(w/2)
 76 | 		local ch = math.ceil(h/2)
 77 | 		local fw = math.floor(w/2)
 78 | 		local fh = math.floor(h/2)
 79 | 
 80 | 		readQuad(x, y, cw, ch)
 81 | 		readQuad(x+cw, y, fw, ch)
 82 | 		readQuad(x, y+ch, cw, fh)
 83 | 		readQuad(x+cw, y+ch, fw, fh)
 84 | 		
 85 | 	else
 86 | 		-- Doesn't split.
 87 | 		if (reader:readBit()) then
 88 | 			-- Inverts the region of this quad.
 89 | 			invertQuad(x, y, w, h)
 90 | 		
 91 | 		end
 92 | 
 93 | 	end
 94 | 
 95 | end
 96 | 
 97 | local fx
 98 | local fy
 99 | 
100 | local w_bits
101 | local h_bits
102 | 
103 | local frw
104 | local frh
105 | 
106 | local function readFrame()
107 | 	fx = reader:readNumber(_width_bits)
108 | 	fy = reader:readNumber(_height_bits)
109 | 
110 | 	w_bits = 0
111 | 	h_bits = 0
112 | 
113 | 	while (2^w_bits <= width - fx) do
114 | 		w_bits = w_bits + 1
115 | 	end
116 | 	
117 | 	while (2^h_bits <= height - fy) do
118 | 		h_bits = h_bits + 1
119 | 	end
120 | 
121 | 	frw = reader:readNumber(w_bits)
122 | 
123 | 	if (frw == 0) then
124 | 		return
125 | 	end
126 | 	frh = reader:readNumber(h_bits)
127 | 	
128 | 	
129 | 
130 | 
131 | 	readQuad(fx+1, fy+1, frw, frh)
132 | 
133 | end
134 | 
135 | local loop = false
136 | for i=1, #arg do
137 | 	if (arg[i] == "loop") then
138 | 		loop = true
139 | 		table.remove(arg, i)
140 | 		break
141 | 
142 | 	end
143 | 
144 | end
145 | 
146 | print("Reading files...")
147 | 
148 | local videofile = arg[1]
149 | local audiofile
150 | 
151 | local dPos = videofile:find("%.")
152 | if (dPos) then
153 | 	audiofile = videofile:sub(1, dPos-1) .. ".nbs"
154 | 	
155 | else
156 | 	audiofile = videofile .. ".nbs"
157 | 	videofile = videofile .. ".qtv"
158 | 
159 | end
160 | 
161 | -- Read the audio file
162 | local wc
163 | if (audiofile and fs.exists(audiofile)) then
164 | 	local dir, speaker = findPer("speaker")
165 | 	
166 | 	if (speaker ~= nil) then
167 | 		wc = wave.createContext()
168 | 		wc:addOutput(dir)
169 | 		local t = wave.loadTrack(audiofile)
170 | 		wc:addInstance(wave.createInstance(t))
171 | 		
172 | 	end
173 | 
174 | end
175 | 
176 | 
177 | -- Read the video file
178 | if (not fs.exists(videofile)) then
179 | 	error("video file '" .. videofile .. "' not found.")
180 | 
181 | end
182 | 
183 | local f = fs.open(videofile, "rb")
184 | local fileString = f.readAll()
185 | data = {string.byte(fileString, 1, -1)}
186 | 
187 | f.close()
188 | 
189 | 
190 | reader = BitReader(data)
191 | 
192 | sleep_ticks = reader:readNumber(5)+1
193 | width = reader:readNumber(10)+1
194 | height = reader:readNumber(9)+1
195 | 
196 | _width_bits = 0
197 | _height_bits = 0
198 | 
199 | while (2^_width_bits <= width) do
200 | 	_width_bits = _width_bits + 1
201 | end
202 | 
203 | while (2^_height_bits <= height) do
204 | 	_height_bits = _height_bits + 1
205 | end
206 | 
207 | local mon = peripheral.find("monitor")
208 | 
209 | if (mon ~= nil) then
210 | 	screen = mon
211 | 	
212 | 	for s=5,0.5,-0.5 do
213 | 		screen.setTextScale(s)
214 | 		w, h = screen.getSize()
215 | 		if (width <= (w+1)*2 or height <= (h+1)*3) then
216 | 			break
217 | 		end
218 | 		
219 | 	end
220 | 
221 | end
222 | 
223 | local hs = HexScreen(screen)
224 | hs:setSizeBuffer(width, height)
225 | 
226 | local fri
227 | 
228 | frame = {}
229 | for i=1, height do
230 | 	frame[i] = {}
231 | 	fri = frame[i]
232 | 	for j=1, width do
233 | 		fri[j] = false
234 | 	end
235 | end
236 | 
237 | hs.buffer = frame
238 | local status, err
239 | while true do
240 | 	status, err = pcall(readFrame)
241 | 
242 | 	if (not status) then
243 | 		if (not loop) then
244 | 			break
245 | 		end
246 | 
247 | 		reader:reset()
248 | 		reader:readNumber(5)
249 | 		reader:readNumber(10)
250 | 		reader:readNumber(9)
251 | 
252 | 		frame = {}
253 | 		for i=1, height do
254 | 			frame[i] = {}
255 | 			fri = frame[i]
256 | 			for j=1, width do
257 | 				fri[j] = false
258 | 			end
259 | 		end
260 | 
261 | 		hs.buffer = frame
262 | 
263 | 		if (wc) then
264 | 			for i = 1, #wc.instances do
265 | 				wc.instances[i].playing = true
266 | 				wc.instances[i].tick = 1
267 | 				
268 | 			end
269 | 		end
270 | 
271 | 	else
272 | 		hs:draw()
273 | 
274 | 		if (wc) then
275 | 			pcall(wc.update, wc, 0.05)
276 | 			
277 | 		end
278 | 		
279 | 	end
280 | 
281 | 	sleep(0.05 * sleep_ticks)
282 | 	
283 | end


--------------------------------------------------------------------------------
/encode/encoder.py:
--------------------------------------------------------------------------------
  1 | import sys
  2 | import getopt
  3 | import time
  4 | import importlib
  5 | import math
  6 | 
  7 | import numpy as np
  8 | 
  9 | from moviepy.video.io.VideoFileClip import VideoFileClip
 10 | from PIL import Image
 11 | 
 12 | 
 13 | def usage():
 14 | 	print("""Usage: encoder <options>
 15 | Options available:
 16 | -c/--codec <codec name>: The specific codec to use, required.
 17 | -i/--input <path>: Video file to be encoded.
 18 | -o/--output <path>: The output file.
 19 | -d/--duration <seconds>: The amount of time of the video to encode.
 20 | -t/--time <seconds>: The time to start encoding the video from.
 21 | -s/--sleepticks <ticks>: The amount of time to sleep in between frames, must be a positive integer.
 22 | -?/--help: A small guide and explanation.""")
 23 | 
 24 | def help():
 25 | 	usage()
 26 | 	print("""\nCall using "-c <codec name> -i <path>" to encode a file using the given codec.
 27 | 
 28 | You can specify the output file with -o <path>.
 29 | 
 30 | The method used to encode the final file depends on the codec used.
 31 | Details about each encoder can be obtained by calling "encoder -c <codec name>" without any other option.
 32 | """)
 33 | 
 34 | class Bits8:
 35 | 	""" Class to control writing bits individually to a file, equivalent to a byte.
 36 | 	"""
 37 | 
 38 | 	def __init__(self):
 39 | 		self._bits = 0
 40 | 		self._value = 0
 41 | 		
 42 | 	def addBit(self, bit):
 43 | 		""" Adds a single bit to the byte, unless it's already complete.
 44 | 
 45 | 			Returns true if the byte is still incomplete.
 46 | 		"""
 47 | 
 48 | 		if (self._bits >= 8):
 49 | 			return False
 50 | 
 51 | 		self._bits += 1
 52 | 		self._value *= 2
 53 | 		if (bit):
 54 | 			self._value += 1
 55 | 
 56 | 		return self._bits < 8
 57 | 
 58 | 	def reset(self):
 59 | 		""" Clears the bits and returns a byte number representing it's past value.
 60 | 		"""
 61 | 		
 62 | 		r = self._value
 63 | 
 64 | 		self._bits = 0
 65 | 		self._value = 0
 66 | 
 67 | 		return r
 68 | 
 69 | 	def complete(self):
 70 | 		""" Adds new bits with value 0 until the group is complete.
 71 | 		"""
 72 | 
 73 | 		while (self.addBit(False)):
 74 | 			pass
 75 | 
 76 | class OutBytes:
 77 | 	""" List of bytes to be written to a file.
 78 | 	"""
 79 | 
 80 | 	output = []
 81 | 	currentB = Bits8()
 82 | 	debug = False
 83 | 
 84 | 	_bits = (1 << np.arange(16))[::-1]
 85 | 
 86 | 	def addBit(self, bit):
 87 | 		""" Adds a single bit.
 88 | 		"""
 89 | 		
 90 | 		if (self.debug):
 91 | 			print(1 if bit else 0, end='')
 92 | 
 93 | 		if (not self.currentB.addBit(bit)):
 94 | 			self.output.append(self.currentB.reset())
 95 | 
 96 | 	def addBits(self, bits):
 97 | 		""" Adds a sequence of bits.
 98 | 		"""
 99 | 	
100 | 		for b in bits:
101 | 			self.addBit(b)
102 | 
103 | 	def addNumber(self, number, n):
104 | 		""" Converts a number into a sequence of N bits, then adds it to the file.
105 | 
106 | 		More than 16 bits per number will not be accepted, it's a hard limit.
107 | 
108 | 		If the number contains more bits, they will be ignored.
109 | 		"""
110 | 		if (n > 0 and n <= 16):
111 | 			self.addBits((self._bits[16-n:] & number) != 0)
112 | 
113 | 	def close(self):
114 | 		""" Completes current byte and adds it to the output.
115 | 		"""
116 | 
117 | 		self.currentB.complete()
118 | 		self.output.append(self.currentB.reset())
119 | 
120 | 
121 | if __name__ == "__main__":
122 | 	codec = ""
123 | 	video_input = ""
124 | 	image_input = ""
125 | 	video_output = "converted_file.qtv"
126 | 	duration = 100000
127 | 	initial_time = 0
128 | 	sleep_ticks = 1
129 | 	lossiness = 0
130 | 
131 | 	try:
132 | 		opts, args = getopt.getopt(sys.argv[1:], "c:i:o:d:t:s:l:?", ["codec=", "input=", "image=", "output=", "duration=", "time=", "sleepticks=", "lossiness=", "help"])
133 | 	except getopt.GetoptError:
134 | 		usage()
135 | 		sys.exit(2)
136 | 
137 | 	try:
138 | 		for opt, arg in opts:
139 | 			if opt in ("-?", "--help"):
140 | 				help()
141 | 				sys.exit()
142 | 			elif opt in ("-c", "--codec"):
143 | 				codec = arg
144 | 			elif opt in ("-i", "--input"):
145 | 				video_input = arg
146 | 			elif opt == "--image":
147 | 				image_input = arg
148 | 			elif opt in ("-o", "--output"):
149 | 				video_output = arg
150 | 			elif opt in ("-d", "--duration"):
151 | 				duration = float(arg)
152 | 			elif opt in ("-t", "--time"):
153 | 				initial_time = float(arg)
154 | 			elif opt in ("-s", "--sleepticks"):
155 | 				sleep_ticks = int(arg)
156 | 			elif opt in ("-l", "--lossiness"):
157 | 				lossiness = float(arg)
158 | 			else:
159 | 				usage()
160 | 				sys.exit(2)
161 | 	except:
162 | 		usage()
163 | 		sys.exit(2)
164 | 	
165 | 	# Input validation
166 | 	if (codec == ""):
167 | 		print("You must specify a codec.")
168 | 		usage()
169 | 		sys.exit(2)
170 | 
171 | 	codec = importlib.import_module(codec)
172 | 
173 | 	if (video_input == "" and image_input == ""):
174 | 		codec.help()
175 | 		sys.exit(2)
176 | 
177 | 	if (sleep_ticks < 1):
178 | 		sleep_ticks = 1
179 | 	elif (sleep_ticks > 16):
180 | 		sleep_ticks = 16
181 | 
182 | 	if (initial_time < 0):
183 | 		initial_time = 0
184 | 	
185 | 	if (duration < 0):
186 | 		duration = 0
187 | 
188 | 	if (lossiness < 0):
189 | 		lossiness = 0
190 | 
191 | 
192 | 	out_bytes = OutBytes()
193 | 
194 | 
195 | 	
196 | 	# For debugging purposes, encodes a single image, also prints all bits as 1's and 0's on the console/terminal.
197 | 	# Could break at any second with changes to other parts of the code, don't recommend relying on it for anything ever.
198 | 	# That's also why it's not documented anywhere else.
199 | 	# Also doesn't work well for .jpg so use .png instead.
200 | 	if (image_input != ""):
201 | 		print("Compressing image...")
202 | 		out_bytes.debug = True
203 | 		start_time = time.time()
204 | 
205 | 		im = Image.open(image_input)
206 | 		w, h = im.size
207 | 
208 | 		frame = []
209 | 
210 | 		raw_data = list(im.getdata())
211 | 		for y in range(h):
212 | 			frame.append(raw_data[w*y:w*(y+1)])
213 | 
214 | 		encoder = codec.Encoder(w, h, out_bytes)
215 | 		repeats = 1
216 | 		for i in range(repeats):
217 | 			encoder.encode_frame(frame)
218 | 
219 | 		out_bytes.close()
220 | 
221 | 		tot = len(out_bytes.output)
222 | 		ori = math.ceil(w*h/8) * repeats
223 | 
224 | 		print(f"\nEncoded image {repeats} times.")
225 | 		print(f"Total bytes used: {tot}\nAprox. uncompressed size: {ori}")
226 | 		print("Compression ratio: %.2f%%" % (tot / ori * 100))
227 | 		print("Time elapsed: %.2fs\n" % (time.time() - start_time))
228 | 
229 | 		sys.exit(2)
230 | 
231 | 
232 | 
233 | 
234 | 	# Preparing to encode.
235 | 
236 | 	clip = VideoFileClip(video_input)
237 | 
238 | 	t = initial_time
239 | 
240 | 	w, h = clip.size
241 | 	out_bytes.addNumber(sleep_ticks-1, 5)
242 | 	out_bytes.addNumber(w-1, 10)
243 | 	out_bytes.addNumber(h-1, 9)
244 | 
245 | 
246 | 	print(f"\nStarting encoding for '{video_input}' with the following settings:\nSleep ticks: {sleep_ticks}")
247 | 	print(f"Video duration: {min(duration, clip.duration)}s\nInitial time: {t}s\n")
248 | 
249 | 	# Encoding loop.
250 | 
251 | 	encoder = codec.Encoder(w, h, out_bytes)
252 | 
253 | 	start_time = time.time()
254 | 	g = 0
255 | 	while (clip.is_playing(t) and t < initial_time + duration):
256 | 		frame = clip.get_frame(t)
257 | 
258 | 		encoder.encode_frame(frame)
259 | 		
260 | 		if (g % 20 == 0):
261 | 			tot = len(out_bytes.output)
262 | 			ori = max(math.ceil(w*h/8 * (t-initial_time)*20/sleep_ticks), 1)
263 | 			print("Encoding progress: %.2f%% Aprox. time remaining: %.2fs Current size: %.2fkB Compression ratio: %.2f%%    " % ((t - initial_time) / min(duration, clip.duration) * 100, (time.time() - start_time) / max((t - initial_time) / min(duration, clip.duration), 0.00001) - (time.time() - start_time), len(out_bytes.output) / 1000, tot / ori * 100), end="\r")
264 | 		
265 | 		t += sleep_ticks/20
266 | 		g += 1
267 | 
268 | 
269 | 	tot = len(out_bytes.output)
270 | 	ori = math.ceil(w*h/8 * min(duration, clip.duration)*20/sleep_ticks)
271 | 	print("\nTotal bytes used: %.2fkB\nAprox. uncompressed size: %.2fkB" % (tot / 1000, ori / 1000))
272 | 	print("Compression ratio: %.2f%%" % (tot / ori * 100))
273 | 	print("Time elapsed: %.2fs\n" % (time.time() - start_time))
274 | 
275 | 
276 | 	out_bytes.close()
277 | 	with open(video_output, "wb") as f:
278 | 		f.write(bytes(out_bytes.output))


--------------------------------------------------------------------------------
/encode/quadtree.py:
--------------------------------------------------------------------------------
  1 | import math
  2 | import sys
  3 | 
  4 | import numpy as np
  5 | 
  6 | def help():
  7 | 	print("""\nQuadTree (Binary)
  8 | 
  9 | Quadtree structure based encoder, recursively splits the screen in 4 parts until only parts that are a solid color are visible.
 10 | It doesn't store full images, it would be wasteful to do so especially since the video only has two colors anyways.
 11 | It'll store only the pixels that changed color, represented as white pixels.
 12 | It also only stores pixels in an area that actually changed, the area itself is recorded at the start of the frame.
 13 | 
 14 | Expect a compression ratio of about 30%% of the original size for medium to small files.
 15 | The bigger the file, the better this ratio will be.
 16 | Bad Apple at the highest resolution CC can play almost reaches 10%.
 17 | 
 18 | """)
 19 | 
 20 | class Encoder:
 21 | 	def __init__(self, w, h, out_bytes, lossiness=0):
 22 | 		self.width = w
 23 | 		self.height = h
 24 | 
 25 | 		# To save on storage, we figure out how many bits we need to store the width and height values.
 26 | 		# This is not super meaningful even for a big file, but we're writing data bit by bit anyways, so might as well.
 27 | 		self._width_bits = 0
 28 | 		self._height_bits = 0
 29 | 
 30 | 		while (2 ** self._width_bits <= self.width):
 31 | 			self._width_bits += 1
 32 | 
 33 | 		while (2 ** self._height_bits <= self.height):
 34 | 			self._height_bits += 1
 35 | 
 36 | 		# There's a hard limit on how big numbers can be, mostly because there shouldn't be a situation where numbers this big are required ever.
 37 | 		if (self._width_bits > 16 or self._height_bits > 16):
 38 | 			print("Video size too big! How long do you think that'd take to encode even if it worked anyways?")
 39 | 			sys.exit()
 40 | 
 41 | 		self.out_bytes = out_bytes
 42 | 
 43 | 		self.diff = None
 44 | 
 45 | 		self.last = np.zeros((self.height, self.width))
 46 | 
 47 | 	def getColor(self, x, y, w, h, data=None):
 48 | 		""" Checks if the region is uniform, and if it is, the color.
 49 | 		"""
 50 | 
 51 | 		if (data is None):
 52 | 			data = self.diff
 53 | 
 54 | 		# Gets a slice of the data with the correct coordinates.
 55 | 		s = data[y:y+h, x:x+w]
 56 | 
 57 | 		# Generates an array of bools where each stores if that index in the slice is equal to the first index, then checks if all of those are True.
 58 | 		# Simply put, will be true only if all elements are the same.
 59 | 		u = np.all(s == s[0, 0])
 60 | 
 61 | 		# If you're wondering why this needs to be a condition, it doesn't.
 62 | 		# A previous version of the code used it and I left it like that since it doesn't change the result.
 63 | 		return u, True if not u else s[0, 0]
 64 | 
 65 | 	def split(self, x, y, w, h):
 66 | 		""" Splits a region into 4 new regions.
 67 | 		
 68 | 			Returns a list of 4 tuples, each with 4 values for position and size.
 69 | 		"""
 70 | 		l = []
 71 | 
 72 | 		cw = math.ceil(w/2)
 73 | 		ch = math.ceil(h/2)
 74 | 		fw = math.floor(w/2)
 75 | 		fh = math.floor(h/2)
 76 | 		
 77 | 		# NW
 78 | 		l.append((x, y, cw, ch))
 79 | 		# NE
 80 | 		l.append((x + cw, y, fw, ch))
 81 | 		
 82 | 		# SW
 83 | 		l.append((x, y + ch, cw, fh))
 84 | 		# SE
 85 | 		l.append((x + cw, y + ch, fw, fh))
 86 | 
 87 | 		return l
 88 | 
 89 | 	def encode_quad(self, x, y, w, h, data=None):
 90 | 		""" Encodes a region recursively splitting to capture detail.
 91 | 		"""
 92 | 
 93 | 		# If the region is empty, the encoder just skips it since the decoder also has this information.
 94 | 		if (w*h == 0):
 95 | 			return
 96 | 
 97 | 		if (data is None):
 98 | 			data = self.diff
 99 | 		
100 | 		# Check if the region has an uniform color.
101 | 		u, c = self.getColor(x, y, w, h)
102 | 		if (u):
103 | 			# It is uniform, so we write 0 to say it's a leaf node and the next bit is the color of this region.
104 | 			self.out_bytes.addBits([False, c])
105 | 		else:
106 | 			# The color is not uniform, so we need to split into 4 quads.
107 | 			self.out_bytes.addBit(True)
108 | 
109 | 			l = self.split(x, y, w, h)
110 | 
111 | 			for q in l:
112 | 				q = self.encode_quad(q[0], q[1], q[2], q[3], data)
113 | 
114 | 
115 | 	def encode_frame(self, next_frame):
116 | 		""" Encodes a frame.
117 | 		
118 | 			Handles data so that it's only two colors, represented as either a 0 or a 1.
119 | 		"""
120 | 
121 | 		# Makes all pixels either a 0 or a 1.
122 | 		data = np.rint(np.divide(np.average(next_frame, axis=2), 255))
123 | 
124 | 		# Difference between pixels from the previous frame, as a boolean array.
125 | 		# This is the image the encoder actually writes to the file.
126 | 		self.diff = np.not_equal(data, self.last)
127 | 
128 | 		
129 | 		# Figure out the bounding box of all the different (white) pixels.
130 | 		rows = np.any(self.diff, axis=1)
131 | 		cols = np.any(self.diff, axis=0)
132 | 		if (np.any(rows)):
133 | 			y, yh = np.nonzero(rows)[0][[0, -1]]
134 | 			x, xw = np.nonzero(cols)[0][[0, -1]]
135 | 		else:
136 | 			# It has to be -1 since we add one later and we want zero to represent the frame not being changed at all.
137 | 			y, yh = 0, -1
138 | 			x, xw = 0, -1
139 | 
140 | 		# Write the starting position of the box.
141 | 		self.out_bytes.addNumber(x, self._width_bits)
142 | 		self.out_bytes.addNumber(y, self._height_bits)
143 | 
144 | 		w = xw - x + 1
145 | 		h = yh - y + 1
146 | 
147 | 		w_bits = 0
148 | 		h_bits = 0
149 | 
150 | 		while (2 ** w_bits <= self.width - x):
151 | 			w_bits += 1
152 | 		while (2 ** h_bits <= self.height - y):
153 | 			h_bits += 1
154 | 
155 | 		# Write the width of the box.
156 | 		self.out_bytes.addNumber(w, w_bits)
157 | 
158 | 		# If width is 0 we know the frame didn't change, so there's no reason to write the height or encode anything.
159 | 		if (w != 0):
160 | 			# Write the height of the box.
161 | 			self.out_bytes.addNumber(h, h_bits)
162 | 
163 | 			# Encode the quad, we already know it splits so we tell it.
164 | 			self.encode_quad(x, y, w, h, self.diff)
165 | 
166 | 
167 | 		self.last = data


--------------------------------------------------------------------------------
/sample/badapple.nbs:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Axisok/qtccv/6c866ab99da887afaf9428856d05b3f31b0af86d/sample/badapple.nbs


--------------------------------------------------------------------------------
/sample/badapple.qtv:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Axisok/qtccv/6c866ab99da887afaf9428856d05b3f31b0af86d/sample/badapple.qtv


--------------------------------------------------------------------------------
/sample/playbadapple.lua:
--------------------------------------------------------------------------------
 1 | -- Program to download and play bad apple on loop.
 2 | 
 3 | local function getFile(name, lname)
 4 | 	local r = http.get("https://raw.githubusercontent.com/Axisok/qtccv/master/" .. name, nil, true)
 5 | 	local f = fs.open(lname, "wb")
 6 | 	f.write(r.readAll())
 7 | 	f.close()
 8 | 	
 9 | end
10 | 
11 | if (not fs.exists("badapple.qtv")) then
12 | 	getFile("decode/apis/bitreader.lua", "apis/bitreader.lua")
13 | 	getFile("decode/apis/hexscreen.lua", "apis/hexscreen.lua")
14 | 	getFile("decode/apis/wave.lua", "apis/wave.lua")
15 | 	getFile("decode/videoplayer.lua", "videoplayer.lua")
16 | 	getFile("sample/badapple.nbs", "badapple.nbs")
17 | 	getFile("sample/badapple.qtv", "badapple.qtv")
18 | 	
19 | end
20 | 
21 | shell.run("videoplayer", "badapple")


--------------------------------------------------------------------------------