Predator99 wrote on 2020-07-01, 19:09:

I think I also need to revise my cabling. For EGA it makes sense to connect it in the order r, g, b, R, G, B, HSYNC, VSYNC With […]
Show full quote

I think I also need to revise my cabling. For EGA it makes sense to connect it in the order
r, g, b, R, G, B, HSYNC, VSYNC
With this you extract the color information in a very easy way from each byte read without performing any binary conversion in the program:
https://upload.wikimedia.org/wikipedia/common … 2/EGA_Table.svg

Hi BreakPoint,

when setting up you cable, please use the following wiring:

Analyzer Channel - Card connector
Channel 1 - 5 B
Channel 2 - 4 G
Channel 3 - 3 R
Channel 4 - 6 Gint
Channel 5 - 2 Rint
Channel 6 - 7 Bint
Channel 7 - 8 Hsync
Channel 8 - 9 Vsync
I dont understand the logic behind it and it took me some time to get behind this....but by doing so you get the EGA-color number from the captured byte simply by masking out the HSYNC/VSYNC channel (CH7/CH8):
color = (captured_value AND VAL("&B00111111")).
So for me the order is somehow reversed but it works. Should be the same for other programming languages 😉 Saves a lot of CPU-time and programming effort...

Thanks!

...EDIT: Noticed minor mistake in cabling, corrected!

You can easily calculate color component by multiplying hexadecimal 0x55 by 2 bit EGA color component. So EGA 00 is 0. EGA 01 is 0x55, EGA 10 = 0xAA, EGA 11 = 0xFF. So in general cable wiring does not really matter. You can get color by using simple bit operations.
I spent some time with sigrok. It looks like there is not much documentation on API. I'll try to do some reverse-engineering of PulseView and CGI when i have some free time. But actually your results are good proof of concept.

BreakPoint wrote on 2020-07-04, 18:01:

You can easily calculate color component by multiplying hexadecimal 0x55 by 2 bit EGA color component. So EGA 00 is 0. EGA 01 is 0x55, EGA 10 = 0xAA, EGA 11 = 0xFF. So in general cable wiring does not really matter. You can get color by using simple bit operations.

Thats true, but you dont need this effort when the bits are directly in the correct order.

BreakPoint wrote on 2020-07-04, 18:01:

I spent some time with sigrok. It looks like there is not much documentation on API. I'll try to do some reverse-engineering of PulseView and CGI when i have some free time. But actually your results are good proof of concept.

Did you see this?
https://sigrok.org/wiki/Developers

Maybe its even possible to make a "protocol decoder" which pops up with a graphics screen?

A Sigrok protocol decoder would certainly be possible, but I strongly doubt that it would be usable for anything but still frames. The Python code it probably not even remotely fast enough.

You could speed up you own code, though, by reading blocks of data from stdin and iterating over it. Byte-wise I/O can be abysmally slow.

Benedikt wrote on 2020-07-09, 14:59:

You could speed up you own code, though, by reading blocks of data from stdin and iterating over it. Byte-wise I/O can be abysmally slow.

Yes indeed, I also had this idea. But for this the C# part needs to be modified - I dont know how to do this.

I think QB64 is as slow as Python. For somebody with average C# skills it should be no problem to transfer my little program and implement the reading of blocks of data over stdin if still to slow...

I still have some rudimentary C++ and SDL code for the same task since I had virtually the same project idea in 2018 but then abandoned it before it got anywhere.
I should really dig that up sometime.

As requested my QB64 source for EGA. Cable needs to be (I made a minor mistake in my above post...also corrected):

Analyzer Channel - Card connector
Channel 1 - 5 B
Channel 2 - 4 G
Channel 3 - 3 R
Channel 4 - 6 Gint
Channel 5 - 2 Rint
Channel 6 - 7 Bint
Channel 7 - 8 Hsync
Channel 8 - 9 Vsync

Best to try:

1) Start a 320x200 game with animation, e.g. populous. Easy to start from autoexec.bat without monitor attached.

2) create a 10 seconds data file "EGA.bin" with
sigrok-cli.exe" -d fx2lafw --time 10s -O binary --config "samplerate=24 MHz" > EGA.bin

3) replay this file with:
type EGA.bin | sigrok-EGA.exe

For other modes than 320x200 you need to exchange two lines in the program, see comments below.

Thats all...with this little program you can make the nice 64-color screenshots I posted above, including animation...:

--- sigrok-EGA.BAS

DECLARE LIBRARY "std_wrapper"
FUNCTION getchar_stdin& ()

END DECLARE

42 SCREEN _NEWIMAGE(1700, 700, 12)
50 value = getchar_stdin&
HSYNC = 0
VSYNC = 0

