Windows and OSX 64-bit builds?
hh
hh at hyperhh.de
Fri Feb 10 17:29:14 EST 2017
Please post this "Split it!"- answer, as it is, in LC's blog.
This is good even for real beginners.
Large files or large data shouldn't be a reason for _incomplete_ 64Bit
implementations that would make once again LC Script slower.
> Mark Waddingham wrote:
> >
> > Tom Glod wrote:
> > I will... if u wanna replicate...put an image on a stack..make it
> > 32k x 32k
> > ..... and try and do a export snapshot of the image, LC goes POOF...
> > Trevor
> > said tha last version of 8 (8.13) had some memory issues solves, so i
> > will try to test is there too.
>
> Currently, the engine implements 'export snapshot' by allocating a
> raster (32-bits per pixel) of the size of the snapshot you are making,
> rendering into it and then compressing it.
>
> So really the maximum size you could hope to snapshot is 16k x* 16k
> pixels as that requires 2Gb - the engine in general uses signed integer
> indicies, so the maximum memory buffer it can manipulate is 2Gb bytes. A
> 32-bit process would probably struggle to do that (due to only having
> around 2-3Gb of user address space to use) - as there is overhead in
> rasterization and then compression; but a 64-bit process should be fine.
>
> There is a bug here as (at least in this specific case) the engine
> should fail gracefully (as we know there is a hard limit in the size of
> an image the engine can process).
>
> As you correctly point out 32k x 32k comes in at 1Gb pixels - which at
> 24-bit RGB comes out at 4Gb of data. No 'normal' 32-bit application
> which isn't explicitly designed for manipulating huge images will be
> able to deal with something that size. I would expect applications such
> as Photoshop to be able to deal with them though since I believe their
> native raw storage format for images pages from disk as required (so you
> never have the 'whole thing' in memory at once - just the bit you are
> looking at / editing).
>
> One important thing to remember is that the amount of memory required to
> take a snapshot is (SOMECONSTANT * 4 * the number of pixels) in the rect
> of the snapshot (I've not checked but I would estimate 0 < SOMECONSTANT
> < 2) which means that you can get LiveCode to generate very large
> images, but you have to break the problem down by splitting up the
> snapshot into bands and probably use an external (command-line) tool to
> compress the image into your format of choice (how big an image such a
> tool can process, again, will be dependent on whether it needs to load
> the entire image into memory to compress it or not).
>
> Rough idea:
>
> repeat with i = 0 to pHeight / kBandSize
> import snapshot from rect (0, pWidth, i * kBandSize, kBandSize)
> write the imageData of the last image to file tOutputFile
> delete the last image
> end repeat
>
> After this you will have a very large file with the raw xRGB data in it,
> so you need to find a tool which can take raw 32-bit xRGB data (with
> specified order of the RGB), the width and height and process it into
> jpg or png or whatever format you require (I'm hoping others who know
> more about such things might be able to chime in here - ImageMagick has
> an arsenal of command-line tools, for example).
>
> Warmest Regards,
>
> Mark.
>
> P.S. There is a hard limit of co-ordinate magnitude in LC and thus the
> size of any object - 32767 pixels on any side of anything.
More information about the use-livecode
mailing list