Hello everyone! Several years ago, I wanted to make my own Open Source game console that can compete with modern consoles of today. Well, now I’m ready to start building it. Of course, back then I thought a powerful console would be a piece of cake, but now I know better, so this little guy is going to be around the GameCube in performance. But anyway, the reason I mention it here is because 1) to spread the word, and 2) I need all of your input on this. You see, I want this thing to support Java, and on top of that be capable of running JME. But before I go into what I need to do that, here is what the Dingo Console will have:
- 512 MB DDR 400 RAM (capable of a bandwidth of 12.8 GB/s)
- Pentium III CPU running at 800MHz
- 160GB Sata HDD
- CD drive
- SD card reader
- Bluetooth (for wireless controllers only)
- 4 USB ports (also for controllers)
- Wifi
- Custom programmed stereo DSP capable of 16 channels at once, and a lot of cool features (actually, it’s some form of ARM microcontroller programmed to be a DSP)
- Custom designed GPU and Northbridge programmed onto a FPGA
- Oh, and did I mention EVERYTHING will be open source, including the GPU? That means no more binary blobs!
- Documentation on how to hack this little guy. As in, you will be allowed (and encouraged) to modify the bejeezus out of this thing. Well, except for maybe the GPU/NB because you could easily destroy something if you don’t know what you’re doing.
- Custom made OS and drivers (as if I have a choice)
Jeez, that list formatting was a lot more difficult than I remember it being… Anyway, I want to put a lot of emphasis on two things: The DSP and the GPU/NB. Let’s start with the DSP.
What I want the DSP to do is take in sound data (obviously), and be able to apply lots of cool effects and enhancements to it. It will have 16 channels, and will output in stereo. For input data, I have come up with my own audio compression format that only stores the point of inflections in the sound wave (points where the waveform change direction). I am getting close to getting this format to work in Java, but there are still a few (major) bugs to work out. So until then, it’ll also be able to support WAV formats. Some effects the DSP will be able to do include echo, fade in/out, overdrive (which is like intentional clipping), audio blending, tone shifting (useful for simulating instruments), and a bunch of other stuff that I can’t remember right now.
The DSP will only be able to take in audio at a 48KHz sample rate at 24 bits, but it’ll have two features called Over Sampling Anti-Aliasing (OSAA) and Bit Depth Anti-Aliasing (BDAA). What OSAA does is while the DSP calculates the output waveform, it will attempt to estimate the levels between the two audio samples. This way, the output waveform is smoother and takes less of a blocky formation. OSAA will have three modes: HD (96KHz), UHD (192KHz), and XHD (384KHz).
BDAA is a feature that increases the bit depth from 24 bits to 32 or 64 bits. This leads to more accurate calculations, and results in a smoother waveform. Combine BDAA 64 with XHD OSAA, and you have extremely smooth sound waves (and an overloaded DSP), possibly much more than humans can notice due to the Nyquist theory (I think that’s what it’s called).
Now on to the GPU and Northbridge. I gave it a model number, the D832M. The GPU portion will contain 8 32bit rendering cores, each running at a max frequency of 400MHz, without overclocking. They can set their frequencies to what they need, at a minimum of 100MHz. Each core will have 256KB of shader code cache, and they will all share an 8MB texture cache. The GPU will split the RAM with the rest of the system, although this split isn’t concrete. The game developer has the power to choose the RAM split, in fact the entire memory map, due to the optimized Northbridge architecture. More on that later. The GPU will have two video modes PAL and NTSC, each with two resolutions, 640 x 480 and 720 x 480. Unlike other console GPUs, this one will support shader scripting, although it won’t be OpenGL, but instead my own made up language.
The Northbridge took a long time to get a good design. At first I was only going to do a single internal bus connecting everything, with a fixed memory map. But then that wouldn’t be efficient nor flexible. So in the end, the NB will have a pipelined architecture, and is able to split up bus activity. For example, if the CPU wanted to upload audio data via SPI to the DSP, but the GPU is in the middle of a RAM cycle, then the old design would force the CPU to wait until the GPU finished. But with my new architecture, the CPU won’t need to wait. The new design will allow more than one bus combination to be active at a time, but if a bus port is busy, then the other devices will have to wait. Ie, the CPU and GPU can’t both use the RAM at the same time. Yet. I do want to add support for splitting of the RAM bus itself, so the GPU and CPU can both use it at the same time. But that’s a whole 'nother beast.
Now onto the JME part. My OS will eventually be able to run Java, and then JME. The only issue I have is compatibility. Since this console doesn’t have OpenGL support, I’d have to modify JME to use the what this console has. And then I’d have to port the native libraries to work with this system. So my question is, how hard is it to do that? And is JME even runnable with these specs? It would be really cool to see JME run on this thing, that is, when I can come up with $600 and the time to build and program it. But hey, when I get this thing running, I’d be the first High Schooler to make something like this (as far as I know). So I want your input on this, what do you guys think? And so you don’t waste your time, I already know this is going to be difficult. So you don’t need to tell me.
Hackaday page here (slightly outdated): The Dingo Console | Hackaday.io