REM Read SYNCS from value
211 IF ((value AND 128) <> 0) THEN VSYNC = 1
212 IF ((value AND 64) <> 0) THEN HSYNC = 1

REM Wait for VSYNC
IF VSYNC = 0 THEN vsyncc = 0: GOTO 230
IF VSYNC = 1 THEN vsyncc = vsyncc + 1

REM This is different for different modes and cards:
REM There are "false" VSYNCS, therefore it must be at least 20 bytes long to be accepted.
REM Remove this if you dont see anything, it will disable screen refresh.
IF VSYNC = 1 AND vsyncc > 20 THEN y = 0: LOCATE 22, 1: PRINT TIME$: GOTO 50

230
REM decode EGA color: Mask out HSYNC/VSYNC
color1 = (value AND VAL("&B00111111"))

REM Next activates flicker-free for 320x200, other modes will not work!
PSET ((319 / 1070) * (x - 305), y), color1

REM Uncomment below and comment above to see every mode (unfiltered)
REM PSET (x, y), color1

250 IF HSYNC = 1 THEN Ref_len = Ref_len + 1
252 IF HSYNC = 0 THEN Ref_len = 0
260 IF HSYNC = 1 AND x > 700 AND (Ref_len > 30) THEN PSET (x, y), 5: y = y + 1: x = 0
x = x + 1

700 GOTO 50

----std_wrapper.h (put in your QB64 root-DIR)
#include <cstdio>

int getchar_stdin(){
unsigned char getChar;
getChar = fgetc (stdin);
return (int)getChar;
}

void write_string(char * s){
printf("%s", s);
return ;
}

And for the lazy ones:
sigrok-ega.exe and a 10 seconds sample file capttured with the logic analyzer. To replay extract both and type:

type EGA.bin | sigrok-EGA.exe

Other nice demo capture: Commander Keen 5

I am quite sure this will speed up to real-time if somebody is able to transfer my 20-lines QB64 Program to C++............

type keen5b.bin | sigrok-EGA.exe

s

Wow...one download... 🙁

I have made some benchmarks (i7-4790@3.6 GHz) to see where the bottleneck is.
When reading from STDIN in the the c library, I tested if it makes a difference to read byte-wise or block-wise (1000 bytes at once).

With...
getChar = fgetc (stdin);

and also with
fgets(buffer, 1000, stdin);

It takes 8 seconds to read 240.000.000 bytes from stdin - whichs corresponds to 10 seconds of data using a 24MHz capture. This in a simple loop without any processing of the data .

So this makes no difference on this level.

When doing the byte-wise transfer from the c library to QB64, it also takes 8 seconds to transfer the 240.000.000 bytes, without any further processing. So this is no bottleneck.

Including the rather simple data processing and drawing of the image in QB64, it takes 42 seconds to process 240.000.000 bytes.

--> My conclusion: QB64 is too slow. With all calculations done in c++ it will work in real-time, also when using STDIN.

Yeah, I would guess that stdin itself is buffered. So reading bytes or blocks probably doesn't make any difference. Using any language (compiled or JIT) other than BASIC will probably lead to performance gains. Also parallelizing some of the tasks/loops will help as well. I guess this is a task that can easily scale to multiple cores if several scanlines are buffered.

Predator99 wrote on 2020-07-04, 21:40:

BreakPoint wrote on 2020-07-04, 18:01:

You can easily calculate color component by multiplying hexadecimal 0x55 by 2 bit EGA color component. So EGA 00 is 0. EGA 01 is 0x55, EGA 10 = 0xAA, EGA 11 = 0xFF. So in general cable wiring does not really matter. You can get color by using simple bit operations.

Thats true, but you dont need this effort when the bits are directly in the correct order.

In correct order for a 4 bit output, yes. But BreakPoint suggests to do this transform for an RGB output. Which makes sense when using not a BASIC program, but something that uses e.g. SDL with an RGB surface.

root_42 from dosreloaded.de was so kind to transfer my code to c++ within a few minutes..!

https://dosreloaded.de/forum/index.php?thread … 6257#post106266

He already created a video:
https://www.youtube.com/watch?v=JgYpNU9yGyY&feature=youtu.be
Looks fantastic!

I think I will focus on the discussion there now to get it forward...

awesome :3

I really can't help discussing much, just watch in awe ^^

Predator99 wrote on 2020-07-15, 18:51:

root_42 from dosreloaded.de was so kind to transfer my code to c++ within a few minutes..!

Oh man, that guy sounds like a really cool dude! I wish I could meet him at some point!

imi wrote on 2020-07-15, 19:01:

awesome :3

I really can't help discussing much, just watch in awe ^^

Same! I'm sure there are plenty of us who can't contribute but are really enjoying watching the progress. @Predator99 the view count on your embedded images is a better indication of how many people are watching with interest.

