Restructure renderBlend so it can return multiple pieces; JS side not ready yet

Author: JustAMan

src/SubtitleOctopus.cpp

@@ -59,6 +59,9 @@ class ReusableBuffer {
         lessen_counter = 0;
         return buffer;
     }
+    int capacity() const {
+        return size;
+    }
 
 private:
     void *buffer;
@@ -79,13 +82,25 @@ const float MAX_UINT8_CAST = 255.9 / 255;
 
 #define CLAMP_UINT8(value) ((value > MIN_UINT8_CAST) ? ((value < MAX_UINT8_CAST) ? (int)(value * 255) : 255) : 0)
 
+typedef struct {
+    int dest_x, dest_y, dest_width, dest_height;
+    unsigned char *image;
+    RenderBlendPart *next;
+} RenderBlendPart;
+
 typedef struct {
     int changed;
     double blend_time;
-    int dest_x, dest_y, dest_width, dest_height;
-    unsigned char* image;
+    RenderBlendPart *part;
 } RenderBlendResult;
 
+#define MAX_BLEND_STORAGES 9
+typedef struct {
+    RenderBlendPart part;
+    ReusableBuffer buf;
+    bool taken;
+} RenderBlendStorage;
+
 typedef struct {
     double eventFinish, emptyFinish;
     int is_animated;
@@ -376,6 +391,9 @@ class SubtitleOctopus {
         }
 
         double start_blend_time = emscripten_get_now();
+        for (int i = 0; i < MAX_BLEND_STORAGES; i++) {
+            m_blendParts[i].taken = false;
+        }
 
         // find bounding rect first
         int min_x = img->dst_x, min_y = img->dst_y;
@@ -390,84 +408,11 @@ class SubtitleOctopus {
             if (bottom > max_y) max_y = bottom;
         }
 
-        // make float buffer for blending
-        int width = max_x - min_x + 1, height = max_y - min_y + 1;
-        float* buf = (float*)m_blend.take(sizeof(float) * width * height * 4, 0);
-        if (buf == NULL) {
-            printf("libass: error: cannot allocate buffer for blending");
-            return NULL;
-        }
-        memset(buf, 0, sizeof(float) * width * height * 4);
-
-        // blend things in
-        for (cur = img; cur != NULL; cur = cur->next) {
-            int curw = cur->w, curh = cur->h;
-            if (curw == 0 || curh == 0) continue; // skip empty images
-            int a = (255 - (cur->color & 0xFF));
-            if (a == 0) continue; // skip transparent images
-
-            int curs = (cur->stride >= curw) ? cur->stride : curw;
-            int curx = cur->dst_x - min_x, cury = cur->dst_y - min_y;
-
-            unsigned char *bitmap = cur->bitmap;
-            float normalized_a = a / 255.0;
-            float r = ((cur->color >> 24) & 0xFF) / 255.0;
-            float g = ((cur->color >> 16) & 0xFF) / 255.0;
-            float b = ((cur->color >> 8) & 0xFF) / 255.0;
-
-            int buf_line_coord = cury * width;
-            for (int y = 0, bitmap_offset = 0; y < curh; y++, bitmap_offset += curs, buf_line_coord += width)
-            {
-                for (int x = 0; x < curw; x++)
-                {
-                    float pix_alpha = bitmap[bitmap_offset + x] * normalized_a / 255.0;
-                    float inv_alpha = 1.0 - pix_alpha;
-                    
-                    int buf_coord = (buf_line_coord + curx + x) << 2;
-                    float *buf_r = buf + buf_coord;
-                    float *buf_g = buf + buf_coord + 1;
-                    float *buf_b = buf + buf_coord + 2;
-                    float *buf_a = buf + buf_coord + 3;
-                    
-                    // do the compositing, pre-multiply image RGB with alpha for current pixel
-                    *buf_a = pix_alpha + *buf_a * inv_alpha;
-                    *buf_r = r * pix_alpha + *buf_r * inv_alpha;
-                    *buf_g = g * pix_alpha + *buf_g * inv_alpha;
-                    *buf_b = b * pix_alpha + *buf_b * inv_alpha;
-                }
-            }
-        }
-
-        // now build the result;
-        // NOTE: we use a "view" over [float,float,float,float] array of pixels,
-        // so we _must_ go left-right top-bottom to not mangle the result
-        unsigned int *result = (unsigned int*)buf;
-        for (int y = 0, buf_line_coord = 0; y < height; y++, buf_line_coord += width) {
-            for (int x = 0; x < width; x++) {
-                unsigned int pixel = 0;
-                int buf_coord = (buf_line_coord + x) << 2;
-                float alpha = buf[buf_coord + 3];
-                if (alpha > MIN_UINT8_CAST) {
-                    // need to un-multiply the result
-                    float value = buf[buf_coord] / alpha;
-                    pixel |= CLAMP_UINT8(value); // R
-                    value = buf[buf_coord + 1] / alpha;
-                    pixel |= CLAMP_UINT8(value) << 8; // G
-                    value = buf[buf_coord + 2] / alpha;
-                    pixel |= CLAMP_UINT8(value) << 16; // B
-                    pixel |= CLAMP_UINT8(alpha) << 24; // A
-                }
-                result[buf_line_coord + x] = pixel;
-            }
-        }
-        
-        // return the thing
-        m_blendResult.dest_x = min_x;
-        m_blendResult.dest_y = min_y;
-        m_blendResult.dest_width = width;
-        m_blendResult.dest_height = height;
+        RenderBlendPart *part = renderBlendPart(min_x, min_y, max_x, max_y, img);
+        part->next = NULL;
+        m_blendResult.part = part;
         m_blendResult.blend_time = emscripten_get_now() - start_blend_time;
-        m_blendResult.image = (unsigned char*)result;
+
         return &m_blendResult;
     }
 
