libnebular-plugin-jpeg.cpp

Go to the documentation of this file.

#include "libnebular-plugin-base.hpp"

#include <sstream>
#include <vector>

#include <boost/static_assert.hpp>
#include <boost/bind.hpp>

// Base for this plugin, "libjpeg"
#include "jpeglib.h"

namespace libnebular{
    using namespace std;

    class JpegPictureHandler;

    class JpegPictureHandler: public PictureHandler{
    private:
        static const String dctTypeNameTable[];
        static const String jpegColorSpaceTable[];

        NumberedStrings dctTypeName;
        NumberedStrings jpegColorSpaceString;

        J_DCT_METHOD curIdctMethod;

        struct MyErrorMgr {
        public:
            jpeg_error_mgr pub;

        private:

            int msgLevel;
            JMETHOD(void, prevEmitMessage, (j_common_ptr cinfo, int msgLevel));
            RawCExceptionLongJmp rawCException;

            static MyErrorMgr *get(j_common_ptr cInfo){
                return reinterpret_cast<MyErrorMgr*>(cInfo->err);
            }

            template <typename CurrException> void doThrow(const CurrException &newException){
                rawCException.doThrow(newException);
            }

            static void myErrorExit (j_common_ptr cInfo)
            {
                char buffer[JMSG_LENGTH_MAX];
                cInfo->err->format_message(cInfo, buffer);

                ostringstream tmpOut; tmpOut << "From <libjpeg>: \"" << buffer << "\"";

                MyErrorMgr::get(cInfo)->doThrow( LIBNEBULAR_ERROR(tmpOut.str()) );
            }

            static void myEmitMessage (j_common_ptr cInfo, int msgLevel)
            {
                MyErrorMgr::get(cInfo)->msgLevel = msgLevel;
                MyErrorMgr::get(cInfo)->prevEmitMessage(cInfo, msgLevel);
            }

            static void myOutputMessage (j_common_ptr cInfo)
            {
                char buffer[JMSG_LENGTH_MAX];
                cInfo->err->format_message(cInfo, buffer);

                const int &msgLevel = MyErrorMgr::get(cInfo)->msgLevel;

                if(
                    msgLevel == -1
                ){
                    ostringstream tmpOut; tmpOut << "From <libjpeg>: \"" << buffer << "\"";
                    Log::warning(tmpOut.str());
                }else{
                    ostringstream tmpOut; tmpOut << "From <libjpeg> (trace level " << msgLevel << "): \"" << buffer << "\"";
                    Log::info(tmpOut.str());
                }
            }
        public:
            template <typename Return> Return runRawC(Loki::Functor<Return> procedure){
                return rawCException.run<Return>(procedure);
            }
            MyErrorMgr(){
                jpeg_std_error(&pub);

                pub.error_exit = myErrorExit;
                prevEmitMessage = pub.emit_message;
                pub.emit_message = myEmitMessage;
                pub.output_message = myOutputMessage;
            }

        };

        struct MyErrorMgr jerr;

        struct jpeg_decompress_struct decInfo;
        struct jpeg_compress_struct cInfo;
        CFileWrapper file;

    public:
        template <typename Return> Return runRawC(Loki::Functor<Return> procedure){
            return jerr.runRawC<Return>(procedure);
        }

        JpegPictureHandler();
        ~JpegPictureHandler(){
            jpeg_destroy_compress(&cInfo);
            jpeg_destroy_decompress(&decInfo);
        }

