Ticket #1801: mplayer_vdpau-surface.2.diff

libvo/vo_vdpau.c

@@ -79 +79 @@
 /* number of palette entries */
 #define PALETTE_SIZE 256
 
-/* Initial maximum number of EOSD surfaces */
-#define EOSD_SURFACES_INITIAL 512
+/* Initial maximum number of EOSD surfaces - this should already be more than enough */
+#define EOSD_SURFACES_INITIAL 16
+
+/* Maximum size of vdpau bitmap surface */
+#define VDPAU_BITMAP_SURFACE_MAXSIZE 8192
 
 /*
  * Global variable declaration - VDPAU specific
@@ -188 +191 @@
 // Pool of surfaces
 struct {
     VdpBitmapSurface surface;
-    int w;
-    int h;
-    char in_use;
+    unsigned int w;
+    unsigned int h;
+    unsigned short in_use;
 } *eosd_surfaces;
 
-// List of surfaces to be rendered
+// List of glyphs to be rendered
 struct {
     VdpBitmapSurface surface;
     VdpRect source;
@@ -201 +204 @@
     VdpColor color;
 } *eosd_targets;
 
+// counters
 static int eosd_render_count;
 static int eosd_surface_count;
 
+// sizes
+static int eosd_render_size;
+
 // Video equalizer
 static VdpProcamp procamp;
 
@@ -854 +861 @@
     }
 }
 
+static int eosd_invalidGlyph(ASS_Image* i)
+{
+    // Invalid bitmap sizes
+    if (i->w < 0 || i->h < 0 || i->stride < 0
+        || i->w > VDPAU_BITMAP_SURFACE_MAXSIZE
+        || i->h > VDPAU_BITMAP_SURFACE_MAXSIZE)
+       return -1;
+    return 0;
+}
+
 static void generate_eosd(EOSD_ImageList *imgs)
 {
     VdpStatus vdp_st;
-    VdpRect destRect;
-    int j, found;
+    VdpRect vdp_surface_rect;
+    int j, found, start_x;
     ASS_Image *img = imgs->imgs;
     ASS_Image *i;
+    ASS_Image *i_prev;
 
     // Nothing changed, no need to redraw
     if (imgs->changed == 0)
         return;
+
+    // Hide eosd again ...
     eosd_render_count = 0;
+
     // There's nothing to render!
     if (!img)
         return;
@@ -873 +894 @@
     if (imgs->changed == 1)
         goto eosd_skip_upload;
 
-    for (j = 0; j < eosd_surface_count; j++)
+    // OPTIONAL: No need to try to reuse - simplification
+    for (j = 0; j < eosd_surface_count; j++) {
         eosd_surfaces[j].in_use = 0;
+        //if (eosd_surfaces[j].surface != VDP_INVALID_HANDLE) {
+        //    vdp_bitmap_surface_destroy(eosd_surfaces[j].surface);
+        //    CHECK_ST_WARNING("Error when calling vdp_bitmap_surface_destroy")
+        //    eosd_surfaces[j].surface = VDP_INVALID_HANDLE;
+        //}
+    }
+
+    // Initialize handling of surfaces
+    found = 0;
+    vdp_surface_rect.x1 = 0;
+    vdp_surface_rect.y1 = 0;
 
     for (i = img; i; i = i->next) {
-        // Try to reuse a suitable surface
-        found = -1;
-        for (j = 0; j < eosd_surface_count; j++) {
-            if (eosd_surfaces[j].surface != VDP_INVALID_HANDLE && !eosd_surfaces[j].in_use &&
-                eosd_surfaces[j].w >= i->w && eosd_surfaces[j].h >= i->h) {
-                found = j;
-                break;
-            }
+        if (eosd_invalidGlyph (i))
+            continue;
+
+        // Create bitmap surface and restart with current glyph
+        if (vdp_surface_rect.x1 + i->w > VDPAU_BITMAP_SURFACE_MAXSIZE) {
+            i = i_prev;
+
+        // Collect glyphs for one surface
+        } else {
+            // Get render count
+            eosd_render_count++;
+
+            i_prev = i;
+            vdp_surface_rect.x1 += i->w;
+
+            if (i->h > vdp_surface_rect.y1)
+                vdp_surface_rect.y1 = i->h;
+            if (i->next)
+                continue;
         }
-        // None found, allocate a new surface
-        if (found < 0) {
-            for (j = 0; j < eosd_surface_count; j++) {
-                if (!eosd_surfaces[j].in_use) {
-                    if (eosd_surfaces[j].surface != VDP_INVALID_HANDLE)
-                        vdp_bitmap_surface_destroy(eosd_surfaces[j].surface);
-                    found = j;
-                    break;
-                }
+
+        // Allocate new space for surface arrays
+        if (eosd_surface_count <= found) {
+            j = eosd_surface_count;
+            eosd_surface_count = eosd_surface_count ? eosd_surface_count*2 : EOSD_SURFACES_INITIAL;
+            eosd_surfaces = realloc(eosd_surfaces, eosd_surface_count * sizeof(*eosd_surfaces));
+            for (; j < eosd_surface_count; j++) {
+                eosd_surfaces[j].surface = VDP_INVALID_HANDLE;
+                eosd_surfaces[j].in_use = 0;
             }
-            // Allocate new space for surface/target arrays
-            if (found < 0) {
-                j = found = eosd_surface_count;
-                eosd_surface_count = eosd_surface_count ? eosd_surface_count*2 : EOSD_SURFACES_INITIAL;
-                eosd_surfaces = realloc(eosd_surfaces, eosd_surface_count * sizeof(*eosd_surfaces));
-                eosd_targets  = realloc(eosd_targets,  eosd_surface_count * sizeof(*eosd_targets));
-                for (j = found; j < eosd_surface_count; j++) {
-                    eosd_surfaces[j].surface = VDP_INVALID_HANDLE;
-                    eosd_surfaces[j].in_use = 0;
-                }
+        }
+
+        // OPTIONAL: No need to try to reuse - simplification
+        if (eosd_surfaces[found].surface == VDP_INVALID_HANDLE ||
+            eosd_surfaces[found].w < vdp_surface_rect.x1 || eosd_surfaces[found].h < vdp_surface_rect.y1) {
+            // Destroy surface
+            if (eosd_surfaces[found].surface != VDP_INVALID_HANDLE) {
+                vdp_bitmap_surface_destroy(eosd_surfaces[found].surface);
+                CHECK_ST_WARNING("Error when calling vdp_bitmap_surface_destroy")
+
+                // Increase w or h only - relax oscillation
+                vdp_surface_rect.x1 = (vdp_surface_rect.x1 < eosd_surfaces[found].w) ? eosd_surfaces[found].w : vdp_surface_rect.x1;
+                vdp_surface_rect.y1 = (vdp_surface_rect.y1 < eosd_surfaces[found].h) ? eosd_surfaces[found].h : vdp_surface_rect.y1;
             }
+
+            // Create bigger surface
             vdp_st = vdp_bitmap_surface_create(vdp_device, VDP_RGBA_FORMAT_A8,
-                i->w, i->h, VDP_TRUE, &eosd_surfaces[found].surface);
+                vdp_surface_rect.x1, vdp_surface_rect.y1, VDP_TRUE, &eosd_surfaces[found].surface);
             CHECK_ST_WARNING("EOSD: error when creating surface")
-            eosd_surfaces[found].w = i->w;
-            eosd_surfaces[found].h = i->h;
+            eosd_surfaces[found].w = vdp_surface_rect.x1;
+            eosd_surfaces[found].h = vdp_surface_rect.y1;
+
+            //printf ("surface: n:%d w:%d h:%d c:%d ...\n", found, vdp_surface_rect.x1, vdp_surface_rect.y1, eosd_render_count);
         }
-        eosd_surfaces[found].in_use = 1;
+
+        eosd_surfaces[found].in_use = eosd_render_count;
+
+        // Set surface data
+        vdp_surface_rect.x1 = 0;
+        vdp_surface_rect.y1 = 0;
+
+        // Get surface count
+        found++;
+    }
+
+    // Allocate new space for target arrays
+    if (eosd_render_size < eosd_render_count) {
+        eosd_render_size = eosd_render_count;
+
+        eosd_targets = realloc(eosd_targets, eosd_render_count * sizeof(*eosd_targets));
+    }
+
+    start_x = 0;
+    found = 0;
+    eosd_render_count = 0;
+
+    for (i = img; i; i = i->next) {
+        if (eosd_invalidGlyph (i))
+            continue;
+
+        if (eosd_render_count == eosd_surfaces[found].in_use) {
+            found++;
+            start_x = 0;
+        }
+
         eosd_targets[eosd_render_count].surface = eosd_surfaces[found].surface;
-        destRect.x0 = 0;
-        destRect.y0 = 0;
-        destRect.x1 = i->w;
-        destRect.y1 = i->h;
+        eosd_targets[eosd_render_count].source.x0 = start_x;
+        eosd_targets[eosd_render_count].source.y0 = 0;
+        eosd_targets[eosd_render_count].source.x1 = start_x + i->w;
+        eosd_targets[eosd_render_count].source.y1 = i->h;
+
+        //printf ("rect: n:%d w:%d h:%d x:%d y:%d ...\n", found, i->w, i->h, eosd_targets[eosd_render_count].source.x0, eosd_targets[eosd_render_count].source.y0 );
+
         vdp_st = vdp_bitmap_surface_putbits_native(eosd_targets[eosd_render_count].surface,
-            (const void *) &i->bitmap, &i->stride, &destRect);
+            (const void *) &i->bitmap, &i->stride, &eosd_targets[eosd_render_count].source);
         CHECK_ST_WARNING("EOSD: putbits failed")
+
+        start_x += i->w;
         eosd_render_count++;
     }
 
 eosd_skip_upload:
     eosd_render_count = 0;
     for (i = img; i; i = i->next) {
-        // Render dest, color, etc.
+        if (eosd_invalidGlyph (i))
+            continue;
+
+        // Render dest and color only
         eosd_targets[eosd_render_count].color.alpha = 1.0 - ((i->color >>  0) & 0xff) / 255.0;
         eosd_targets[eosd_render_count].color.blue  =       ((i->color >>  8) & 0xff) / 255.0;
         eosd_targets[eosd_render_count].color.green =       ((i->color >> 16) & 0xff) / 255.0;
         eosd_targets[eosd_render_count].color.red   =       ((i->color >> 24) & 0xff) / 255.0;
-        eosd_targets[eosd_render_count].dest.x0     =        i->dst_x;
-        eosd_targets[eosd_render_count].dest.y0     =        i->dst_y;
-        eosd_targets[eosd_render_count].dest.x1     = i->w + i->dst_x;
-        eosd_targets[eosd_render_count].dest.y1     = i->h + i->dst_y;
-        eosd_targets[eosd_render_count].source.x0   = 0;
-        eosd_targets[eosd_render_count].source.y0   = 0;
-        eosd_targets[eosd_render_count].source.x1   = i->w;
-        eosd_targets[eosd_render_count].source.y1   = i->h;
+
+        //printf ("color: r:%f g:%f b:%f a:%f ...\n", eosd_targets[eosd_render_count].color.red, eosd_targets[eosd_render_count].color.green, eosd_targets[eosd_render_count].color.blue, eosd_targets[eosd_render_count].color.alpha);
+
+        eosd_targets[eosd_render_count].dest.x0     = i->dst_x;
+        eosd_targets[eosd_render_count].dest.y0     = i->dst_y;
+        eosd_targets[eosd_render_count].dest.x1     = i->dst_x + i->w;
+        eosd_targets[eosd_render_count].dest.y1     = i->dst_y + i->h;
         eosd_render_count++;
     }
 }
@@ -1269 +1357 @@
     index_data_size = 0;
 
     eosd_surface_count = eosd_render_count = 0;
+    eosd_render_size = 0;
     eosd_surfaces = NULL;
     eosd_targets  = NULL;