video: cleanup: replace old mp_image function names

mp_image_alloc() also changes argument order compared to alloc_mpi().
The format now comes first, then width/height.

15 files changed, 37 insertions, 44 deletions

diff --git a/sub/draw_bmp.c b/sub/draw_bmp.c
index 245d1edd2b..79b44bfa66 100644
--- a/sub/draw_bmp.c
+++ b/sub/draw_bmp.c
@@ -274,8 +274,8 @@ static void draw_rgba(struct mp_draw_sub_cache **cache, struct mp_rect bb,
             part->imgs[i].i = talloc_steal(part, sbi);
             part->imgs[i].a = talloc_steal(part, sba);
         } else {
-            free_mp_image(sbi);
-            free_mp_image(sba);
+            talloc_free(sbi);
+            talloc_free(sba);
         }
     }
 }
@@ -520,7 +520,7 @@ void mp_draw_sub_bitmaps(struct mp_draw_sub_cache **cache, struct mp_image *dst,
     if (dst->imgfmt == format) {
         temp = &dst_region;
     } else {
-        temp = alloc_mpi(bb.x1 - bb.x0, bb.y1 - bb.y0, format);
+        temp = mp_image_alloc(format, bb.x1 - bb.x0, bb.y1 - bb.y0);
         // temp is always YUV, dst_region not
         // reduce amount of conversions in YUV case (upsampling/shifting only)
         if (dst_region.flags & MP_IMGFLAG_YUV) {
@@ -538,7 +538,7 @@ void mp_draw_sub_bitmaps(struct mp_draw_sub_cache **cache, struct mp_image *dst,
 
     if (temp != &dst_region) {
         mp_image_swscale(&dst_region, temp, SWS_AREA); // chroma down
-        free_mp_image(temp);
+        talloc_free(temp);
     }
 }
 
@@ -581,7 +581,7 @@ static void backup_realloc(struct mp_draw_sub_backup *backup,
         return;
 
     talloc_free_children(backup);
-    backup->image = alloc_mpi(img->w, img->h, img->imgfmt);
+    backup->image = mp_image_alloc(img->imgfmt, img->w, img->h);
     talloc_steal(backup, backup->image);
     for (int p = 0; p < MP_MAX_PLANES; p++) {
         backup->lines[p] = talloc_array(backup, struct line_ext,
diff --git a/sub/img_convert.c b/sub/img_convert.c
index 0560b66aab..5e74ba9e84 100644
--- a/sub/img_convert.c
+++ b/sub/img_convert.c
@@ -73,7 +73,7 @@ bool osd_conv_idx_to_rgba(struct osd_conv_cache *c, struct sub_bitmaps *imgs)
         rgba_to_premultiplied_rgba(sb.palette, 256);
 
         *d = *s;
-        struct mp_image *image = alloc_mpi(s->w, s->h, IMGFMT_BGRA);
+        struct mp_image *image = mp_image_alloc(IMGFMT_BGRA, s->w, s->h);
         talloc_steal(c->parts, image);
         d->stride = image->stride[0];
         d->bitmap = image->planes[0];
@@ -104,8 +104,8 @@ bool osd_conv_blur_rgba(struct osd_conv_cache *c, struct sub_bitmaps *imgs,
 
         // add a transparent padding border to reduce artifacts
         int pad = 5;
-        struct mp_image *temp = alloc_mpi(s->w + pad * 2, s->h + pad * 2,
-                                          IMGFMT_BGRA);
+        struct mp_image *temp = mp_image_alloc(IMGFMT_BGRA, s->w + pad * 2,
+                                                            s->h + pad * 2);
         memset_pic(temp->planes[0], 0, temp->w * 4, temp->h, temp->stride[0]);
         uint8_t *p0 = temp->planes[0] + pad * 4 + pad * temp->stride[0];
         memcpy_pic(p0, s->bitmap, s->w * 4, s->h, temp->stride[0], s->stride);
@@ -117,7 +117,7 @@ bool osd_conv_blur_rgba(struct osd_conv_cache *c, struct sub_bitmaps *imgs,
         d->y = s->y - pad * sy;
         d->w = d->dw = s->dw + pad * 2 * sx;
         d->h = d->dh = s->dh + pad * 2 * sy;
-        struct mp_image *image = alloc_mpi(d->w, d->h, IMGFMT_BGRA);
+        struct mp_image *image = mp_image_alloc(IMGFMT_BGRA, d->w, d->h);
         talloc_steal(c->parts, image);
         d->stride = image->stride[0];
         d->bitmap = image->planes[0];
diff --git a/video/image_writer.c b/video/image_writer.c
index b730f40bf6..8d3b746ef7 100644
--- a/video/image_writer.c
+++ b/video/image_writer.c
@@ -285,7 +285,7 @@ int write_image(struct mp_image *image, const struct image_writer_opts *opts,
     //         - RGB->YUV assumes BT.601
     //         - color levels broken in various ways thanks to libswscale
     if (image->imgfmt != destfmt || is_anamorphic) {
-        struct mp_image *dst = alloc_mpi(d_w, d_h, destfmt);
+        struct mp_image *dst = mp_image_alloc(destfmt, d_w, d_h);
         mp_image_copy_attributes(dst, image);
 
         int flags = SWS_LANCZOS | SWS_FULL_CHR_H_INT | SWS_FULL_CHR_H_INP |
@@ -310,7 +310,7 @@ int write_image(struct mp_image *image, const struct image_writer_opts *opts,
                    filename);
     }
 
-    free_mp_image(allocated_image);
+    talloc_free(allocated_image);
 
     return success;
 }
diff --git a/video/mp_image.h b/video/mp_image.h
index 05502c49b4..1d00115545 100644
--- a/video/mp_image.h
+++ b/video/mp_image.h
@@ -91,11 +91,6 @@ typedef struct mp_image {
     void* priv;
 } mp_image_t;
 
-#define alloc_mpi(w, h, fmt) mp_image_alloc(fmt, w, h)
-#define free_mp_image talloc_free
-#define new_mp_image mp_image_new_empty
-#define copy_mpi mp_image_copy
-
 struct mp_image *mp_image_alloc(unsigned int fmt, int w, int h);
 void mp_image_clear(struct mp_image *mpi, int x0, int y0, int w, int h);
 void mp_image_copy(struct mp_image *dmpi, struct mp_image *mpi);
diff --git a/video/out/gl_common.c b/video/out/gl_common.c
index 42d035337f..b7b30702a6 100644
--- a/video/out/gl_common.c
+++ b/video/out/gl_common.c
@@ -1978,7 +1978,7 @@ mp_image_t *glGetWindowScreenshot(GL *gl)
 {
     GLint vp[4]; //x, y, w, h
     gl->GetIntegerv(GL_VIEWPORT, vp);
-    mp_image_t *image = alloc_mpi(vp[2], vp[3], IMGFMT_RGB24);
+    mp_image_t *image = mp_image_alloc(IMGFMT_RGB24, vp[2], vp[3]);
     gl->BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
     gl->PixelStorei(GL_PACK_ALIGNMENT, 0);
     gl->PixelStorei(GL_PACK_ROW_LENGTH, 0);
diff --git a/video/out/vo.h b/video/out/vo.h
index 6ea2f930e8..eb55417f4c 100644
--- a/video/out/vo.h
+++ b/video/out/vo.h
@@ -98,7 +98,7 @@ struct voctrl_screenshot_args {
     // implemented.
     int full_window;
     // Will be set to a newly allocated image, that contains the screenshot.
-    // The caller has to free the pointer with free_mp_image().
+    // The caller has to free the image with talloc_free().
     // It is not specified whether the image data is a copy or references the
     // image data directly.
     // Is never NULL. (Failure has to be indicated by returning VO_FALSE.)
diff --git a/video/out/vo_direct3d.c b/video/out/vo_direct3d.c
index d3c907f944..51caaf2be9 100644
--- a/video/out/vo_direct3d.c
+++ b/video/out/vo_direct3d.c
@@ -1616,7 +1616,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
     if (!get_video_buffer(priv, &buffer))
         return;
 
-    copy_mpi(&buffer, mpi);
+    mp_image_copy(&buffer, mpi);
 
     d3d_unlock_video_objects(priv);
 
@@ -1697,7 +1697,7 @@ static mp_image_t *get_window_screenshot(d3d_priv *priv)
     if (width < 1 || height < 1)
         goto error_exit;
 
-    image = alloc_mpi(width, height, IMGFMT_BGR32);
+    image = mp_image_alloc(IMGFMT_BGR32, width, height);
 
     IDirect3DSurface9_LockRect(surface, &locked_rect, NULL, 0);
 
@@ -1712,7 +1712,7 @@ static mp_image_t *get_window_screenshot(d3d_priv *priv)
 
 error_exit:
     if (image)
-        free_mp_image(image);
+        talloc_free(image);
     if (surface)
         IDirect3DSurface9_Release(surface);
     return NULL;
diff --git a/video/out/vo_lavc.c b/video/out/vo_lavc.c
index cdb7f71797..aa9077fb17 100644
--- a/video/out/vo_lavc.c
+++ b/video/out/vo_lavc.c
@@ -89,7 +89,7 @@ static void uninit(struct vo *vo)
         // palette hack
         if (vc->lastimg->imgfmt == IMGFMT_PAL8)
             vc->lastimg->planes[1] = NULL;
-        free_mp_image(vc->lastimg);
+        talloc_free(vc->lastimg);
         vc->lastimg = NULL;
     }
 
@@ -171,7 +171,7 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
 
     vc->buffer = talloc_size(vc, vc->buffer_size);
 
-    vc->lastimg = alloc_mpi(width, height, format);
+    vc->lastimg = mp_image_alloc(format, width, height);
 
     // palette hack
     if (vc->lastimg->imgfmt == IMGFMT_PAL8)
@@ -455,7 +455,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
                 mp_msg(MSGT_ENCODE, MSGL_INFO,
                        "vo-lavc: Frame at pts %d got displayed %d times\n",
                        (int) vc->lastframeipts, vc->lastdisplaycount);
-            copy_mpi(vc->lastimg, mpi);
+            mp_image_copy(vc->lastimg, mpi);
             vc->lastimg_wants_osd = true;
 
             // palette hack
diff --git a/video/out/vo_opengl.c b/video/out/vo_opengl.c
index aa6f9243f3..665e008178 100644
--- a/video/out/vo_opengl.c
+++ b/video/out/vo_opengl.c
@@ -1321,8 +1321,8 @@ static mp_image_t *get_screenshot(struct gl_priv *p)
 {
     GL *gl = p->gl;
 
-    mp_image_t *image = alloc_mpi(p->texture_width, p->texture_height,
-                                  p->image_format);
+    mp_image_t *image = mp_image_alloc(p->image_format, p->texture_width,
+                                                        p->texture_height);
 
     // NOTE about image formats with alpha plane: we don't even have the alpha
     // anymore. We never upload it to any texture, as it would be a waste of
diff --git a/video/out/vo_opengl_old.c b/video/out/vo_opengl_old.c
index d708d6fcb6..6605876226 100644
--- a/video/out/vo_opengl_old.c
+++ b/video/out/vo_opengl_old.c
@@ -791,8 +791,8 @@ static mp_image_t *get_screenshot(struct vo *vo)
     struct gl_priv *p = vo->priv;
     GL *gl = p->gl;
 
-    mp_image_t *image = alloc_mpi(p->texture_width, p->texture_height,
-                                  p->image_format);
+    mp_image_t *image = mp_image_alloc(p->image_format, p->texture_width,
+                                                        p->texture_height);
 
     glDownloadTex(gl, p->target, p->gl_format, p->gl_type, image->planes[0],
                   image->stride[0]);
diff --git a/video/out/vo_sdl.c b/video/out/vo_sdl.c
index 2eeed1b66a..c3ed3c6774 100644
--- a/video/out/vo_sdl.c
+++ b/video/out/vo_sdl.c
@@ -448,7 +448,7 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
         return -1;
     }
 
-    vc->ssmpi = alloc_mpi(width, height, format);
+    vc->ssmpi = mp_image_alloc(format, width, height);
 
     resize(vo, d_width, d_height);
 
@@ -593,7 +593,7 @@ static void uninit(struct vo *vo)
 {
     struct priv *vc = vo->priv;
     destroy_renderer(vo);
-    free_mp_image(vc->ssmpi);
+    talloc_free(vc->ssmpi);
     SDL_QuitSubSystem(SDL_INIT_VIDEO);
     talloc_free(vc);
 }
@@ -857,7 +857,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
     if (color_add > 255)
         color_add = 255;
 
-    // typically this runs in parallel with the following copy_mpi call
+    // typically this runs in parallel with the following mp_image_copy call
     SDL_SetRenderDrawColor(vc->renderer, color_add, color_add, color_add, 255);
     SDL_RenderClear(vc->renderer);
 
@@ -894,7 +894,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
                 texmpi->stride[2] = pitch / 2;
             }
         }
-        copy_mpi(texmpi, mpi);
+        mp_image_copy(texmpi, mpi);
 
         SDL_UnlockTexture(vc->tex);
     }
@@ -909,7 +909,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
     dst.w = vc->dst_rect.x1 - vc->dst_rect.x0;
     dst.h = vc->dst_rect.y1 - vc->dst_rect.y0;
 
-    // typically this runs in parallel with the following copy_mpi call
+    // typically this runs in parallel with the following mp_image_copy call
     if (color_mod > 255) {
         SDL_SetTextureColorMod(vc->tex, color_mod / 2, color_mod / 2, color_mod / 2);
         SDL_RenderCopy(vc->renderer, vc->tex, &src, &dst);
@@ -919,7 +919,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
         SDL_RenderCopy(vc->renderer, vc->tex, &src, &dst);
     }
     if (mpi)
-        copy_mpi(vc->ssmpi, mpi);
+        mp_image_copy(vc->ssmpi, mpi);
 }
 
 static void update_screeninfo(struct vo *vo)
@@ -940,19 +940,18 @@ 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->w, vc->ssmpi->h, vc->ssmpi->imgfmt);
-    copy_mpi(image, vc->ssmpi);
-    return image;
+    return mp_image_new_copy(vc->ssmpi);
 }
 
 static struct mp_image *get_window_screenshot(struct vo *vo)
 {
     struct priv *vc = vo->priv;
-    mp_image_t *image = alloc_mpi(vo->dwidth, vo->dheight, vc->osd_format.mpv);
+    struct mp_image *image = mp_image_alloc(vc->osd_format.mpv, vo->dwidth,
+                                                                vo->dheight);
     if (SDL_RenderReadPixels(vc->renderer, NULL, vc->osd_format.sdl,
                              image->planes[0], image->stride[0])) {
         mp_msg(MSGT_VO, MSGL_ERR, "[sdl] SDL_RenderReadPixels failed\n");
-        free_mp_image(image);
+        talloc_free(image);
         return NULL;
     }
     return image;
diff --git a/video/out/vo_vdpau.c b/video/out/vo_vdpau.c
index 48080ba186..42c8bc6a24 100644
--- a/video/out/vo_vdpau.c
+++ b/video/out/vo_vdpau.c
@@ -1339,7 +1339,7 @@ static struct mp_image *read_output_surface(struct vdpctx *vc,
 {
     VdpStatus vdp_st;
     struct vdp_functions *vdp = vc->vdp;
-    struct mp_image *image = alloc_mpi(width, height, IMGFMT_BGR32);
+    struct mp_image *image = mp_image_alloc(IMGFMT_BGR32, width, height);
     image->colorspace = MP_CSP_RGB;
     image->levels = vc->colorspace.levels_out; // hardcoded with conv. matrix
 
diff --git a/video/out/vo_x11.c b/video/out/vo_x11.c
index 4bdb209891..5a81648233 100644
--- a/video/out/vo_x11.c
+++ b/video/out/vo_x11.c
@@ -449,8 +449,7 @@ static mp_image_t *get_screenshot(struct vo *vo)
     struct priv *p = vo->priv;
 
     struct mp_image img = get_x_buffer(p);
-    struct mp_image *res = alloc_mpi(img.w, img.h, img.imgfmt);
-    copy_mpi(res, &img);
+    struct mp_image *res = mp_image_new_copy(&img);
     mp_draw_sub_backup_restore(p->osd_backup, res);
 
     return res;
diff --git a/video/out/vo_xv.c b/video/out/vo_xv.c
index 8bfe3e1777..d5225cd7cd 100644
--- a/video/out/vo_xv.c
+++ b/video/out/vo_xv.c
@@ -406,7 +406,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
     struct xvctx *ctx = vo->priv;
 
     struct mp_image xv_buffer = get_xv_buffer(vo, ctx->current_buf);
-    copy_mpi(&xv_buffer, mpi);
+    mp_image_copy(&xv_buffer, mpi);
 
     mp_draw_sub_backup_reset(ctx->osd_backup);
 }
diff --git a/video/sws_utils.c b/video/sws_utils.c
index c097fe4d14..61a0122960 100644
--- a/video/sws_utils.c
+++ b/video/sws_utils.c
@@ -158,7 +158,7 @@ static void to_gbrp(struct mp_image *dst, struct mp_image *src,
     case IMGFMT_ARGB: SET_COMPS(comp, 1, 2, 3, 0); break;
     case IMGFMT_RGBA: SET_COMPS(comp, 0, 1, 2, 3); break;
     default:
-        temp = alloc_mpi(dst->w, dst->h, IMGFMT_RGBA);
+        temp = mp_image_alloc(IMGFMT_RGBA, dst->w, dst->h);
         mp_image_swscale(temp, src, my_sws_flags);
         src = temp;
         SET_COMPS(comp, 0, 1, 2, 3);