jpeg.h

/*
    OGN - Open Glider Network - http://glidernet.org/
    Copyright (c) 2015 The OGN Project

    A detailed list of copyright holders can be found in the file "AUTHORS".

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    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 software.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <stdlib.h>
#include <stdint.h>

#include <setjmp.h>
#include <jpeglib.h>

class JPEG
{ private:
   struct jpeg_compress_struct Compress;           // structures for jpeglib
   struct jpeg_error_mgr       ErrorManager;
   struct jpeg_destination_mgr DestinationManager;
          jmp_buf              ErrorJmp;

  public:
   uint8_t *Data;                                 // compressed JPEG storage
   size_t   Size;                                 // actuall JPEG size
   uint32_t Valid;

  private:
   size_t Allocated;                             // allocated staorage
   static const size_t AllocUnit = 8192;         // storage will be allocated in blocks

  public:
   int Quality;                                  // JPEG quality: 0..100

  private:
   size_t Reallocate(size_t NewSize)            // reallocate JPEG storage to a new (bigger) size
     { // printf("Reallocate(%d)\n", NewSize);
       Data=(uint8_t *)realloc(Data, NewSize);
       if(Data==0) { Allocated=0; Size=0; return 0; } // return zero if not possible to reallocate
       return Allocated=NewSize; }

   static void BufferInit_(jpeg_compress_struct *Compress)
     { JPEG *Client = (JPEG *)Compress->client_data; Client->BufferInit(); }

          void BufferInit(void)
     { if(Allocated<=0) Reallocate(AllocUnit);
       DestinationManager.next_output_byte    = Data;
       DestinationManager.free_in_buffer      = Allocated;
       Size=0; }

   static boolean BufferFull_(jpeg_compress_struct *Compress)
     { JPEG *Client = (JPEG *)Compress->client_data; return Client->BufferFull(); }

          boolean BufferFull(void)
     { Size=Allocated;
       if(Reallocate(Allocated+AllocUnit)<=0)
       { longjmp(ErrorJmp, -1); return FALSE; }
       DestinationManager.next_output_byte    = Data+Size;
       DestinationManager.free_in_buffer      = Allocated-Size;
       return TRUE; }

   static void BufferTerminate_(jpeg_compress_struct *Compress)
     { JPEG *Client = (JPEG *)Compress->client_data; Client->BufferTerminate(); }

          void BufferTerminate(void)
     { Size=Allocated-DestinationManager.free_in_buffer; }

   int Compress_(uint8_t *Image, int Width, int Height,                      // compress Image
                 J_COLOR_SPACE ColorSpace, int BytesPerPixel)
     { Compress.image_width      = Width;
       Compress.image_height     = Height;
       Compress.input_components = BytesPerPixel;
       Compress.in_color_space   = ColorSpace;
       jpeg_set_defaults(&Compress);
       jpeg_set_quality(&Compress, Quality, TRUE);

       jpeg_start_compress(&Compress, TRUE);

       int Row=0;
       if(setjmp(ErrorJmp)) { jpeg_abort_compress(&Compress); Size=0; return -1; }

       for(Row=0; Row<Height; Row++, Image+=(Width*BytesPerPixel))
       { jpeg_write_scanlines(&Compress, &Image, 1); }

       jpeg_finish_compress(&Compress);
       return Size; }

  public:
   JPEG()
     { Data=0; Allocated=0; Size=0;
       Quality=80;
       Compress.err = jpeg_std_error(&ErrorManager);
       jpeg_create_compress(&Compress);
       Compress.client_data = this;
       Compress.dest = &DestinationManager;
       DestinationManager.init_destination    = BufferInit_;        // call-backs
       DestinationManager.empty_output_buffer = BufferFull_;
       DestinationManager.term_destination    = BufferTerminate_;
     }

  ~JPEG()
     { jpeg_destroy_compress(&Compress);
       if(Data) free(Data); }

   int Compress_MONO8(uint8_t *Image, int Width, int Height)        // compress a grey-scale image
     { return Compress_(Image, Width, Height, JCS_GRAYSCALE, 1); }

   int Compress_RGB24(uint8_t *Image, int Width, int Height)        // compress an RGB image
     { return Compress_(Image, Width, Height, JCS_RGB, 3); }

   int Write(char *FileName)                                        // write compressed JPEG image to a file
     { if(Data==0) return 0;
       FILE *File = fopen(FileName, "wb"); if(File==0) return 0;
       size_t Written=fwrite(Data, 1, Size, File);
       fclose(File); return Written; }

} ;