Re: Fast way of splitting an image into bit planes ?

Hmm, maybe I should try a differen technique to get more speed.

I want to process each bit plane individually.

Maybe I should just try and do it in parallel, and then store the results
in 
parallel as well.

For example, top of my head:

Bit : array[0..23] of byte;

for vIndex := 0 to 23 do
begin
    Bit[vIndex] := (Pixel shr vIndex) and 1;
end;

Then keep track of data bit for each plane
DataBit[Index] etc. for first pixel.

Then to run time length encode in parallel:

for loop etc
if DataBit[Index] = Bit[vIndex] then
begin
    Count[Index] := Count[Index] + 1;
end else
begin
    Output Count... only problem is... how will reader know what is what
;)
end;

Only if the count is written in parallel in one bit for each thingy or so 
might it work.

and ofcourse then it won't work, since some counts will stop and others
will 
continue.

Anyway maybe storing every bit in a seperate byte might be a nice way to 
extract everything fastly and work with it fastly.

Or maybe not...

Ofcourse for each bit plane a count array could be kept.

So it might be something like:

Count[BitIndex,CountIndex]

This will store all the runtime lengths for each bit plane.

It will require some memory... but access will probably be pretty fast.

Then finally only thing which needs to happen is to output the counts... 
which could happen in any order really..
but the most logic way would to simply be,

begin with bit plane 0, write the counts, when down, continue to bit plane
1 
and repeat.

Pretty easy really.

This is actually how I did it more or less for some other processing...
but 
I am not sure if it's fast.

It's probably a lot faster then the stupid set/get ****ing code.

Well don't worry if you not understand any of this.

It's vague idea/description but it will probably work.

Though it does need a CounterCount for each bit plane which must be 
incremented as well, which adds further cpu overhead...
but it's still doable me thinks.

Well maybe somebody else knows better way to do what I want... which is 
split image into bit planes and store the bit planes next to each 
sequentially like I described earlier.

Tomorrow I will try this wacky idea above though... it should be pretty
easy 
to implement.

Bye,
  Skybuck.