        void readFileInfo(){
            file = CFileWrapper(pic->get<String>("opt/file/url").c_str(), "rb");

            runRawC<void>(boost::bind(
                jpeg_stdio_src, &decInfo, file.get()
            ));
            runRawC<int>(boost::bind(
                jpeg_read_header, &decInfo, TRUE
            ));

            pic->set<Integer>("bm/x-size", decInfo.image_width);
            pic->set<Integer>("bm/y-size", decInfo.image_height);
            pic->set<Integer>("bm/jpeg-color-components", decInfo.num_components);
            pic->set<String>("bm/jpeg-color-space", jpegColorSpaceString.indexToString(decInfo.jpeg_color_space));

            pic->set<bool>("file/jpeg-jfif-header", decInfo.saw_JFIF_marker);
            if(decInfo.saw_JFIF_marker){
                // There's JFIF APP0 marker and we'll process it

                pic->set<Integer>("file/jpeg-jfif-major-version", decInfo.JFIF_major_version);
                pic->set<Integer>("file/jpeg-jfif-minor-version", decInfo.JFIF_minor_version);
                if(decInfo.density_unit == 1){
                    // Density units: BPP
                    pic->set<Integer>("bm/x-dpi", decInfo.X_density);
                    pic->set<Integer>("bm/y-dpi", decInfo.Y_density);
                }else if(decInfo.density_unit == 2){
                    // Density units: dots/cm
                    const Integer dpmPerDpcm = 100;
                    pic->set<Integer>("bm/x-dots-per-m", decInfo.X_density*dpmPerDpcm);
                    pic->set<Integer>("bm/y-dots-per-m", decInfo.Y_density*dpmPerDpcm);
                }else if(decInfo.density_unit != 0){
                    throw LIBNEBULAR_ERROR(
                        Log::getWrongValueMsg(
                            "\"density_unit\"",
                            Integer(decInfo.density_unit),
                            "in {0, 1, 2}",
                            "JPEG header",
                            "Invalid"
                        )
                    );
                }
            }

            pic->set<bool>("file/jpeg-saw-adobe-marker", decInfo.saw_Adobe_marker);
            if(decInfo.saw_Adobe_marker){
                // Adobe APP14 marker was seen
                pic->set<Integer>("file/jpeg-adobe-transform", decInfo.Adobe_transform);
            }

            {
                pic->set<Integer>("bm/bpp", 24);

                pic->set<String>("bm/pixel-mask/r", "0xff");
                pic->set<String>("bm/pixel-mask/g", "0xff00");
                pic->set<String>("bm/pixel-mask/b", "0xff0000");
                pic->set<String>("bm/pixel-mask/a", "0");

                pic->set<String>("bm/scanline-skip", "0");
                pic->set<String>("bm/scanline-axis", "x");

                pic->set<String>("bm/orient-left", "true");
                pic->set<String>("bm/orient-top", "true");

                decInfo.out_color_space = JCS_RGB;
            }
        }

        void readBm(){
            /* Step 4: set parameters for decompression */
            {
                pic->setDefaultIfNotSet("opt/file/jpeg-dct-method", "islow");

                decInfo.dct_method = static_cast<J_DCT_METHOD>(
                    dctTypeName.stringToIndex(pic->get<String>("opt/file/jpeg-dct-method"))
                );

                pic->acceptOpt("file/jpeg-dct-method");
            }

            Blob bmData;
            if(pic->isSet("bm/data")){
                bmData = pic->get<Blob>("bm/data");
                pic->unSet("bm/data");
                bmData.forsakeData();
            }
            pic->calculate<PictureProps::PropCalcBmDataSize>();

            Integer bmScanlinePitch = checkedBitsToIntBytes(
                pic->get<Integer>("calc/bm/scanline-pitch-bits")
            );
            BOOST_STATIC_ASSERT(sizeof(JSAMPLE) == 1);

            bmData.prepareForSize(
                pic->get<Integer>("calc/bm/data-size")
            );

            const unsigned int scanlinesPerPass = 1;

            /* Step 5: Start decompressor */
            runRawC<boolean>(boost::bind(
                jpeg_start_decompress, &decInfo
            ));

            /* Step 6: while (scan lines remain to be read) */
            std::vector<JSAMPLE*> buffer(scanlinesPerPass);
            Loki::Functor<JDIMENSION> readScanlines =
                boost::bind(
                    jpeg_read_scanlines, &decInfo, &(buffer[0]), scanlinesPerPass
                );
            while (decInfo.output_scanline < decInfo.output_height) {
                JSAMPLE *curDestScanLine = reinterpret_cast<JSAMPLE*>(bmData.getDataReadWrite())+
                    bmScanlinePitch*1*decInfo.output_scanline;
                for(Integer i = 0; i < scanlinesPerPass; i++){
                    buffer[i] = reinterpret_cast<JSAMPLE*>(
                        curDestScanLine
                    );
                    curDestScanLine += bmScanlinePitch; // @note  No overflow check and s
                }
                runRawC<JDIMENSION>(readScanlines);
            }

            /* Step 7: Finish decompression */
            runRawC<boolean>(boost::bind(
                jpeg_finish_decompress, &decInfo
            ));

            pic->set("bm/data", bmData);
        }

