lib/image/format/jpeg.cc

Go to the documentation of this file.

//
// canola - canon canola 1614p emulator
// Copyright (C) 2011 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, version 3, as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <lib/ac/stdio.h>
#include <lib/ac/string.h>
#include <libexplain/fclose.h>
#include <libexplain/fopen.h>
#include <jpeglib.h>

#include <lib/image/format/jpeg.h>


image_format_jpeg::~image_format_jpeg()
{
}


image_format_jpeg::image_format_jpeg(int a_width, int a_height) :
    image_format(a_width, a_height)
{
}


image_format_jpeg::image_format_jpeg(
    int a_width,
    int a_height,
    data_t *a_data
) :
    image_format(a_width, a_height, a_data)
{
}


const char *
image_format_jpeg::type_name(void)
    const
{
    return "JPEG";
}


image::pointer
image_format_jpeg::create(const std::string &filename)
{
    jpeg_decompress_struct cinfo;
    jpeg_error_mgr jerr;
    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_decompress(&cinfo);

    //
    // tell the jpeg library where to get its input from
    //
    FILE *fp = explain_fopen_or_die(filename.c_str(), "rb");
    jpeg_stdio_src(&cinfo, fp);

    //
    // read the file header
    //
    jpeg_read_header(&cinfo, TRUE);

    // tell the decompress we want RGB data
    cinfo.out_color_space = JCS_RGB;
    cinfo.quantize_colors = false;

    jpeg_start_decompress(&cinfo);
    int width = cinfo.output_width;
    int height = cinfo.output_height;

    size_t rgba_row_stride = width * 4;
    size_t rgba_data_size = height * rgba_row_stride;
    data_t *rgba_data = new data_t [rgba_data_size];

    int row_stride = width * cinfo.output_components;
    JSAMPLE *buffer = new JSAMPLE [row_stride];

    for (int y = 0; y < height; ++y)
    {
        //
        // jpeg_read_scanlines expects an array of pointers to scanlines.
        // Here the array is only one element long, but you could ask for
        // more than one scanline at a time if that's more convenient.
        //
        jpeg_read_scanlines(&cinfo, &buffer, 1);

        //
        // Transfer the RGB row into an RGBA row
        //
        JSAMPLE *ip = buffer;
        data_t *op = rgba_data + y * rgba_row_stride;
        for (int x = 0; x < width; ++x)
        {
            *op++ = *ip++;
            *op++ = *ip++;
            *op++ = *ip++;
            *op++ = 255;
        }
    }
    delete buffer;

    //
    // All done, release the resources.
    //
    jpeg_finish_decompress(&cinfo);
    explain_fclose_or_die(fp);

    //
    // Create the object.
    //
    return pointer(new image_format_jpeg(width, height, rgba_data));
}


void
image_format_jpeg::save_to_file(const std::string &filename)
    const
{
    //
    // create file
    //
    FILE *fp = explain_fopen_or_die(filename.c_str(), "wb");

    jpeg_compress_struct cinfo;
    memset(&cinfo, 0, sizeof(cinfo));
    jpeg_error_mgr jerr;
    memset(&jerr, 0, sizeof(jerr));
    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_compress(&cinfo);
    jpeg_stdio_dest(&cinfo, fp);
    cinfo.image_width = get_width();
    cinfo.image_height = get_height();
    cinfo.input_components = 3;
    cinfo.in_color_space = JCS_RGB;
    jpeg_set_defaults(&cinfo);
    jpeg_set_quality(&cinfo, 100, 1);
    jpeg_start_compress(&cinfo, 1);

    //
    // Write each scan line, one at a time
    JSAMPLE *rowbuf = new JSAMPLE [cinfo.image_width * 3];
    while (cinfo.next_scanline < cinfo.image_height)
    {
        const data_t *ip = get_data(cinfo.next_scanline);
        JSAMPLE *op = rowbuf;
        for (size_t x = 0; x < cinfo.image_width; ++x)
        {
            // turn RGBA data into RGB data
            *op++ = *ip++;
            *op++ = *ip++;
            *op++ = *ip++;
            ++ip;
        }
        jpeg_write_scanlines(&cinfo, &rowbuf, 1);
    }
    delete rowbuf;
    jpeg_finish_compress(&cinfo);
    jpeg_destroy_compress(&cinfo);

    explain_fclose_or_die(fp);
}


image::pointer
image_format_jpeg::create_blank(int width, int height)
{
    return pointer(new image_format_jpeg(width, height));
}