I take it this question is "academic" since it appears that this strange behavior doesn't actually prevent you from accomplishing anything useful.
In that spirit, I can tell you a couple things about digital video.
It is pretty typical that your screen gets "refreshed" by a video controller that reads memory and sends it to the display. Typically the memory contains an array of pixels which have values that determine their colors. Typically it is a contiguous block of memory. And it is the "right size" to provide a value for each pixel (picture element, ie the smallest spec of screen that ends up a color). (And "raster" means that your display is "drawn" by beam(s) tracing across and down, as each pixel data arrives with the color. The horizontal lines are slightly visible in your image.)
The lower part of your display seems to be reading memory that is not actually written with graphical information (could be program, could just be uninitialized, or some other data that was lying around, or could be pixel information that is misinterpreted because the mode has changed--eg sometimes colors are looked up in a table, sometimes right in the data). Clearly it isn't constant, and it isn't anything that looks like anything in particular.
The top part is a bit mysterious. It is common for video to provide test output (eg the famous color bars you used to see on TV). This is fairly easy to generate in hardware, because it is just the same color repeating over and over, and then occasionally a new color. These are usually created in a way that makes them recognizable on a generic oscilloscope. I haven't seen one generate subtractive colors (magenta etc), but why not. It is a weird that it switches from the solids to memory, but then it is weird that it doesn't output a sensible image or black.
It looks like the total pixels that are solids might be about right to fill the screen, but it isn't sending them at the right time, so it ends up finishing with the random stuff instead. This isn't terribly surprising because there are any number of (valid) modes, each with a specific memory addressing scheme and timing for starting the horizontal traces, and what is clear is that this mode isn't self-consistent.