Add plMipmap::CompressJPEG().

This adds an easy way to actually cause mipmaps with JPEG compression to
actually its content. The implementation largely mirrors what Cyan
does... If RLE can get the image down below 5KB, then don't compress.
Otherwise, compress to jpeg.

This is especially useful for Python apps where plJPEG::CompressImage()
still doesn't have bindings.

Author: Hoikas

Python/PRP/Surface/pyMipmap.cpp

@@ -308,6 +308,26 @@ PY_METHOD_KWARGS(Mipmap, CompressImage,
     Py_RETURN_NONE;
 }
 
+PY_METHOD_KWARGS(Mipmap, CompressJPEG,
+    "Params: quality, force\n"
+    "Compresses the mipmap to JPEG format")
+{
+    static char* kwlist[] = { _pycs("quality"), _pycs("force"), nullptr };
+    int quality = 70;
+    int force = 0;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwlist, &quality, &force)) {
+        PyErr_SetString(PyExc_TypeError, "CompressJPEG expects an optional int and an optional boolean");
+        return nullptr;
+    }
+    try {
+        self->fThis->CompressJPEG(quality, force != 0);
+    } catch (const hsBadParamException& ex) {
+        PyErr_SetString(PyExc_RuntimeError, ex.what());
+        return nullptr;
+    }
+    Py_RETURN_NONE;
+}
+
 static PyMethodDef pyMipmap_Methods[] = {
     pyMipmap_readData_method,
     pyMipmap_writeData_method,
@@ -326,6 +346,7 @@ static PyMethodDef pyMipmap_Methods[] = {
     pyMipmap_isAlphaJPEG_method,
     pyMipmap_DecompressImage_method,
     pyMipmap_CompressImage_method,
+    pyMipmap_CompressJPEG_method,
     PY_METHOD_TERMINATOR
 };
 

Python/PyHSPlasma.pyi

@@ -4124,6 +4124,7 @@ class plMipmap(plBitmap):
     def __init__(self, name: str = "") -> None: ...
 
     def CompressImage(self, level: int, data: bytes, quality: int = kBlockQualityNormal) -> None: ...
+    def CompressJPEG(self, quality: int = 70, force: bool = False) -> None: ...
     def DecompressImage(self, level: int) -> bytes: ...
     def extractAlphaData(self) -> bytes: ...
     def extractColorData(self) -> bytes: ...

core/CMakeLists.txt

@@ -656,6 +656,7 @@ set(SDL_HEADERS
 
 set(STREAM_SOURCES
     Stream/hsElfStream.cpp
+    Stream/hsNullStream.cpp
     Stream/hsRAMStream.cpp
     Stream/hsStdioStream.cpp
     Stream/hsStream.cpp
@@ -668,6 +669,7 @@ set(STREAM_SOURCES
 )
 set(STREAM_HEADERS
     Stream/hsElfStream.h
+    Stream/hsNullStream.h
     Stream/hsRAMStream.h
     Stream/hsStdioStream.h
     Stream/hsStream.h

core/PRP/Surface/plMipmap.cpp

@@ -19,11 +19,13 @@
 #include <algorithm>
 #include <cstring>
 #include <cstdlib>
+#include <memory>
 
 #include "Debug/plDebug.h"
 #include "Util/plJPEG.h"
 #include "Util/plPNG.h"
 #include "Util/plDDSurface.h"
+#include "Stream/hsNullStream.h"
 #include "Stream/hsRAMStream.h"
 #include "3rdPartyLibs/squish/squish.h"
 
@@ -771,6 +773,75 @@ void plMipmap::CompressImage(size_t level, void* src, size_t size, BlockQuality
     }
 }
 
+void plMipmap::CompressJPEG(int quality, bool force)
+{
+    if (fCompressionType != kJPEGCompression)
+        throw hsBadParamException(__FILE__, __LINE__, "JPEG compression only supported on JPEG mipmaps");
+
+    // We don't want to recompress if we already have JPEG data.
+    // That can cause data loss, artificating, and diff churn.
+    // But, if they say force... go for it.
+    bool compressColor = fJPEGCache.empty() || force;
+    bool compressAlpha = fJAlphaCache.empty() || force;
+
+    if (!force) {
+        {
+            hsNullStream S;
+            IWriteRLEImage(&S, false);
+            compressColor = S.size() >= 5 * 1024;
+        }
+        {
+            hsNullStream S;
+            IWriteRLEImage(&S, true);
+            compressAlpha = S.size() >= 5 * 1024;
+        }
+    }
+
+    if (compressColor) {
+        auto colorBuf = std::make_unique <uint8_t[]>(fWidth * fHeight * 3);
+
+        // Guess what? plJPEG::CompressImage() expects RGB, not BGR.
+        // Just roll our own conversion loop here.
+        const unsigned char* sp = (const unsigned char*)fImageData;
+        unsigned char* dp = (unsigned char*)colorBuf.get();
+        for (size_t i = 0; i < fLevelData[0].fSize; i += 4) {
+            unsigned char b = *sp++;
+            unsigned char g = *sp++;
+            unsigned char r = *sp++;
+            sp++;           // Skip alpha
+            *dp++ = r;
+            *dp++ = g;
+            *dp++ = b;
+        }
+
+        hsRAMStream S;
+        plJPEG::CompressJPEG(&S, colorBuf.get(), fWidth * fHeight * 3, fWidth, fHeight, 24, quality);
+        fJPEGCache.resize(S.size());
+        memcpy(fJPEGCache.data(), S.data(), S.size());
+    }
+
+    if (compressAlpha) {
+        auto alphaBuf = std::make_unique <uint8_t[]>(fWidth * fHeight * 3);
+
+        // extractAlphaData only extracts 1 byte per pixel, but plJPEG expects 3 bytes per pixel.
+        // Cyan's alpha JPEGs stuff the alpha byte into the red channel only.
+        const unsigned char* sp = (const unsigned char*)fImageData;
+        unsigned char* dp = (unsigned char*)alphaBuf.get();
+        for (size_t i = 0; i < fLevelData[0].fSize; i += 4) {
+            sp += 3;        // Skip RGB
+            *dp++ = *sp++;  // Alpha (R)
+            *dp++ = 0;      // G
+            *dp++ = 0;      // B
+        }
+
+        hsRAMStream S;
+        // Cyan's alpha JPEGs are always 100% quality.
+        plJPEG::CompressJPEG(&S, alphaBuf.get(), fWidth * fHeight * 3, fWidth, fHeight, 24, 100);
+        fJAlphaCache.resize(S.size());
+        memcpy(fJAlphaCache.data(), S.data(), S.size());
+    }
+}
+
 /* plLODMipmap */
 void plLODMipmap::read(hsStream* S, plResManager* mgr)
 {

core/PRP/Surface/plMipmap.h

@@ -112,6 +112,14 @@ class HSPLASMA_EXPORT plMipmap : public plBitmap
     size_t GetUncompressedSize(size_t level) const;
     void DecompressImage(size_t level, void* dest, size_t size) const;
     void CompressImage(size_t level, void* src, size_t size, BlockQuality quality = kBlockQualityNormal);
+
+    /**
+     * Compress mipmap to JPEG format.
+     * This compresses the image data to JPEG with the specified quality.
+     * If the mipmap will not benefit from JPEG compression (i.e. the RLE
+     * map is under 5 KB), then no compression is done unless 'force' is true.
+     */
+    void CompressJPEG(int quality = 70, bool force = false);
 };
 
 

core/Stream/hsNullStream.cpp

@@ -0,0 +1,33 @@
+/* This file is part of HSPlasma.
+ *
+ * HSPlasma 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.
+ *
+ * HSPlasma 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 HSPlasma.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "hsNullStream.h"
+
+size_t hsNullStream::read(size_t size, void*)
+{
+    if (size + fPos > fSize)
+        throw hsFileReadException(__FILE__, __LINE__, "Read past end of buffer");
+    fPos += size;
+    return size;
+}
+
+size_t hsNullStream::write(size_t size, const void*)
+{
+    fPos += size;
+    if (fPos > fSize)
+        fSize = fPos;
+    return size;
+}

core/Stream/hsNullStream.h

@@ -0,0 +1,44 @@
+/* This file is part of HSPlasma.
+ *
+ * HSPlasma 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.
+ *
+ * HSPlasma 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 HSPlasma.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _HSNULLSTREAM_H
+#define _HSNULLSTREAM_H
+
+#include "hsStream.h"
+
+class HSPLASMA_EXPORT hsNullStream : public hsStream
+{
+protected:
+    uint32_t fSize, fPos;
+
+public:
+    explicit hsNullStream(int pv = PlasmaVer::pvUnknown)
+        : hsStream(pv), fSize(), fPos() { }
+
+    uint32_t size() const HS_OVERRIDE { return fSize; }
+    uint32_t pos() const HS_OVERRIDE { return fPos; }
+    bool eof() const HS_OVERRIDE { return (fPos >= fSize); }
+
+    void seek(uint32_t pos) HS_OVERRIDE { fPos = pos; }
+    void skip(int32_t count) HS_OVERRIDE { fPos += count; }
+    void fastForward() HS_OVERRIDE { fPos = fSize; }
+    void rewind() HS_OVERRIDE { fPos = 0; }
+
+    size_t read(size_t size, void* buf) HS_OVERRIDE;
+    size_t write(size_t size, const void* buf) HS_OVERRIDE;
+};
+
+#endif

core/Util/plJPEG.cpp

@@ -330,7 +330,7 @@ plMipmap* plJPEG::DecompressJPEG(hsStream* S)
     return newMipmap;
 }
 
-void plJPEG::CompressJPEG(hsStream* S, void* buf, size_t size, uint32_t width, uint32_t height, uint32_t bpp)
+void plJPEG::CompressJPEG(hsStream* S, void* buf, size_t size, uint32_t width, uint32_t height, uint32_t bpp, int quality)
 {
     plJPEG_CInfo cinfo;
 
@@ -347,7 +347,7 @@ void plJPEG::CompressJPEG(hsStream* S, void* buf, size_t size, uint32_t width, u
         cinfo->in_color_space = JCS_RGB;
 
     jpeg_set_defaults(&cinfo);
-    jpeg_set_quality(&cinfo, 100, TRUE);
+    jpeg_set_quality(&cinfo, quality, TRUE);
     jpeg_start_compress(&cinfo, TRUE);
 
     uint32_t row_stride = cinfo->image_width * cinfo->input_components;

core/Util/plJPEG.h

@@ -47,7 +47,8 @@ class HSPLASMA_EXPORT plJPEG
 
     /* Write JPEG file to stream from bitmap data buffer. */
     static void CompressJPEG(hsStream* S, void* buf, size_t size,
-                             uint32_t width, uint32_t height, uint32_t bpp);
+                             uint32_t width, uint32_t height, uint32_t bpp,
+                             int quality = 100);
 
 private:
     plJPEG() = delete;