Compactor

Compactor





James Higgo steals space on the Spectrum.





A few months ago, several routines which stored a screen in


memory and then recalled it were published. This takes up


much memory, and only three screens may be stored on a 48K


Spectrum in this way. [Not quite true. The maximum is six,


though there is then little room left over for a recalling


program. Mr. Higgo's main point remains valid, of course.]


This routine compacts the screen by not storing all the


blank spaces, but by counting up how many of them there


are. The resulting data is stored by a Basic program, and


then recalled from any area of memory by the machine-code


routine.


The advantages of this technique are that it takes up


about a tenth of the memory for a normal picture, is faster


to draw, and several images may be superimposed.


To store a picture, the Basic program must be run - use


GO TO 10, as RUN will wipe the screen. The compacted data


will be put into locations 50000 onwards, depending on the


complexity of the picture.


The length of the data will be indicated by the final


value of the number at the bottom left-hand corner of the


screen. The data may then be saved using


SAVE "data" CODE 50000


and the length number.


Once the data has been saved it may be reloaded into a


new location using


LOAD "data" CODE


and the value of the desired location.


To recall the picture, the machine-code routine must be


loaded, and the values of the start and finish addresses of


the data must be poked into the locations 65532 to 65535,


by converting the number to hex and poking the high and low


bytes as follows:


65532: end location high byte


65533: end location low byte


65532: start location high byte


65533: start location low byte


For example, if the data is left at locations 50000 - not


saved and reloaded -


POKE 65532,200 end locations (ave. picture length)


POKE 65533,180


POKE 65534,195


POKE 65535, 80 start locations


Using these values for the end locations may chop off or


add something to your picture if it is longer or shorter


than the average. Once this had been done, to recall the


picture, you need only type


RANDOMIZE USR 60000


Listing 1 is the data for the machine-code routine.


Listing 2 is a loader for listing 1. Listing 3 is the


compacting program.


Here's how to enter the program:


1. Type in machine-code loader and enter data by running it


2. Delete the loader line by line, and type in the compac-


ter program


3. Draw a picture, then run the computer by typing GO TO


100. Commands for drawing the picture may be entered in


lines 1-99, or a picture may be loaded from tape


4. Save the compacted code on tape by typing SAVE "data"


CODE 50000 and the length of the data, which is given at


the bottom left of the screen after compacting


5. Reload the data into the desired area, and poke the


start and finish locations into stores 65532 to 65534,


as described earlier.


6. Type RANDOMIZE USR 60000


If the start and end locations have not been calculated


correctly, the screen will be filled with a portion of the


picture, or garbage. The locations for finish are different


for each screen, and are found by hexing the length of the


data plus 50000, or whatever the start location is.





[ As is evident from the description above, the compactor


program printed with the article wrote over the top of


the screen it was compacting. Not the most productive


behaviour... The program called "Compactor" on the TZX


is a slightly modified version which doesn't do this,


but is the same otherwise - amongst others, it does still


overwrite the screen _after_ it's done with that part.


If, for some reason, you want the original, it is also


on the TZX, as "CompctOrig". Neither version, by the way,


autoruns - that would somewhat defeat the object of the


exercise, as well.


The code loader is not on the TZX - it was the simplest


of affairs - but, of course, the machine code itself is,


as "expand".





Also on the TZX are two very simple sample screens. Note


their sizes, particularly the second one! And this is


for the pixel data alone - the routine never touches or


even looks at the attributes. It seems that Mr. Higgo has


overestimated the efficiency of his routine, or perhaps


uses even simpler screens than these. In any case a com-


pression factor of ten, as promised, is unlikely.


Finally, there's also a demo program which loads the


expander code and the two sample screens - demonstrating


that the routine is relocatable - and then repeatedly


pokes the requisite values and calls the routine on the


screens in turn. This also proves that it doesn't just


write successive zeroes, it skips them entirely, over-


laying the compacted screen on the existing one. As the


article explains, this can be used to superimpose one


screen on another.


Richard Bos, April 2012 ]