This is a node.js module, writen in C++, that uses libjpeg to produce a JPEG image (in memory) from a buffer of RGBA or RGB values. Since JPEG has no notion of A (alpha), the module always uses just RGB values.

It was written by Peteris Krumins ([email protected]). His blog is at http://www.catonmat.net -- good coders code, great reuse.

The module exports three objects: Jpeg, FixedJpegStack, DynamicJpegStack.

Jpeg allows to create fixed size jpegs from RGB, BGR, RGBA or BGRA buffers. FixedJpegStack allows to push multiple jpegs to a fixed size canvas. DynamicJpegStack allows to push multiple jpegs to a dynamic size canvas (it grows as you push jpegs to it).

All objects provide synchronous and asynchronous interfaces.

##Jpeg

Jpeg object that takes 4 arguments in its constructor:

    var jpeg = new Jpeg(buffer, width, height, [buffer_type]);

The first argument, buffer, is a nodee.js Buffer filled with RGBA or RGB values. The second argument is integer width of the image. The third argument is integer height of the image. The fourth argument is buffer type, either 'rgb' or 'rgba'. [Optional].

After you have constructed the object, call .encode() or .encodeSync to produce a jpeg:

    var jpeg_image = jpeg.encodeSync(); // synchronous encoding (blocks node.js)

Or:

    jpeg.encode(function (image, error) {
        // jpeg image is in 'image'
    });

See examples/ directory for examples.

##FixedJpegStack

First you create a FixedJpegStack object of fixed width and height:

    var stack = new FixedJpegStack(width, height, [buffer_type]);

Then you can push individual fragments to it, for example,

    stack.push(buf1, 10, 11, 100, 200); // pushes buf1 to (x,y)=(10,11)
                                        // 100 and 200 are width and height.

    // more pushes

After you're done, call .encode() to produce final jpeg asynchronously or .encodeSync() (just like in Jpeg object). The final jpeg will be of size width x height.

##DynamicJpegStack

DynamicJpegStack is the same as FixedJpegStack except its canvas grows dynamically.

First, create the stack:

    var stack = new DynamicJpegStack([buffer_type]);

Next push the RGB(A) buffers to it:

    stack.push(buf1, 5, 10, 100, 40);
    stack.push(buf2, 2, 210, 20, 20);

Now you can call encode to produce the final jpeg:

    var jpeg = stack.encodeSync();

Now let's see what the dimensions are,

    var dims = stack.dimensions();

Same asynchronously:

    stack.encode(function (jpeg, dims) {
        // jpeg is the image
        // dims are its dimensions
    });

In this particular example:

The x position dims.x is 2 because the 2nd jpeg is closer to the left. The y position dims.y is 10 because the 1st jpeg is closer to the top. The width dims.width is 103 because the first jpeg stretches from x=5 to x=105, but the 2nd jpeg starts only at x=2, so the first two pixels are not necessary and the width is 105-2=103. The height dims.height is 220 because the 2nd jpeg is located at 210 and its height is 20, so it stretches to position 230, but the first jpeg starts at 10, so the upper 10 pixels are not necessary and height becomes 230-10= 220.

##How to install?

To get it compiled, you need to have libjpeg and node installed. Then just run

    node-waf configure build

to build the Jpeg module. It will produce a jpeg.node file as the module.

See also http://github.com/pkrumins/node-png module that produces PNG images. See also http://github.com/pkrumins/node-gif module that produces GIF images.

Have fun!

Sincerely, Peteris Krumins http://www.catonmat.net