        void write(){
            // @c Picture with appropriately converted bitmap
            boost::shared_ptr<Picture> picBm(new Picture);

            {
                picBm->set<Integer>("opt/bm/bpp", 24);

                picBm->set<String>("opt/bm/pixel-format-type", "rgb");
                picBm->set<String>("opt/bm/pixel-mask/r", "0xff");
                picBm->set<String>("opt/bm/pixel-mask/g", "0xff00");
                picBm->set<String>("opt/bm/pixel-mask/b", "0xff0000");
                picBm->set<String>("opt/bm/pixel-mask/a", "0");

                picBm->set<String>("opt/bm/scanline-skip", "0");
                picBm->set<String>("opt/bm/scanline-axis", "x");

                picBm->set<String>("opt/bm/orient-left", "true");
                picBm->set<String>("opt/bm/orient-top", "true");

                picBm->reproduce(*pic.get());
            }

            file = CFileWrapper(pic->get<String>("opt/file/url").c_str(), "wb");
            runRawC<void>(boost::bind(
                jpeg_stdio_dest, &cInfo, file.get()
            ));

            cInfo.image_width = pic->get<Integer>("bm/x-size");
            cInfo.image_height = pic->get<Integer>("bm/y-size");

            // Will write only RGB
            cInfo.in_color_space = JCS_RGB;
            pic->set<String>("bm/jpeg-color-space", jpegColorSpaceString.indexToString(cInfo.jpeg_color_space));
            // Usual for RGB
            cInfo.input_components = 3;
            pic->set<Integer>("bm/jpeg-color-components", cInfo.num_components);

            runRawC<void>(boost::bind(
                jpeg_set_defaults, &cInfo
            ));

            pic->setDefaultIfNotSet("opt/file/jpeg-force-baseline", "true");
            if(!pic->isSet("opt/file/jpeg-quality")){
                pic->setDefaultIfNotSet("opt/file/jpeg-quality", "75");
            }else{
                if(pic->isSet("opt/file/jpeg-linear-quality")){
                    if(
                        runRawC<int>(boost::bind(
                            jpeg_quality_scaling, pic->get<Integer>("opt/file/jpeg-quality")
                        )) !=
                        pic->get<Integer>("opt/file/jpeg-linear-quality")
                    ){
                        throw LIBNEBULAR_ERROR(Log::getWrongValueMsg(
                            "\"opt/file/jpeg-linear-quality\"", pic->get<Integer>("opt/file/jpeg-linear-quality"), "not conflicting with \"opt/file/jpeg-quality\"",
                            String(__func__)+" option key", "Conflicting"
                        ));
                    }
                }
            }
            if(pic->isSet("opt/file/jpeg-quality")){
                runRawC<void>(boost::bind(
                    jpeg_set_quality, &cInfo,
                    pic->get<Integer>("opt/file/jpeg-quality"),
                    pic->get<bool>("opt/file/jpeg-force-baseline")
                ));

            }else{
                runRawC<void>(boost::bind(
                    jpeg_set_linear_quality, &cInfo,
                    pic->get<Integer>("opt/file/jpeg-linear-quality"),
                    pic->get<bool>("opt/file/jpeg-force-baseline")
                ));
            }

            pic->setDefaultIfNotSet("opt/file/jpeg-simple-progression", "false");
            if(pic->get<bool>("opt/file/jpeg-simple-progression")){
                runRawC<void>(boost::bind(
                    jpeg_simple_progression, &cInfo
                ));
            }
            pic->acceptOpt("file/jpeg-simple-progression");

            pic->setDefaultIfNotSet("opt/file/jpeg-optimize-coding", "true");
            cInfo.optimize_coding = pic->get<bool>("opt/file/jpeg-optimize-coding");
            pic->acceptOpt("file/jpeg-optimize-coding");

            pic->setDefaultIfNotSet("opt/file/jpeg-jfif-header", "true");
            cInfo.write_JFIF_header = pic->get<bool>("opt/file/jpeg-jfif-header");
            pic->acceptOpt("file/jpeg-jfif-header");
            if(cInfo.write_JFIF_header){
                // There's JFIF APP0 marker and we'll process it

                if(pic->isSet("bm/x-dpi") && pic->isSet("bm/y-dpi")){
                    cInfo.density_unit = 1;
                    cInfo.X_density = pic->get<Integer>("bm/x-dpi");
                    cInfo.Y_density = pic->get<Integer>("bm/y-dpi");
                }if(pic->isSet("bm/x-dots-per-m") && pic->isSet("bm/y-dots-per-m")){
                    cInfo.density_unit = 2;
                    const Integer cmPerM = 100;
                    if(
                        pic->get<Integer>("bm/x-dots-per-m") % cmPerM != 0
                    ){
                        Log::warning(String() + "Property \"" + "bm/x-dots-per-m" + "\" value in file loses precision of that in \"Picture\"");
                    }
                    if(
                        pic->get<Integer>("bm/y-dots-per-m") % cmPerM != 0
                    ){
                        Log::warning(String() + "Property \"" + "bm/y-dots-per-m" + "\" value in file loses precision of that in \"Picture\"");
                    }
                    cInfo.X_density = roundDiv(
                        pic->get<Integer>("bm/x-dots-per-m"),
                        cmPerM
                    );
                    cInfo.Y_density = roundDiv(
                        pic->get<Integer>("bm/y-dots-per-m"),
                        cmPerM
                    );
                }else{
                    cInfo.density_unit = 0;
                }
            }

            pic->setDefaultIfNotSet("opt/file/jpeg-dct-method", "islow");
            cInfo.dct_method = static_cast<J_DCT_METHOD>(
                dctTypeName.stringToIndex(pic->get<String>("opt/file/jpeg-dct-method"))
            );
            pic->acceptOpt("file/jpeg-dct-method");

            Blob bmData = picBm->get<Blob>("bm/data");

            // Integer number of bytes per pixel assumed
            pic->calculate<PictureProps::PropCalcBmDataSize>();
            Integer bmScanlinePitch = checkedBitsToIntBytes(
                pic->get<Integer>("calc/bm/scanline-pitch-bits")
            );
            BOOST_STATIC_ASSERT(sizeof(JSAMPLE) == 1);

            const Integer scanlinesPerPass = 1;

            runRawC<void>(boost::bind(
                jpeg_start_compress, &cInfo, TRUE
            ));
        
            pic->acceptOpt("file/jpeg-quality");
            pic->acceptOpt("file/jpeg-linear-quality");
            pic->acceptOpt("file/jpeg-force-baseline");

            std::vector<const JSAMPLE*> buffer(scanlinesPerPass);
            Loki::Functor<JDIMENSION> writeScanlines = boost::bind(
                    jpeg_write_scanlines,
                    &cInfo,
                    const_cast<JSAMPLE**>( &(buffer[0]) ),
                    scanlinesPerPass
                );
            while (cInfo.next_scanline < cInfo.image_height) {
                const JSAMPLE *curDestScanLine = reinterpret_cast<const JSAMPLE*>(bmData.getDataReadOnly())+
                    bmScanlinePitch*1*cInfo.next_scanline;
                for(Integer i = 0; i < scanlinesPerPass; i++){
                    buffer[i] = reinterpret_cast<const JSAMPLE*>(
                        curDestScanLine
                    );
                    curDestScanLine += bmScanlinePitch;
                    // @note  No overflow check and s
                }
                runRawC<JDIMENSION>(writeScanlines);
            }

            runRawC<void>(boost::bind(
                jpeg_finish_compress, &cInfo
            ));
        }

