video: remove things related to old DR code

Remove mp_image.width/height. The w/h members are the ones to use.
width/height were used internally by vf_get_image(), and sometimes for
other purposes.

Remove some image flags, most of which are now useless or completely
unused. This includes VFCAP_ACCEPT_STRIDE: the vf_expand insertion in
vf.c does nothing.

Remove some other unused mp_image fields.

Some rather messy changes in vo_opengl[_old] to get rid of legacy
mp_image flags and fields. This is left from when vo_gl supported DR.

5 files changed, 54 insertions, 72 deletions

diff --git a/video/out/vo_opengl.c b/video/out/vo_opengl.c
index fc94a86eac..aa6f9243f3 100644
--- a/video/out/vo_opengl.c
+++ b/video/out/vo_opengl.c
@@ -1237,29 +1237,23 @@ static void flip_page(struct vo *vo)
     p->frames_rendered++;
 }
 
-static uint32_t get_image(struct vo *vo, mp_image_t *mpi)
+static bool get_image(struct vo *vo, mp_image_t *mpi)
 {
     struct gl_priv *p = vo->priv;
     GL *gl = p->gl;
 
     if (!p->use_pbo)
-        return VO_FALSE;
+        return false;
 
     // We don't support alpha planes. (Disabling PBOs with normal draw calls is
     // an undesired, but harmless side-effect.)
     if (mpi->num_planes != p->plane_count)
-        return VO_FALSE;
-
-    if (mpi->flags & MP_IMGFLAG_READABLE)
-        return VO_FALSE;
-    if (mpi->type != MP_IMGTYPE_STATIC && mpi->type != MP_IMGTYPE_TEMP &&
-        (mpi->type != MP_IMGTYPE_NUMBERED || mpi->number))
-        return VO_FALSE;
-    mpi->flags &= ~MP_IMGFLAG_COMMON_PLANE;
+        return false;
+
     for (int n = 0; n < p->plane_count; n++) {
         struct texplane *plane = &p->planes[n];
-        mpi->stride[n] = (mpi->width >> plane->shift_x) * p->plane_bytes;
-        int needed_size = (mpi->height >> plane->shift_y) * mpi->stride[n];
+        mpi->stride[n] = (mpi->w >> plane->shift_x) * p->plane_bytes;
+        int needed_size = (mpi->h >> plane->shift_y) * mpi->stride[n];
         if (!plane->gl_buffer)
             gl->GenBuffers(1, &plane->gl_buffer);
         gl->BindBuffer(GL_PIXEL_UNPACK_BUFFER, plane->gl_buffer);
@@ -1274,8 +1268,7 @@ static uint32_t get_image(struct vo *vo, mp_image_t *mpi)
         mpi->planes[n] = plane->buffer_ptr;
         gl->BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
     }
-    mpi->flags |= MP_IMGFLAG_DIRECT;
-    return VO_TRUE;
+    return true;
 }
 
 static void draw_image(struct vo *vo, mp_image_t *mpi)
@@ -1288,14 +1281,8 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
 
     mp_image_t mpi2 = *mpi;
     int w = mpi->w, h = mpi->h;