@@ -562,8 +507,116 @@ class SubtitleOctopus {
     }
 
 private:
+    RenderBlendPart* renderBlendPart(int min_x, int min_y, int max_x, int max_y, ASS_Image* img) {
+        // make float buffer for blending
+        int width = max_x - min_x + 1, height = max_y - min_y + 1;
+        float* buf = (float*)m_blend.take(sizeof(float) * width * height * 4, 0);
+        if (buf == NULL) {
+            printf("libass: error: cannot allocate buffer for blending");
+            return NULL;
+        }
+        memset(buf, 0, sizeof(float) * width * height * 4);
+
+        // blend things in
+        for (ASS_Image *cur = img; cur != NULL; cur = cur->next) {
+            if (cur->dst_x < min_x || cur->dst_y < min_y) continue; // skip images not fully within render region
+            int curw = cur->w, curh = cur->h;
+            if (curw == 0 || curh == 0 || cur->dst_x + curw > max_x || cur->dst_y + curh > max_y) continue; // skip empty images or images outside render region
+            int a = (255 - (cur->color & 0xFF));
+            if (a == 0) continue; // skip transparent images
+
+            int curs = (cur->stride >= curw) ? cur->stride : curw;
+            int curx = cur->dst_x - min_x, cury = cur->dst_y - min_y;
+
+            unsigned char *bitmap = cur->bitmap;
+            float normalized_a = a / 255.0;
+            float r = ((cur->color >> 24) & 0xFF) / 255.0;
+            float g = ((cur->color >> 16) & 0xFF) / 255.0;
+            float b = ((cur->color >> 8) & 0xFF) / 255.0;
+
+            int buf_line_coord = cury * width;
+            for (int y = 0, bitmap_offset = 0; y < curh; y++, bitmap_offset += curs, buf_line_coord += width)
+            {
+                for (int x = 0; x < curw; x++)
+                {
+                    float pix_alpha = bitmap[bitmap_offset + x] * normalized_a / 255.0;
+                    float inv_alpha = 1.0 - pix_alpha;
+                    
+                    int buf_coord = (buf_line_coord + curx + x) << 2;
+                    float *buf_r = buf + buf_coord;
+                    float *buf_g = buf + buf_coord + 1;
+                    float *buf_b = buf + buf_coord + 2;
+                    float *buf_a = buf + buf_coord + 3;
+                    
+                    // do the compositing, pre-multiply image RGB with alpha for current pixel
+                    *buf_a = pix_alpha + *buf_a * inv_alpha;
+                    *buf_r = r * pix_alpha + *buf_r * inv_alpha;
+                    *buf_g = g * pix_alpha + *buf_g * inv_alpha;
+                    *buf_b = b * pix_alpha + *buf_b * inv_alpha;
+                }
+            }
+        }
+
+        // find closest free buffer
+        int needed = sizeof(unsigned int) * width * height;
+        RenderBlendStorage *storage = m_blendParts, *bigBuffer = NULL, *smallBuffer = NULL;
+        for (int buffer_index = 0; buffer_index < MAX_BLEND_STORAGES; buffer_index++, storage++) {
+            if (storage->taken) continue;
+            if (storage->buf.capacity() >= needed) {
+                if (bigBuffer == NULL || bigBuffer->buf.capacity() > storage->buf.capacity()) bigBuffer = storage;
+            } else {
+                if (smallBuffer == NULL || smallBuffer->buf.capacity() > storage->buf.capacity()) smallBuffer = storage;
+            }
+        }
+
+        if (bigBuffer != NULL) {
+            storage = bigBuffer;
+        } else if (smallBuffer != NULL) {
+            storage = smallBuffer;
+        } else {
+            printf("libass: cannot get a buffer for rendering part!\n");
+            return NULL;
+        }
+           
+        unsigned int *result = (unsigned int*)storage->buf.take(needed, false);
+        if (result == NULL) {
+            printf("libass: cannot make a buffer for rendering part!\n");
+            return NULL;
+        }
+        storage->taken = true;
+
+        // now build the result;
+        for (int y = 0, buf_line_coord = 0; y < height; y++, buf_line_coord += width) {
+            for (int x = 0; x < width; x++) {
+                unsigned int pixel = 0;
+                int buf_coord = (buf_line_coord + x) << 2;
+                float alpha = buf[buf_coord + 3];
+                if (alpha > MIN_UINT8_CAST) {
+                    // need to un-multiply the result
+                    float value = buf[buf_coord] / alpha;
+                    pixel |= CLAMP_UINT8(value); // R
+                    value = buf[buf_coord + 1] / alpha;
+                    pixel |= CLAMP_UINT8(value) << 8; // G
+                    value = buf[buf_coord + 2] / alpha;
+                    pixel |= CLAMP_UINT8(value) << 16; // B
+                    pixel |= CLAMP_UINT8(alpha) << 24; // A
+                }
+                result[buf_line_coord + x] = pixel;
+            }
+        }
+        
+        // return the thing
+        storage->part.dest_x = min_x;
+        storage->part.dest_y = min_y;
+        storage->part.dest_width = width;
+        storage->part.dest_height = height;
+        storage->part.image = (unsigned char*)result;
+        return &storage->part;
+    }
+
     ReusableBuffer m_blend;
     RenderBlendResult m_blendResult;
+    RenderBlendStorage m_blendParts[MAX_BLEND_STORAGES];
     int *m_is_event_animated;
     bool m_drop_animations;
 };