One thing I noticed though is that I don't see the source code in your github, only the executable. Am I missing something or did you upload the wrong file ?

Deksor wrote on 2020-07-16, 16:39:

One thing I noticed though is that I don't see the source code in your github, only the executable. Am I missing something or did you upload the wrong file ?

I uploaded the wrong file. It's corrected now.

I improved your program because the scaling was totally off 😀

Now the overscan area that gets colored is entirely shown, the rest is cut.

1#include <stdio.h>
2#include <stdlib.h>
3
4#include <SDL2/SDL.h>
5#include <SDL2/SDL_surface.h>
6
7#define IMG_WIDTH 376
8#define IMG_HEIGHT 247
9
10void pset( SDL_Surface *surface,
11      unsigned int x,
12      unsigned int y,
13      unsigned char color
14      )
15{
16  Uint32 pixel =
17    (  ((color & (1 << 0)) << 1) + ((color & (1 << 3)) >> 3)) * 0x000055  // R
18    + (((color & (1 << 1)) >> 0) + ((color & (1 << 3)) >> 3)) * 0x005500  // G
19    + (((color & (1 << 2)) >> 1) + ((color & (1 << 3)) >> 3)) * 0x550000  // B
20    ;
21
22  Uint32 *target_pixel = surface->pixels + y * surface->pitch +
23    x * sizeof *target_pixel;
24  *target_pixel = pixel;
25}
26
27int main(int argc, char** argv) {
28	int new_frame = 0;
29	unsigned char value, color1;
30	int hsync = 0, vsync = 0;
31	int frame = 0;
32	unsigned int vsyncc = 0, ref_len = 0;
33	unsigned int x = 0, y = 0;
34
35	SDL_Window *window;                    // Declare a pointer
36
37	SDL_Init(SDL_INIT_VIDEO);              // Initialize SDL2
38
39	// Create an application window with the following settings:
40	window = SDL_CreateWindow(
41	"SIGROK2EGA",
42	SDL_WINDOWPOS_UNDEFINED,
43	SDL_WINDOWPOS_UNDEFINED,
44	376,
45	247,
46	SDL_WINDOW_SHOWN
47	);
48
49	// Check that the window was successfully created
50	if (window == NULL) {
51		// In the case that the window could not be made...
52		printf("Could not create window: %s\n", SDL_GetError());
53		return 1;
54	}
55
56	SDL_Surface *surface =
57	SDL_CreateRGBSurface(0, IMG_WIDTH, IMG_HEIGHT, 32, 0, 0, 0, 0);
58	if (surface == NULL) {
59		SDL_Log("SDL_CreateRGBSurface() failed: %s", SDL_GetError());
60		exit(1);

61	}
62	SDL_Surface *screen = SDL_GetWindowSurface(window);
63	if (screen == NULL) {
64		SDL_Log("SDL_GetWindowSurface() failed: %s", SDL_GetError());
65		exit(1);
66	}
67
68	while(!feof(stdin)) {
69		value = fgetc(stdin);
70		vsync = value & 128;
71		hsync = value & 64;
72		if( vsync == 0 ) {
73		  vsyncc = 0;
74		  new_frame = 0;
75		} else {
76			  vsyncc++;
77			  if( vsyncc > 20 ) {
78				vsyncc = 0;
79				y = 0;
80				// this means a new frame?
81				if( !new_frame ) {
82				  new_frame = 1;
83				  frame++;
84				  printf("frame %u\n", frame);
85				  // char fn[255];
86				  // snprintf(fn, 255, "public_html/public/ega-%u.bmp", frame);
87				  // SDL_SaveBMP(surface, fn);
88				  SDL_BlitSurface(surface, NULL, screen, NULL);
89				  SDL_UpdateWindowSurface(window);
90				  SDL_Event e;
91				  if (SDL_PollEvent(&e)) {
92					if (e.type == SDL_QUIT) {
93					  break;
94					}
95				  }
96				}
97				else {
98					
99				}
100			  }
101			  continue;
102			}
103		color1 = value & 0x3F;
104		int x_scaled = 319.0/1070.0*(x-184);
105		int y_scaled = y -13;
106		if( x_scaled >= 0 && x_scaled < IMG_WIDTH && y_scaled >= 0 && y_scaled < IMG_HEIGHT ) {
107		  pset(surface, x_scaled, y_scaled, color1);
108		}
109		x++;
110		if( hsync ) {
111		  ref_len++;
112		  if( ref_len > 30 && x > 700 ) {
113			//pset(surface, x, y, 5);
114			y++;
115			x = 0;
116		  }
117		} else {
118		  ref_len = 0;
119		}
120	}
121
122	SDL_DestroyWindow( window ); 
123	SDL_Quit();
124
125	return 0;
126}