-    mpi2.flags = 0;
-    mpi2.type = MP_IMGTYPE_TEMP;
-    mpi2.width = mpi2.w;
-    mpi2.height = mpi2.h;
-    if (!(mpi->flags & MP_IMGFLAG_DIRECT)
-        && !p->planes[0].buffer_ptr
-        && get_image(p->vo, &mpi2) == VO_TRUE)
-    {
+    bool pbo = false;
+    if (!p->planes[0].buffer_ptr && get_image(p->vo, &mpi2)) {
         for (n = 0; n < p->plane_count; n++) {
             struct texplane *plane = &p->planes[n];
             int xs = plane->shift_x, ys = plane->shift_y;
@@ -1304,13 +1291,14 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
                        mpi2.stride[n], mpi->stride[n]);
         }
         mpi = &mpi2;
+        pbo = true;
     }
     p->mpi_flipped = mpi->stride[0] < 0;
     for (n = 0; n < p->plane_count; n++) {
         struct texplane *plane = &p->planes[n];
         int xs = plane->shift_x, ys = plane->shift_y;
         void *plane_ptr = mpi->planes[n];
-        if (mpi->flags & MP_IMGFLAG_DIRECT) {
+        if (pbo) {
             gl->BindBuffer(GL_PIXEL_UNPACK_BUFFER, plane->gl_buffer);
             if (!gl->UnmapBuffer(GL_PIXEL_UNPACK_BUFFER))
                 mp_msg(MSGT_VO, MSGL_FATAL, "[gl] Video PBO upload failed. "
@@ -1638,7 +1626,7 @@ static bool init_format(int fmt, struct gl_priv *init)
 static int query_format(struct vo *vo, uint32_t format)
 {
     int caps = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_FLIP |
-               VFCAP_ACCEPT_STRIDE | VFCAP_OSD;
+               VFCAP_OSD;
     if (!init_format(format, NULL))
         return 0;
     return caps;
diff --git a/video/out/vo_opengl_old.c b/video/out/vo_opengl_old.c
index a8ad21408e..d708d6fcb6 100644
--- a/video/out/vo_opengl_old.c
+++ b/video/out/vo_opengl_old.c
@@ -587,30 +587,28 @@ static void flip_page(struct vo *vo)
         gl->Clear(GL_COLOR_BUFFER_BIT);
 }
 
-static uint32_t get_image(struct vo *vo, mp_image_t *mpi)
+static bool get_image(struct vo *vo, mp_image_t *mpi, int *th, bool *cplane)
 {
     struct gl_priv *p = vo->priv;
     GL *gl = p->gl;
 
+    bool common_plane = false;
+
     int needed_size;
     if (!gl->GenBuffers || !gl->BindBuffer || !gl->BufferData || !gl->MapBuffer) {
         if (!p->err_shown)
             mp_msg(MSGT_VO, MSGL_ERR, "[gl] extensions missing for dr\n"
                    "Expect a _major_ speed penalty\n");
         p->err_shown = 1;
-        return VO_FALSE;
+        return false;
     }
-    if (mpi->flags & MP_IMGFLAG_READABLE)
-        return VO_FALSE;
-    if (mpi->type != MP_IMGTYPE_STATIC && mpi->type != MP_IMGTYPE_TEMP &&
-        (mpi->type != MP_IMGTYPE_NUMBERED || mpi->number))
-        return VO_FALSE;
+    int width = mpi->w, height = mpi->h;
     if (p->ati_hack) {
-        mpi->width = p->texture_width;
-        mpi->height = p->texture_height;
+        width = p->texture_width;
+        height = p->texture_height;
     }
-    mpi->stride[0] = mpi->width * mpi->bpp / 8;
-    needed_size = mpi->stride[0] * mpi->height;
+    mpi->stride[0] = width * mpi->bpp / 8;
+    needed_size = mpi->stride[0] * height;
     if (!p->buffer)
         gl->GenBuffers(1, &p->buffer);
     gl->BindBuffer(GL_PIXEL_UNPACK_BUFFER, p->buffer);
@@ -628,24 +626,24 @@ static uint32_t get_image(struct vo *vo, mp_image_t *mpi)
             mp_msg(MSGT_VO, MSGL_ERR, "[gl] could not acquire buffer for dr\n"
                    "Expect a _major_ speed penalty\n");
         p->err_shown = 1;
-        return VO_FALSE;
+        return false;
     }
     if (p->is_yuv) {
         // planar YUV
         int xs, ys, component_bits;
         mp_get_chroma_shift(p->image_format, &xs, &ys, &component_bits);
         int bp = (component_bits + 7) / 8;
-        mpi->flags |= MP_IMGFLAG_COMMON_STRIDE | MP_IMGFLAG_COMMON_PLANE;
-        mpi->stride[0] = mpi->width * bp;
-        mpi->planes[1] = mpi->planes[0] + mpi->stride[0] * mpi->height;
-        mpi->stride[1] = (mpi->width >> xs) * bp;
-        mpi->planes[2] = mpi->planes[1] + mpi->stride[1] * (mpi->height >> ys);
-        mpi->stride[2] = (mpi->width >> xs) * bp;
+        common_plane = true;
+        mpi->stride[0] = width * bp;
+        mpi->planes[1] = mpi->planes[0] + mpi->stride[0] * height;
+        mpi->stride[1] = (width >> xs) * bp;
+        mpi->planes[2] = mpi->planes[1] + mpi->stride[1] * (height >> ys);
+        mpi->stride[2] = (width >> xs) * bp;
         if (p->ati_hack) {
-            mpi->flags &= ~MP_IMGFLAG_COMMON_PLANE;
+            common_plane = false;
             if (!p->buffer_uv[0])
                 gl->GenBuffers(2, p->buffer_uv);
-            int buffer_size = mpi->stride[1] * mpi->height;
+            int buffer_size = mpi->stride[1] * height;
             if (buffer_size > p->buffersize_uv) {
                 gl->BindBuffer(GL_PIXEL_UNPACK_BUFFER, p->buffer_uv[0]);
                 gl->BufferData(GL_PIXEL_UNPACK_BUFFER, buffer_size, NULL,
@@ -667,8 +665,9 @@ static uint32_t get_image(struct vo *vo, mp_image_t *mpi)
             mpi->planes[2] = p->bufferptr_uv[1];
         }
     }
-    mpi->flags |= MP_IMGFLAG_DIRECT;
-    return VO_TRUE;
+    *th = height;
+    *cplane = common_plane;
+    return true;
 }
 
 static void clear_border(struct vo *vo, uint8_t *dst, int start, int stride,
@@ -696,12 +695,12 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
     unsigned char *planes[3];
     mp_image_t mpi2 = *mpi;
     int w = mpi->w, h = mpi->h;
+    int th = h;
+    bool common_plane = false;
+    bool pbo = false;
     mpi2.flags = 0;
-    mpi2.type = MP_IMGTYPE_TEMP;
-    mpi2.width = mpi2.w;
-    mpi2.height = mpi2.h;
-    if (p->force_pbo && !(mpi->flags & MP_IMGFLAG_DIRECT) && !p->bufferptr
-        && get_image(vo, &mpi2) == VO_TRUE)
+    if (p->force_pbo && !p->bufferptr
+        && get_image(vo, &mpi2, &th, &common_plane))
     {
         int bp = mpi->bpp / 8;
         int xs, ys, component_bits;
@@ -720,16 +719,17 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
         if (p->ati_hack) {
             // since we have to do a full upload we need to clear the borders
             clear_border(vo, mpi2.planes[0], mpi->w * bp, mpi2.stride[0],
-                         mpi->h, mpi2.height, 0);
+                         mpi->h, th, 0);
             if (p->is_yuv) {
                 int clear = get_chroma_clear_val(component_bits);
                 clear_border(vo, mpi2.planes[1], uv_bytes, mpi2.stride[1],
-                             mpi->h >> ys, mpi2.height >> ys, clear);
+                             mpi->h >> ys, th >> ys, clear);
                 clear_border(vo, mpi2.planes[2], uv_bytes, mpi2.stride[2],
-                             mpi->h >> ys, mpi2.height >> ys, clear);
+                             mpi->h >> ys, th >> ys, clear);
             }
         }
         mpi = &mpi2;
+        pbo = true;
     }
     stride[0] = mpi->stride[0];
     stride[1] = mpi->stride[1];
@@ -738,7 +738,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
     planes[1] = mpi->planes[1];
     planes[2] = mpi->planes[2];
     p->mpi_flipped = stride[0] < 0;
-    if (mpi->flags & MP_IMGFLAG_DIRECT) {
+    if (pbo) {
         intptr_t base = (intptr_t)planes[0];
         if (p->ati_hack) {
             w = p->texture_width;
@@ -752,7 +752,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
         gl->BindBuffer(GL_PIXEL_UNPACK_BUFFER, p->buffer);
         gl->UnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
         p->bufferptr = NULL;
-        if (!(mpi->flags & MP_IMGFLAG_COMMON_PLANE))
+        if (!common_plane)
             planes[0] = planes[1] = planes[2] = NULL;
         slice = 0; // always "upload" full texture
     }
@@ -761,7 +761,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
     if (p->is_yuv) {
         int xs, ys;
         mp_get_chroma_shift(p->image_format, &xs, &ys, NULL);
-        if ((mpi->flags & MP_IMGFLAG_DIRECT) && !(mpi->flags & MP_IMGFLAG_COMMON_PLANE)) {
+        if (pbo && !common_plane) {
             gl->BindBuffer(GL_PIXEL_UNPACK_BUFFER, p->buffer_uv[0]);
             gl->UnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
             p->bufferptr_uv[0] = NULL;
@@ -769,7 +769,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
         gl->ActiveTexture(GL_TEXTURE1);
         glUploadTex(gl, p->target, p->gl_format, p->gl_type, planes[1],
                     stride[1], 0, 0, w >> xs, h >> ys, slice);
-        if ((mpi->flags & MP_IMGFLAG_DIRECT) && !(mpi->flags & MP_IMGFLAG_COMMON_PLANE)) {
+        if (pbo && !common_plane) {
             gl->BindBuffer(GL_PIXEL_UNPACK_BUFFER, p->buffer_uv[1]);
             gl->UnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
             p->bufferptr_uv[1] = NULL;
@@ -779,7 +779,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
                     stride[2], 0, 0, w >> xs, h >> ys, slice);
         gl->ActiveTexture(GL_TEXTURE0);
     }
-    if (mpi->flags & MP_IMGFLAG_DIRECT) {
+    if (pbo) {
         gl->BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
     }
 
@@ -819,8 +819,7 @@ static int query_format(struct vo *vo, uint32_t format)
     struct gl_priv *p = vo->priv;
 
     int depth;
-    int caps = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_FLIP |
-               VFCAP_ACCEPT_STRIDE;
+    int caps = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_FLIP;
     if (p->use_osd)
         caps |= VFCAP_OSD;
     if (format == IMGFMT_RGB24 || format == IMGFMT_RGBA)
diff --git a/video/out/vo_sdl.c b/video/out/vo_sdl.c
index d04a63e5a6..2eeed1b66a 100644
--- a/video/out/vo_sdl.c
+++ b/video/out/vo_sdl.c
@@ -814,8 +814,7 @@ static int query_format(struct vo *vo, uint32_t format)
 {
     struct priv *vc = vo->priv;
     int i, j;
-    int cap = VFCAP_CSP_SUPPORTED | VFCAP_FLIP | VFCAP_ACCEPT_STRIDE |
-              VFCAP_OSD;
+    int cap = VFCAP_CSP_SUPPORTED | VFCAP_FLIP | VFCAP_OSD;
     for (i = 0; i < vc->renderer_info.num_texture_formats; ++i)
         for (j = 0; j < sizeof(formats) / sizeof(formats[0]); ++j)
             if (vc->renderer_info.texture_formats[i] == formats[j].sdl)
@@ -941,8 +940,7 @@ static void update_screeninfo(struct vo *vo)
 static struct mp_image *get_screenshot(struct vo *vo)
 {
     struct priv *vc = vo->priv;
-    mp_image_t *image = alloc_mpi(vc->ssmpi->width, vc->ssmpi->height,
-                                  vc->ssmpi->imgfmt);
+    mp_image_t *image = alloc_mpi(vc->ssmpi->w, vc->ssmpi->h, vc->ssmpi->imgfmt);
     copy_mpi(image, vc->ssmpi);
     return image;
 }
diff --git a/video/out/vo_x11.c b/video/out/vo_x11.c
index 58c709e471..b323c34865 100644
--- a/video/out/vo_x11.c
+++ b/video/out/vo_x11.c
@@ -530,20 +530,17 @@ static int query_format(struct vo *vo, uint32_t format)
             return 0;           // TODO 8bpp not yet fully implemented
         if (IMGFMT_BGR_DEPTH(format) == vo->x11->depthonscreen)
             return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW |
-                   VFCAP_OSD | VFCAP_FLIP |
-                   VFCAP_ACCEPT_STRIDE;
+                   VFCAP_OSD | VFCAP_FLIP;
         else
             return VFCAP_CSP_SUPPORTED | VFCAP_OSD |
-                   VFCAP_FLIP |
-                   VFCAP_ACCEPT_STRIDE;
+                   VFCAP_FLIP;
     }
 
     switch (format) {
     case IMGFMT_I420:
     case IMGFMT_IYUV:
     case IMGFMT_YV12:
-        return VFCAP_CSP_SUPPORTED | VFCAP_OSD |
-               VFCAP_ACCEPT_STRIDE;
+        return VFCAP_CSP_SUPPORTED | VFCAP_OSD;
     }
     return 0;
 }
diff --git a/video/out/vo_xv.c b/video/out/vo_xv.c
index 46fe4649f5..4f26f195c6 100644
--- a/video/out/vo_xv.c
+++ b/video/out/vo_xv.c
@@ -418,7 +418,7 @@ static int query_format(struct vo *vo, uint32_t format)
 {
     struct xvctx *ctx = vo->priv;
     uint32_t i;
-    int flag = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_OSD | VFCAP_ACCEPT_STRIDE;       // FIXME! check for DOWN
+    int flag = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_OSD;
 
     /* check image formats */
     for (i = 0; i < ctx->formats; i++) {