vo_opengl: clean up ewa_lanczos code

This fixes compatibility with GLES 2.0 and makes the code a bit neater
in general. It also properly forces indirect scaling for subsampled
video regardless of the lscale setting.

1 files changed, 5 insertions, 6 deletions

diff --git a/video/out/filter_kernels.c b/video/out/filter_kernels.c
index f2c97b4bde..4faeb0b4b8 100644
--- a/video/out/filter_kernels.c
+++ b/video/out/filter_kernels.c
@@ -58,10 +58,9 @@ bool mp_init_filter(struct filter_kernel *filter, const int *sizes,
 {
     if (filter->radius < 0)
         filter->radius = 3.0;
-    // polar filters can be of any radius, and nothing special is needed
+    // polar filters are dependent only on the radius
     if (filter->polar) {
-        filter->size = filter->radius;
-        filter->num_coefficients = 1;
+        filter->size = 1;
         return true;
     }
     // only downscaling requires widening the filter
@@ -76,14 +75,12 @@ bool mp_init_filter(struct filter_kernel *filter, const int *sizes,
         cursize++;
     if (*cursize) {
         filter->size = *cursize;
-        filter->num_coefficients = filter->size;
         return true;
     } else {
         // The filter doesn't fit - instead of failing completely, use the
         // largest filter available. This is incorrect, but better than refusing
         // to do anything.
         filter->size = cursize[-1];
-        filter->num_coefficients = filter->size;
         filter->inv_scale = filter->size / 2.0 / filter->radius;
         return false;
     }
@@ -110,16 +107,18 @@ void mp_compute_weights(struct filter_kernel *filter, double f, float *out_w)
 }
 
 // Fill the given array with weights for the range [0.0, 1.0]. The array is
-// interpreted as rectangular array of count * filter->num_coefficients items.
+// interpreted as rectangular array of count * filter->size items.
 void mp_compute_lut(struct filter_kernel *filter, int count, float *out_array)
 {
     if (filter->polar) {
+        // Compute a 1D array indexed by radius
         assert(filter->radius > 0);
         for (int x = 0; x < count; x++) {
             double r = x * filter->radius / (count - 1);
             out_array[x] = r <= filter->radius ? filter->weight(filter, r) : 0;
         }
     } else {
+        // Compute a 2D array indexed by subpixel position
         for (int n = 0; n < count; n++) {
             mp_compute_weights(filter, n / (double)(count - 1),
                                out_array + filter->size * n);