darling-cocotron/Onyx2D/O2ImageDecoder_JPEG_libjpeg.m

#import <Onyx2D/O2ImageDecoder_JPEG_libjpeg.h>

#import <Onyx2D/O2Defines_libjpeg.h>

#ifdef LIBJPEG_PRESENT

#import <jpeglib.h>

@implementation O2ImageDecoder_JPEG_libjpeg

typedef struct o2jpg_error_mgr {
    struct jpeg_error_mgr err;
    jmp_buf jmp; // Additional info about where to go on error
} o2jpg_error_mgr;

// Use libjpeg to do the decoding
static void o2error_exit(j_common_ptr cinfo) {
    o2jpg_error_mgr *o2err = (o2jpg_error_mgr *) cinfo->err;

    // Doesn't hurt to display what went wrong
    (*cinfo->err->output_message)(cinfo);

    // Jump to our error handling code
    longjmp(o2err->jmp, 1);
}

static unsigned char *stbi_jpeg_load_from_memory(const uint8_t const *buffer,
                                                 int len, int *x, int *y)
{
    struct jpeg_decompress_struct cinfo;
    jpeg_create_decompress(&cinfo);

    o2jpg_error_mgr jerr;

    cinfo.err = jpeg_std_error(&jerr.err);
    // Use our own exit routine - we don't want to exit the app when something
    // goes wrong
    jerr.err.error_exit = o2error_exit;
    // We need to use setjmp since the error exit method must no return
    if (setjmp(jerr.jmp)) {
        // Do some cleaning and return an empty image
        jpeg_destroy_decompress(&cinfo);
        return 0;
    }

    /// Read the data from our memory buffer
    jpeg_mem_src(&cinfo, (unsigned char *) buffer, len);

    // Setup the jpeg header and set the decompress options
    jpeg_read_header(&cinfo, TRUE);

    // We only support RGBA format for the output format
    if (cinfo.jpeg_color_space == JCS_CMYK ||
        cinfo.jpeg_color_space == JCS_YCCK) {
        // libjpeg doesn't know how to do the CMYK->RGBx conversion - we'll have
        // to do it ourself
        cinfo.out_color_space = JCS_CMYK;
    } else {
#ifdef JCS_ALPHA_EXTENSIONS
        // libjpeg turbo can convert the output data directly to the RGBA buffer
        // format we want
        cinfo.out_color_space = JCS_EXT_RGBA;
#else
        cinfo.out_color_space = JCS_RGB;
#endif
    }
    int wantedPixelSize = cinfo.output_components = cinfo.out_color_components =
            4;

    jpeg_start_decompress(&cinfo);
    *x = cinfo.output_width;
    *y = cinfo.output_height;

    // Number of bytes in a decompressed row
    int bytesPerRow = cinfo.output_width * wantedPixelSize;

    // Buffer for the final decompressed data
    unsigned char *outputImage =
            (unsigned char *) malloc(bytesPerRow * cinfo.output_height);
    if (outputImage) {
#ifdef JCS_ALPHA_EXTENSIONS
        // Scanline buffers pointers - they'll point directly to the final image
        // buffer
        JSAMPROW scanlineBuffer[cinfo.rec_outbuf_height];
#else
        // Scanline buffers
        JSAMPARRAY scanlineBuffer = (*cinfo.mem->alloc_sarray)(
                (j_common_ptr) &cinfo, JPOOL_IMAGE, bytesPerRow,
                cinfo.rec_outbuf_height);
#endif

        while (cinfo.output_scanline < cinfo.image_height) {
            int currentLine = cinfo.output_scanline;
#ifdef JCS_ALPHA_EXTENSIONS
            // We'll decode directly into the final buffer
            for (int i = 0; i < cinfo.rec_outbuf_height; ++i) {
                scanlineBuffer[i] =
                        outputImage + (currentLine + i) * bytesPerRow;
            }
            jpeg_read_scanlines(&cinfo, scanlineBuffer,
                                cinfo.rec_outbuf_height);
            if (cinfo.out_color_space == JCS_CMYK) {
                // Convert from CMYK to RGBA
                for (int i = 0; i < cinfo.rec_outbuf_height; ++i) {
                    unsigned char *out =
                            outputImage + (currentLine++) * bytesPerRow;
                    for (int j = 0; j < cinfo.output_width; ++j) {
                        unsigned char c = out[0];
                        unsigned char m = out[1];
                        unsigned char y = out[2];
                        unsigned char k = out[3];
                        int r = (c * k) / 255;
                        int g = (m * k) / 255;
                        int b = (y * k) / 255;

                        *out++ = r;
                        *out++ = g;
                        *out++ = b;
                        *out++ = 0xff; // add the alpha component
                    }
                }
            }
#else
            int count = jpeg_read_scanlines(&cinfo, scanlineBuffer,
                                            cinfo.rec_outbuf_height);
            for (int i = 0; i < count; ++i) {
                char *out = outputImage + (currentLine++) * bytesPerRow;
                const char *scanline = scanlineBuffer[i];
                for (int j = 0; j < cinfo.output_width; ++j) {
                    if (cinfo.out_color_space == JCS_CMYK) {
                        // Convert from CMYK to RGBA
                        unsigned char c = *scanline++;
                        unsigned char m = *scanline++;
                        unsigned char y = *scanline++;
                        unsigned char k = *scanline++;
                        int r = (c * k) / 255;
                        int g = (m * k) / 255;
                        int b = (y * k) / 255;

                        *out++ = r;
                        *out++ = g;
                        *out++ = b;
                        *out++ = 0xff; // add the alpha component
                    } else {
                        // Convert from RGB to RGBA
                        *out++ = *scanline++;
                        *out++ = *scanline++;
                        *out++ = *scanline++;
                        *out++ = 0xff; // add the alpha component
                    }
                }
            }
#endif
        }
    }
    // We're done - do some cleanup
    jpeg_finish_decompress(&cinfo);
    jpeg_destroy_decompress(&cinfo);

    return outputImage;
}

- initWithDataProvider: (O2DataProviderRef) dataProvider {

    _compressionType = O2ImageCompressionJPEG;
    _dataProvider = [dataProvider retain];

    CFDataRef encodedData = O2DataProviderCopyData(dataProvider);
    CFIndex encodedLength = CFDataGetLength(encodedData);
    const uint8_t *encodedBytes = CFDataGetBytePtr(encodedData);

    int comp;
    uint8_t *bitmap;

    int width, height;

    bitmap = stbi_jpeg_load_from_memory(encodedBytes, encodedLength, &width,
                                        &height);

    CFRelease(encodedData);

    if (bitmap == NULL) {
        [self dealloc];
        return nil;
    }

    _width = width;
    _height = height;
    _bitsPerComponent = 8;
    _bitsPerPixel = 32;
    _bytesPerRow = (_bitsPerPixel / (sizeof(char) * 8)) * _width;
    _colorSpace = O2ColorSpaceCreateDeviceRGB();
    _bitmapInfo = kO2BitmapByteOrder32Big | kO2ImageAlphaPremultipliedLast;

    _pixelData = (CFDataRef)
            [[NSData alloc] initWithBytesNoCopy: bitmap
                                         length: _bytesPerRow * _height
                                   freeWhenDone: YES];

    return self;
}

- (void) dealloc {
    [_dataProvider release];
    [_colorSpace release];
    CFRelease(_pixelData);
    [super dealloc];
}

- (CFDataRef) createPixelData {
    return CFRetain(_pixelData);
}

@end

#endif