yt-dlp support

node_modules/node-webpmux/libwebp/binding.cpp

@@ -0,0 +1,144 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <emscripten.h>
+#include <emscripten/bind.h>
+#include "libwebp/src/webp/encode.h"
+#include "libwebp/src/webp/decode.h"
+
+using namespace emscripten;
+
+class WebPEnc {
+  public:
+    WebPEnc() { this->ready = false; this->picAlloc = false; }
+    ~WebPEnc() { this->reset(); }
+    bool init() {
+      if (this->ready) { return false; }
+      WebPPictureInit(&(this->pic));
+      WebPMemoryWriterInit(&(this->writer));
+      this->pic.writer = WebPMemoryWrite;
+      this->pic.custom_ptr = &(this->writer);
+      WebPConfigInit(&(this->config));
+      this->ready = true;
+      return true;
+    }
+    void reset() {
+      if (!this->ready) { return; }
+      if (this->picAlloc) { WebPPictureFree(&(this->pic)); }
+      WebPMemoryWriterClear(&(this->writer));
+      this->ready = false;
+      this->picAlloc = false;
+    }
+    // Clunky workaround for Embind not supporting pointers to primitives (first argument should be a const uint8_t *)
+    bool loadRGBA(const int input, int width, int height) {
+      if (!this->ready) { return false; }
+      this->pic.width = width;
+      this->pic.height = height;
+      WebPPictureImportRGBA(&(this->pic), reinterpret_cast<const uint8_t *>(input), width * 4);
+      this->picAlloc = true;
+      return true;
+    }
+    bool setPreset(int en) {
+      if (!this->ready) { return false; }
+      if (en > 0) { WebPConfigPreset(&(this->config), (WebPPreset)en, 100.0f); }
+      else { WebPConfigInit(&(this->config)); }
+      return true;
+    }
+    bool setLosslessPreset(int en) {
+      if (!this->ready) { return false; }
+      if (en > 0) { WebPConfigLosslessPreset(&(this->config), en); this->pic.use_argb = 1; }
+      else { WebPConfigInit(&(this->config)); this->pic.use_argb = 0; }
+      return true;
+    }
+    bool setQuality(float q) { if (!this->ready) { return false; } this->config.quality = q; return true; }
+    bool setMethod(int m) { if (!this->ready) { return false; } this->config.method = m; return true; }
+    bool setExact(bool ex) { if (!this->ready) { return false; } this->config.exact = ex ? 1 : 0; return true; }
+    int encode() {
+      if (!this->ready) { return -1; }
+      if (!WebPValidateConfig(&(this->config))) { return -2; }
+      if (!WebPEncode(&(this->config), &(this->pic))) { return this->pic.error_code; }
+      return 0;
+    }
+    // Clunky workaround for Embind not supporting pointers to primitives (this should return uint8_t*)
+    int getResult() { return (int)this->writer.mem; }
+    size_t getResultSize() { return this->writer.size; }
+    bool advImageHint(int en) { if (!this->ready) { return false; } this->config.image_hint = (WebPImageHint)en; return true; }
+    bool advTargetSize(int s) { if (!this->ready) { return false; } this->config.target_size = s; return true; }
+    bool advTargetPSNR(float psnr) { if (!this->ready) { return false; } this->config.target_PSNR = psnr; return true; }
+    bool advSegments(int seg) { if (!this->ready) { return false; } this->config.segments = seg; return true; }
+    bool advSnsStrength(int str) { if (!this->ready) { return false; } this->config.sns_strength = str; return true; }
+    bool advFilterStrength(int str) { if (!this->ready) { return false; } this->config.filter_strength = str; return true; }
+    bool advFilterSharpness(int shr) { if (!this->ready) { return false; } this->config.filter_sharpness = shr ? 1 : 0; return true; }
+    bool advFilterType(int type) { if (!this->ready) { return false; } this->config.filter_type = type ? 1 : 0; return true; }
+    bool advAutoFilter(int filter) { if (!this->ready) { return false; } this->config.autofilter = filter ? 1 : 0; return true; }
+    bool advAlphaCompression(int comp) { if (!this->ready) { return false; } this->config.alpha_compression = comp; return true; }
+    bool advAlphaFiltering(int filter) { if (!this->ready) { return false; } this->config.alpha_filtering = filter; return true; }
+    bool advAlphaQuality(int qual) { if (!this->ready) { return false; } this->config.alpha_quality = qual; return true; }
+    bool advPass(int pass) { if (!this->ready) { return false; } this->config.pass = pass; return true; }
+    bool advShowCompressed(int comp) { if (!this->ready) { return false; } this->config.show_compressed = comp ? 1 : 0; return true; }
+    bool advPreprocessing(int prepro) { if (!this->ready) { return false; } this->config.preprocessing = prepro; return true; }
+    bool advPartitions(int parts) { if (!this->ready) { return false; } this->config.partitions = parts; return true; }
+    bool advPartitionLimit(int limit) { if (!this->ready) { return false; } this->config.partition_limit = limit; return true; }
+    bool advEmulateJpegSize(int emulate) { if (!this->ready) { return false; } this->config.emulate_jpeg_size = emulate ? 1 : 0; return true; }
+    bool advThreadLevel(int threads) { if (!this->ready) { return false; } this->config.thread_level = threads; return true; }
+    bool advLowMemory(int low) { if (!this->ready) { return false; } this->config.low_memory = low ? 1 : 0; return true; }
+    bool advNearLossless(int near) { if (!this->ready) { return false; } this->config.near_lossless = near; return true; }
+    bool advUseDeltaPalette(int delta) { if (!this->ready) { return false; } this->config.use_delta_palette = 0 /*delta*/; return true; }
+    bool advUseSharpYUV(int sharp) { if (!this->ready) { return false; } this->config.use_sharp_yuv = sharp ? 1 : 0; return true; }
+    bool advQMin(int min) { if (!this->ready) { return false; } this->config.qmin = min; return true; }
+    bool advQMax(int max) { if (!this->ready) { return false; } this->config.qmax = max; return true; }
+  private:
+    bool ready;
+    bool picAlloc;
+    WebPConfig config;
+    WebPPicture pic;
+    WebPMemoryWriter writer;
+};
+// Encoder hooks
+EMSCRIPTEN_BINDINGS(WebPBinding) {
+  class_<WebPEnc>("WebPEnc")
+  .constructor<>()
+  .function("init", &WebPEnc::init)
+  .function("reset", &WebPEnc::reset)
+  .function("loadRGBA", &WebPEnc::loadRGBA)
+  .function("setPreset", &WebPEnc::setPreset)
+  .function("setLosslessPreset", &WebPEnc::setLosslessPreset)
+  .function("setQuality", &WebPEnc::setQuality)
+  .function("setMethod", &WebPEnc::setMethod)
+  .function("setExact", &WebPEnc::setExact)
+  .function("encode", &WebPEnc::encode)
+  .function("getResult", &WebPEnc::getResult)
+  .function("getResultSize", &WebPEnc::getResultSize)
+  .function("advImageHint", &WebPEnc::advImageHint)
+  .function("advTargetSize", &WebPEnc::advTargetSize)
+  .function("advTargetPSNR", &WebPEnc::advTargetPSNR)
+  .function("advSegments", &WebPEnc::advSegments)
+  .function("advSnsStrength", &WebPEnc::advSnsStrength)
+  .function("advFilterStrength", &WebPEnc::advFilterStrength)
+  .function("advFilterSharpness", &WebPEnc::advFilterSharpness)
+  .function("advFilterType", &WebPEnc::advFilterType)
+  .function("advAutoFilter", &WebPEnc::advAutoFilter)
+  .function("advAlphaCompression", &WebPEnc::advAlphaCompression)
+  .function("advAlphaFiltering", &WebPEnc::advAlphaFiltering)
+  .function("advAlphaQuality", &WebPEnc::advAlphaQuality)
+  .function("advPass", &WebPEnc::advPass)
+  .function("advShowCompressed", &WebPEnc::advShowCompressed)
+  .function("advPreprocessing", &WebPEnc::advPreprocessing)
+  .function("advPartitions", &WebPEnc::advPartitions)
+  .function("advPartitionLimit", &WebPEnc::advPartitionLimit)
+  .function("advEmulateJpegSize", &WebPEnc::advEmulateJpegSize)
+  .function("advThreadLevel", &WebPEnc::advThreadLevel)
+  .function("advLowMemory", &WebPEnc::advLowMemory)
+  .function("advNearLossless", &WebPEnc::advNearLossless)
+  .function("advUseDeltaPalette", &WebPEnc::advUseDeltaPalette)
+  .function("advUseSharpYUV", &WebPEnc::advUseSharpYUV)
+  .function("advQMin", &WebPEnc::advQMin)
+  .function("advQMax", &WebPEnc::advQMax);
+}
+extern "C" {
+  // Decoder
+  EMSCRIPTEN_KEEPALIVE uint8_t *decodeRGBA(const uint8_t *data, size_t dataSize) { return WebPDecodeRGBA(data, dataSize, 0, 0); }
+  EMSCRIPTEN_KEEPALIVE void decodeFree(uint8_t *data) { WebPFree(data); }
+  // Utility
+  EMSCRIPTEN_KEEPALIVE uint8_t *allocBuffer(size_t size) { return (uint8_t*)malloc(size * sizeof(uint8_t)); }
+  EMSCRIPTEN_KEEPALIVE void destroyBuffer(uint8_t *p) { free(p); }
+}