mayhem-firmware/firmware/application/ui_about.cpp

/*
 * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
 * Copyright (C) 2016 Furrtek
 *
 * This file is part of PortaPack.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street,
 * Boston, MA 02110-1301, USA.
 */

#include <ch.h>

#include "demofont.hpp"
#include "ymdata.hpp"

#include "cpld_update.hpp"
#include "portapack.hpp"
#include "audio.hpp"
#include "event_m0.hpp"
#include "baseband_api.hpp"

#include "ui_about.hpp"
#include "touch.hpp"
#include "sine_table.hpp"

#include "portapack_shared_memory.hpp"
#include "portapack_persistent_memory.hpp"
#include "lpc43xx_cpp.hpp"

#include <math.h>
#include <cstring>

using namespace lpc43xx;
using namespace portapack;

namespace ui {
	
void AboutView::on_show() {
	about_radio_config.tuning_frequency = 92200000;		// 92.2MHz, change !
	radio::enable(about_radio_config);
	
	//audio::headphone::set_volume(volume_t::decibel(0 - 99) + audio::headphone::volume_range().max);
}

void AboutView::render_video() {
	uint8_t p, r, luma, chroma, cy;
	ui::Color cc;
	char ch;
	float s;
	
	// Send framebuffer to LCD. Gotta go fast !
	display.render_box({30, 112}, {180, 72}, framebuffer);

	// Clear framebuffer to black
	memset(framebuffer, 0, 180 * 72 * sizeof(ui::Color));

	// Drum hit palette animation
	if (drum > 1) drum--;

	// Render copper bars from Y buffer
	for (p = 0; p < 72; p++) {
		luma = copperbuffer[p] & 0x0F;		// 0 is transparent
		if (luma) {
			chroma = copperbuffer[p]>>4;
			cc = ui::Color(std::min((coppercolor[chroma][0]/luma)*drum,255), std::min((coppercolor[chroma][1]/luma)*drum,255), std::min((coppercolor[chroma][2]/luma)*drum,255));
			for (r = 0; r < 180; r++)
				framebuffer[(p*180)+r] = cc;
		}
	}
	
	// Scroll in/out state machine
	if (anim_state == 0) {
		// Scroll in
		if (ofy < 8) {
			ofy++;
			anim_state = 0;
		} else {
			anim_state = 1;
		}
		if (ofx < (int16_t)(180 - (strlen(credits[credits_index].name) * 16) - 8)) {
			ofx += 8;
			anim_state = 0;
		}
	} else if (anim_state == 1) {
		// Just wait
		if (credits_timer == (30*3)) {
			credits_timer = 0;
			anim_state = 2;
		} else {
			credits_timer++;
		}
	} else {
		// Scroll out
		if (credits[credits_index].change == true) {
			if (ofy > -24) {
				ofy--;
				anim_state = 2;
			} else {
				anim_state = 0;
			}
		} else {
			anim_state = 0;
		}
		if (ofx < 180) {
			ofx += 8;
			anim_state = 2;
		}
	
		// Switch to next text
		if (anim_state == 0) {
			if (credits_index == 7)
				credits_index = 0;
			else
				credits_index++;
			ofx = -(strlen(credits[credits_index].name) * 16) - 16;
		}
	}
	
	// Sine text ("role")
	p = 0;
	while ((ch = credits[credits_index].role[p])) {
		draw_demoglyph({(ui::Coord)(8+(p*16)), (ui::Coord)(ofy+(sine_table_f32[((p*16)+(phase>>5))&0xFF] * 8))}, ch, paletteA);
		p++;
	}
		
	// Scroll text (name)
	p = 0;
	while ((ch = credits[credits_index].name[p])) {
		draw_demoglyph({(ui::Coord)(ofx+(p*16)), 56}, ch, paletteB);
		p++;
	}
	
	// Clear bars Y buffer
	memset(copperbuffer, 0, 72);
		
	// Render bars to Y buffer
	for (p = 0; p < 5; p++) {
		cy = copperbars[p];
		for (r = 0; r < 16; r++)
			copperbuffer[cy+r] = copperluma[r] + (p<<4);
	}
	
	// Animate bars positions
	for (p = 0; p < 5; p++) {
	  	s = sine_table_f32[((p*32)+(phase/24))&0xFF];
		s += sine_table_f32[((p*16)+(phase/35))&0xFF];
		copperbars[p] = 28+(uint8_t)(s * 14);
	}
	
	phase += 128;
}

void AboutView::draw_demoglyph(ui::Point p, char ch, ui::Color * pal) {
	uint8_t x, y, c, cl, cr;
	uint16_t che;
	int16_t lbx, il;

	// Map ASCII to font bitmap
	if ((ch >= 32) || (ch < 96))
		che = char_map[ch-32];
	else
		che = 0xFF;
		
	if (che < 0xFF) {
		che = (che * 128) + 48;		// Start in bitmap

		il = (180 * p.y) + p.x;		// Start il framebuffer
		
		for (y = 0; y < 16; y++) {
			if (p.y + y >= 72) break;					// Over bottom of framebuffer, abort
			if (p.y + y >= 0) {
				for (x = 0; x < 8; x++) {
					c = demofont_bin[x+(y*8)+che];		// Split byte in 2 4BPP pixels
					cl = c >> 4;
					cr = c & 0x0F;
					lbx = p.x + (x*2);
					if (cl && (lbx < 180) && (lbx >= 0)) framebuffer[il] = pal[cl];
					lbx++;
					il++;
					if (cr && (lbx < 180) && (lbx >= 0)) framebuffer[il] = pal[cr];
					il++;
				}
				il += 180-16;
			} else {
				il += 180;
			}
		}
	}
}

void AboutView::render_audio() {
	uint8_t i, ymdata;
	uint16_t ym_render_cnt;
	
	// This is heavily inspired by MAME's ay8910.cpp and the YM2149's datasheet
	
	// Render 1024 music samples
	for (ym_render_cnt = 0; ym_render_cnt < 1024; ym_render_cnt++) {

		// Taken at 48000/960 = 50Hz
		if (ym_sample_cnt == 0) {
			// "Decompress" on the fly and update YM registers
			for (i = 0; i < 14; i++) {
				if (!ym_regs[i].cnt) {
					// New run
					ymdata = ymdata_bin[ym_regs[i].ptr++];
					ym_regs[i].cnt = ymdata & 0x7F;
					if (ymdata & 0x80) {
						ym_regs[i].same = true;
						ym_regs[i].value = ymdata_bin[ym_regs[i].ptr++];
					} else {
						ym_regs[i].same = false;
					}
					// Detect drum on channel B
					if (i == 3)
						if (ym_regs[3].value > 2) drum = 4;
				}
				if (ym_regs[i].same == false) {
					ym_regs[i].value = ymdata_bin[ym_regs[i].ptr++];
					if (i == 13) {
						// Update envelope attributes
						ym_env_att = (ym_regs[13].value & 4) ? 0x1F : 0x00;
						if (!(ym_regs[13].value & 8)) {
							ym_env_hold = 1;
							ym_env_alt = ym_env_att;
						} else {
							ym_env_hold = ym_regs[13].value & 1;
							ym_env_alt = ym_regs[13].value & 2;
						}
						// Reset envelope counter
						ym_env_step = 0x1F;
						ym_env_holding = 0;
						ym_env_vol = (ym_env_step ^ ym_env_att);		
					}
				}
				ym_regs[i].cnt--;
			}
			ym_frame++;
		}
		
		// Square wave oscillators
		// 2457600/16/48000 = 3.2, but 4 sounds better than 3...
		for (i = 0; i < 3; i++) {
			ym_osc_cnt[i] += 4;
			if (ym_osc_cnt[i] >= (ym_regs[i*2].value | ((ym_regs[(i*2)+1].value & 0x0f) << 8))) {
				ym_osc_cnt[i] = 0;
				ym_osc_out[i] ^= 1;
			}
		}
		
		// Noise generator
		ym_noise_cnt += 4;
		if (ym_noise_cnt >= ((ym_regs[6].value & 0x1F) * 2)) {
			ym_noise_cnt = 0;
			ym_rng ^= (((ym_rng & 1) ^ ((ym_rng >> 3) & 1)) << 17);
			ym_rng >>= 1;
		}
		
		// Mix tones and noise
		for (i = 0; i < 3; i++)
			ym_ch[i] = (ym_osc_out[i] | ((ym_regs[7].value >> i) & 1)) & ((ym_rng & 1) | ((ym_regs[7].value >> (i + 3)) & 1));
			
		// Envelope generator
		if (!ym_env_holding) {
			ym_env_cnt += 8;
			if (ym_env_cnt >= (ym_regs[11].value | (ym_regs[12].value<<8))) {
				ym_env_cnt = 0;
				ym_env_step--;
				if (ym_env_step < 0) {
					if (ym_env_hold) {
						if (ym_env_alt)
							ym_env_att ^= 0x1F;
						ym_env_holding = 1;
						ym_env_step = 0;
					} else {
						if (ym_env_alt && (ym_env_step & 0x20))
							ym_env_att ^= 0x1F;
						ym_env_step &= 0x1F;
					}
				}
			}
		}
		ym_env_vol = (ym_env_step ^ ym_env_att);

		ym_out = 0;
		for (i = 0; i < 3; i++) {
			if (ym_regs[i + 8].value & 0x10) {
				// Envelope mode
				ym_out += (ym_ch[i] ? ym_env_vol : 0);
			} else {
				// Fixed mode
				ym_out += (ym_ch[i] ? (ym_regs[i + 8].value & 0x0F) : 0);
			}
		}
	
		ym_buffer[ym_render_cnt] = (ym_out * 2) - 93;

		if (ym_sample_cnt < 960) {
			ym_sample_cnt++;
		} else {
			ym_sample_cnt = 0;
		}
		
		// Loop
		if (ym_frame == ym_frames) ym_init();
	}
}

void AboutView::update() {
	if (framebuffer) {
		// Update 1 out of 2 frames, 60Hz is very laggy
		if (refresh_cnt & 1) render_video();
		refresh_cnt++;
	}
	
	// Slowly increase volume to avoid jumpscare
	if (headphone_vol < (70<<2)) {
		audio::headphone::set_volume(volume_t::decibel((headphone_vol/4) - 99) + audio::headphone::volume_range().max);
		headphone_vol++;
	}
}

void AboutView::ym_init() {
	uint8_t reg;
	
	for (reg = 0; reg < 14; reg++) {
		ym_regs[reg].cnt = 0;
		// Pick up start pointers for each YM registers RLE blocks
		ym_regs[reg].ptr = ((uint16_t)(ymdata_bin[(reg*2)+3])<<8) + ymdata_bin[(reg*2)+2];
		ym_regs[reg].same = false;	// Useless ?
		ym_regs[reg].value = 0;		// Useless ?
	}
	
	ym_frame = 0;
}

AboutView::AboutView(
	NavigationView& nav
)
{
	uint8_t p, c;
	
	add_children({ {
		&text_title,
		&text_firmware,
		&text_cpld_hackrf,
		&text_cpld_hackrf_status,
		&button_ok,
	} });
	
	if( cpld_hackrf_verify_eeprom() ) {
		text_cpld_hackrf_status.set(" OK");
	} else {
		text_cpld_hackrf_status.set("BAD");
	}
	
	// Politely ask for about 26kB
	framebuffer = (ui::Color *)chHeapAlloc(0x0, 180 * 72 * sizeof(ui::Color));
	
	if (framebuffer) {
		memset(framebuffer, 0, 180 * 72 * sizeof(ui::Color));
		
		// Copy original font palette
		c = 0;
		for (p = 0; p < 48; p+=3)
			paletteA[c++] = ui::Color(demofont_bin[p], demofont_bin[p+1], demofont_bin[p+2]);
		
		// Increase red in another one
		c = 0;
		for (p = 0; p < 48; p+=3)
			paletteB[c++] = ui::Color(std::min(demofont_bin[p]+64, 255), demofont_bin[p+1], demofont_bin[p+2]);
	}

	// Init YM synth
	ym_frames = ((uint16_t)(ymdata_bin[1])<<8) + ymdata_bin[0];
	ym_init();

	button_ok.on_select = [this,&nav](Button&){
		if (framebuffer) chHeapFree(framebuffer);	// Do NOT forget this
		nav.pop();
	};
}

AboutView::~AboutView() {
	radio::disable();
}

void AboutView::focus() {
	button_ok.focus();
}

} /* namespace ui */