        void virtual setPicture(Picture &picture){
            PictureHandler::setPicture(picture);
            picture.set<String>("handler", "jpeg");
        }
    };

    const String JpegPictureHandler::dctTypeNameTable[] = {
        "islow",
        "ifast",
        "float"
    };

    const String JpegPictureHandler::jpegColorSpaceTable[] = {
        "unknown",
        "grayscale",
        "rgb",
        "ycbcr",
        "cmyk",
        "ycck"
    };

    JpegPictureHandler::JpegPictureHandler():
        dctTypeName(ARRAY_SIZE(dctTypeNameTable), dctTypeNameTable),
        jpegColorSpaceString(ARRAY_SIZE(jpegColorSpaceTable), jpegColorSpaceTable)
    {
        decInfo.err = &jerr.pub;
        cInfo.err = &jerr.pub;

        // @c jpeg_create_compress() and @c jpeg_create_decompress() are macros
        runRawC<void>(boost::bind(
            jpeg_CreateDecompress, &decInfo, JPEG_LIB_VERSION,
            sizeof(jpeg_decompress_struct)
        ));
        runRawC<void>(boost::bind(
            jpeg_CreateCompress, &cInfo, JPEG_LIB_VERSION,
            sizeof(jpeg_compress_struct)
        ));
    }

    typedef MgrForPicHandler<JpegPictureHandler> CurrPicHandlerMgr;

    template <> bool CurrPicHandlerMgr::isHandleableByFileExt(Picture &pictureFile) const{
        determineFileExt(pictureFile);
        const String fileExt = pictureFile.get<String>("opt/file/url-extension");
        if(
            fileExt == "jpg" || fileExt == "jpeg" || fileExt == "jpe"
        ){
            return true;
        }else{
            return false;
        }
    }

    template <> bool CurrPicHandlerMgr::isHandleableByContentMagic(Picture &pictureFile) const{
        const Integer magicDataSize = 2;
        const char magicDataCharArray[] ="\xff\xd8";
        const Blob magicData(magicDataSize, magicDataCharArray);
        const Integer magicFileOffset = 0;

        if(haveContentMagic(pictureFile, magicData, magicFileOffset)){
            pictureFile.set<String>("file/mimetype", "image/jpeg");
            return true;
        }else{
            return false;
        }
    }

    template <> bool CurrPicHandlerMgr::isWriteable(Picture &picture) const{
        return (
            picture.get<String>("opt/file/mimetype") == "image/jpeg"
        );
    }
}

LIBNEBULAR_SET_PLUGIN_PIC_HANDLER_MGR(libnebular::CurrPicHandlerMgr)

---