diff options
| -rw-r--r-- | Makefile | 1 | ||||
| -rw-r--r-- | libvo/bitmap_packer.c | 174 | ||||
| -rw-r--r-- | libvo/bitmap_packer.h | 47 | ||||
| -rw-r--r-- | libvo/vo_vdpau.c | 408 |
4 files changed, 484 insertions, 146 deletions
@@ -241,6 +241,7 @@ SRCS_COMMON = asxparser.c \ libmpdemux/video.c \ libvo/osd.c \ libvo/eosd_packer.c \ + libvo/bitmap_packer.c \ osdep/numcores.c \ osdep/io.c \ osdep/$(GETCH) \ diff --git a/libvo/bitmap_packer.c b/libvo/bitmap_packer.c new file mode 100644 index 0000000000..2ae8a1eee0 --- /dev/null +++ b/libvo/bitmap_packer.c @@ -0,0 +1,174 @@ +/* + * Calculate how to pack bitmap rectangles into a larger surface + * + * Copyright 2009, 2012 Uoti Urpala + * + * This file is part of mplayer2. + * + * mplayer2 is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * mplayer2 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with mplayer2. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <stdlib.h> + +#include <libavutil/common.h> + +#include "talloc.h" +#include "bitmap_packer.h" +#include "mp_msg.h" +#include "mpcommon.h" +#include "sub/ass_mp.h" + + +#define HEIGHT_SORT_BITS 4 +static int size_index(int s) +{ + int n = av_log2_16bit(s); + return (n << HEIGHT_SORT_BITS) + + (- 1 - (s << HEIGHT_SORT_BITS >> n) & (1 << HEIGHT_SORT_BITS) - 1); +} + +/* Pack the given rectangles into an area of size w * h. + * The size of each rectangle is read from in[i].x / in[i].y. + * The height of each rectangle must be less than 65536. + * 'scratch' must point to work memory for num_rects+16 ints. + * The packed position for rectangle number i is set in out[i]. + * Return 0 on success, -1 if the rectangles did not fit in w*h. + * + * The rectangles are placed in rows in order approximately sorted by + * height (the approximate sorting is simpler than a full one would be, + * and allows the algorithm to work in linear time). Additionally, to + * reduce wasted space when there are a few tall rectangles, empty + * lower-right parts of rows are filled recursively when the size of + * rectangles in the row drops past a power-of-two threshold. So if a + * row starts with rectangles of size 3x50, 10x40 and 5x20 then the + * free rectangle with corners (13, 20)-(w, 50) is filled recursively. + */ +static int pack_rectangles(struct pos *in, struct pos *out, int num_rects, + int w, int h, int *scratch) +{ + int bins[16 << HEIGHT_SORT_BITS]; + int sizes[16 << HEIGHT_SORT_BITS] = { 0 }; + for (int i = 0; i < num_rects; i++) + sizes[size_index(in[i].y)]++; + int idx = 0; + for (int i = 0; i < 16 << HEIGHT_SORT_BITS; i += 1 << HEIGHT_SORT_BITS) { + for (int j = 0; j < 1 << HEIGHT_SORT_BITS; j++) { + bins[i + j] = idx; + idx += sizes[i + j]; + } + scratch[idx++] = -1; + } + for (int i = 0; i < num_rects; i++) + scratch[bins[size_index(in[i].y)]++] = i; + for (int i = 0; i < 16; i++) + bins[i] = bins[i << HEIGHT_SORT_BITS] - sizes[i << HEIGHT_SORT_BITS]; + struct { + int size, x, bottom; + } stack[16] = {{15, 0, h}}, s = {}; + int stackpos = 1; + int y; + while (stackpos) { + y = s.bottom; + s = stack[--stackpos]; + s.size++; + while (s.size--) { + int maxy = -1; + int obj; + while ((obj = scratch[bins[s.size]]) >= 0) { + int bottom = y + in[obj].y; + if (bottom > s.bottom) + break; + int right = s.x + in[obj].x; + if (right > w) + break; + bins[s.size]++; + out[obj] = (struct pos){s.x, y}; + num_rects--; + if (maxy < 0) + stack[stackpos++] = s; + s.x = right; + maxy = FFMAX(maxy, bottom); + } + if (maxy > 0) + s.bottom = maxy; + } + } + return num_rects ? -1 : 0; +} + +int packer_pack(struct bitmap_packer *packer) +{ + if (packer->count == 0) + return 0; + int w_orig = packer->w, h_orig = packer->h; + struct pos *in = packer->in; + int xmax = 0, ymax = 0; + for (int i = 0; i < packer->count; i++) { + if (in[i].x == 0 || in[i].y == 0) + in[i] = (struct pos){0, 0}; + if (in[i].x < 0 || in [i].x > 65535 || in[i].y < 0 || in[i].y > 65535) { + mp_msg(MSGT_VO, MSGL_FATAL, "Invalid OSD / subtitle bitmap size\n"); + abort(); + } + xmax = FFMAX(xmax, in[i].x); + ymax = FFMAX(ymax, in[i].y); + } + if (xmax > packer->w) + packer->w = 1 << av_log2(xmax - 1) + 1; + if (ymax > packer->h) + packer->h = 1 << av_log2(ymax - 1) + 1; + while (1) { + if (pack_rectangles(in, packer->result, packer->count, packer->w, + packer->h, packer->scratch) >= 0) + return packer->w != w_orig || packer->h != h_orig; + if (packer->w <= packer->h && packer->w != packer->w_max) + packer->w = FFMIN(packer->w * 2, packer->w_max); + else if (packer->h != packer->h_max) + packer->h = FFMIN(packer->h * 2, packer->h_max); + else + return -1; + } +} + +void packer_set_size(struct bitmap_packer *packer, int size) +{ + packer->count = size; + if (size <= packer->asize) + return; + packer->asize = FFMAX(packer->asize * 2, size); + talloc_free(packer->result); + talloc_free(packer->scratch); + packer->in = talloc_realloc(packer, packer->in, struct pos, packer->asize); + packer->result = talloc_array_ptrtype(packer, packer->result, + packer->asize); + packer->scratch = talloc_array_ptrtype(packer, packer->scratch, + packer->asize + 16); +} + +int packer_pack_from_assimg(struct bitmap_packer *packer, + struct ass_image *imglist) +{ + int count = 0; + struct ass_image *img = imglist; + while (img) { + if (count >= packer->asize) + packer_set_size(packer, FFMAX(packer->asize * 2, 32)); + packer->in[count].x = img->w; + packer->in[count].y = img->h; + img = img->next; + count++; + } + packer->count = count; + return packer_pack(packer); +} diff --git a/libvo/bitmap_packer.h b/libvo/bitmap_packer.h new file mode 100644 index 0000000000..45b6fbc4ae --- /dev/null +++ b/libvo/bitmap_packer.h @@ -0,0 +1,47 @@ +#ifndef MPLAYER_PACK_RECTANGLES_H +#define MPLAYER_PACK_RECTANGLES_H + +struct pos { + int x; + int y; +}; + +struct bitmap_packer { + int w; + int h; + int w_max; + int h_max; + int count; + struct pos *in; + struct pos *result; + + // internal + int *scratch; + int asize; +}; + +struct ass_image; + +/* Reallocate packer->in for at least to desired number of items. + * Also sets packer->count to the same value. + */ +void packer_set_size(struct bitmap_packer *packer, int size); + +/* To use this, set packer->count to number of rectangles, w_max and h_max + * to maximum output rectangle size, and w and h to start size (may be 0). + * Write input sizes in packer->in. + * Resulting packing will be written in packer->result. + * w and h will be increased if necessary for successful packing. + * Return value is -1 if packing failed because w and h were set to max + * values but that wasn't enough, 1 if w or h was increased, and 0 otherwise. + */ +int packer_pack(struct bitmap_packer *packer); + +/* Like above, but packer->count will be automatically set and + * packer->in will be reallocated if needed and filled from the + * given image list. + */ +int packer_pack_from_assimg(struct bitmap_packer *packer, + struct ass_image *imglist); + +#endif diff --git a/libvo/vo_vdpau.c b/libvo/vo_vdpau.c index 52e7abaa0c..d9b59c7dbe 100644 --- a/libvo/vo_vdpau.c +++ b/libvo/vo_vdpau.c @@ -33,6 +33,10 @@ #include <stdint.h> #include <stdbool.h> #include <limits.h> +#include <assert.h> + +#include <libavutil/common.h> +#include <libavcodec/vdpau.h> #include "config.h" #include "mp_msg.h" @@ -47,14 +51,8 @@ #include "libmpcodecs/vfcap.h" #include "libmpcodecs/mp_image.h" #include "osdep/timer.h" - -#include "libavcodec/vdpau.h" - -#include "libavutil/common.h" -#include "libavutil/mathematics.h" - #include "sub/ass_mp.h" -#include "eosd_packer.h" +#include "bitmap_packer.h" #define WRAP_ADD(x, a, m) ((a) < 0 \ ? ((x)+(a)+(m) < (m) ? (x)+(a)+(m) : (x)+(a)) \ @@ -81,9 +79,6 @@ #define MAX_VIDEO_SURFACES 50 #define NUM_BUFFERED_VIDEO 5 -/* number of palette entries */ -#define PALETTE_SIZE 256 - /* Pixelformat used for output surfaces */ #define OUTPUT_RGBA_FORMAT VDP_RGBA_FORMAT_B8G8R8A8 @@ -97,6 +92,8 @@ struct vdp_functions { #undef VDP_FUNCTION }; +#define MAX_OLD_OSD_BITMAPS 6 + struct vdpctx { struct vdp_functions *vdp; @@ -113,7 +110,7 @@ struct vdpctx { unsigned int last_sync_update; /* an extra last output surface is used for OSD and screenshots */ - VdpOutputSurface output_surfaces[MAX_OUTPUT_SURFACES + 1]; + VdpOutputSurface output_surfaces[MAX_OUTPUT_SURFACES]; int num_output_surfaces; struct buffered_video_surface { VdpVideoSurface surface; @@ -164,14 +161,31 @@ struct vdpctx { VdpYCbCrFormat vdp_pixel_format; /* draw_osd */ - unsigned char *index_data; - int index_data_size; - uint32_t palette[PALETTE_SIZE]; + struct old_osd { + int x0, y0, w, h; + unsigned char *src, *srca; + int stride; + } old_osd_elements[MAX_OLD_OSD_BITMAPS]; + int old_osd_count; + unsigned char *osd_data_temp; + int osd_data_size; // EOSD - // Pool of surfaces - VdpBitmapSurface eosd_surface; - struct eosd_packer *eosd_packer; + struct eosd_bitmap_surface { + VdpBitmapSurface surface; + uint32_t max_width; + uint32_t max_height; + struct bitmap_packer *packer; + } eosd_surface, osd_surface; + + // List of surfaces to be rendered + struct eosd_target { + VdpRect source; + VdpRect dest; + VdpColor color; + } *eosd_targets, osd_targets[MAX_OLD_OSD_BITMAPS][2]; + int eosd_targets_size; + int eosd_render_count; // Video equalizer struct mp_csp_equalizer video_eq; @@ -366,7 +380,6 @@ static void resize(struct vo *vo) struct vdpctx *vc = vo->priv; struct vdp_functions *vdp = vc->vdp; VdpStatus vdp_st; - int i; struct vo_rect src_rect; struct vo_rect dst_rect; struct vo_rect borders; @@ -402,12 +415,13 @@ static void resize(struct vo *vo) min_output_height); } // Creation of output_surfaces - for (i = 0; i <= vc->num_output_surfaces; i++) { + for (int i = 0; i < vc->num_output_surfaces; i++) if (vc->output_surfaces[i] != VDP_INVALID_HANDLE) { vdp_st = vdp->output_surface_destroy(vc->output_surfaces[i]); CHECK_ST_WARNING("Error when calling " "vdp_output_surface_destroy"); } + for (int i = 0; i < vc->num_output_surfaces; i++) { vdp_st = vdp->output_surface_create(vc->vdp_device, OUTPUT_RGBA_FORMAT, vc->output_surface_width, @@ -752,8 +766,6 @@ static int create_vdp_decoder(struct vo *vo, int max_refs) static int initialize_vdpau_objects(struct vo *vo) { struct vdpctx *vc = vo->priv; - struct vdp_functions *vdp = vc->vdp; - VdpStatus vdp_st; vc->vdp_chroma_type = VDP_CHROMA_TYPE_420; switch (vc->image_format) { @@ -779,16 +791,6 @@ static int initialize_vdpau_objects(struct vo *vo) if (create_vdp_mixer(vo, vc->vdp_chroma_type) < 0) return -1; - int max_width = 0, max_height = 0; - vdp_st = vdp-> - bitmap_surface_query_capabilities(vc->vdp_device, - VDP_RGBA_FORMAT_A8, - &(VdpBool){0}, - &max_width, - &max_height); - CHECK_ST_WARNING("Query to get max EOSD surface size failed"); - eosd_packer_reinit(vc->eosd_packer, max_width, max_height); - forget_frames(vo); resize(vo); return 0; @@ -805,12 +807,16 @@ static void mark_vdpau_objects_uninitialized(struct vo *vo) vc->video_mixer = VDP_INVALID_HANDLE; vc->flip_queue = VDP_INVALID_HANDLE; vc->flip_target = VDP_INVALID_HANDLE; - for (int i = 0; i <= MAX_OUTPUT_SURFACES; i++) + for (int i = 0; i < MAX_OUTPUT_SURFACES; i++) vc->output_surfaces[i] = VDP_INVALID_HANDLE; vc->vdp_device = VDP_INVALID_HANDLE; - vc->eosd_surface = VDP_INVALID_HANDLE; - eosd_packer_reinit(vc->eosd_packer, 0, 0); + talloc_free(vc->osd_surface.packer); + talloc_free(vc->eosd_surface.packer); + vc->osd_surface = vc->eosd_surface = (struct eosd_bitmap_surface){ + .surface = VDP_INVALID_HANDLE, + }; vc->output_surface_width = vc->output_surface_height = -1; + vc->eosd_render_count = 0; } static int handle_preemption(struct vo *vo) @@ -934,80 +940,22 @@ static void check_events(struct vo *vo) } } -static void draw_osd_I8A8(void *ctx, int x0, int y0, int w, int h, - unsigned char *src, unsigned char *srca, int stride) +static struct bitmap_packer *make_packer(struct vo *vo, VdpRGBAFormat format) { - struct vo *vo = ctx; struct vdpctx *vc = vo->priv; struct vdp_functions *vdp = vc->vdp; - VdpOutputSurface output_surface = vc->output_surfaces[vc->surface_num]; - VdpStatus vdp_st; - int i; - int pitch; - int index_data_size_required; - VdpRect output_indexed_rect_vid; - - if (!w || !h) - return; - - index_data_size_required = 2*w*h; - if (vc->index_data_size < index_data_size_required) { - vc->index_data = talloc_realloc_size(vc, vc->index_data, - index_data_size_required); - vc->index_data_size = index_data_size_required; - } - - // index_data creation, component order - I, A, I, A, ..... - for (i = 0; i < h; i++) - for (int j = 0; j < w; j++) { - vc->index_data[i*2*w + j*2] = src [i*stride+j]; - vc->index_data[i*2*w + j*2 + 1] = -srca[i*stride+j]; - } - - output_indexed_rect_vid.x0 = x0; - output_indexed_rect_vid.y0 = y0; - output_indexed_rect_vid.x1 = x0 + w; - output_indexed_rect_vid.y1 = y0 + h; - - pitch = w*2; - - // write source_data to osd_surface. - VdpOutputSurface osd_surface = vc->output_surfaces[vc->num_output_surfaces]; - vdp_st = vdp-> - output_surface_put_bits_indexed(osd_surface, VDP_INDEXED_FORMAT_I8A8, - (const void *const*)&vc->index_data, - &pitch, &output_indexed_rect_vid, - VDP_COLOR_TABLE_FORMAT_B8G8R8X8, - (void *)vc->palette); - CHECK_ST_WARNING("Error when calling vdp_output_surface_put_bits_indexed"); - - VdpOutputSurfaceRenderBlendState blend_state = { - .struct_version = VDP_OUTPUT_SURFACE_RENDER_BLEND_STATE_VERSION, - .blend_factor_source_color = - VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE, - .blend_factor_source_alpha = - VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE, - .blend_factor_destination_color = - VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, - .blend_factor_destination_alpha = - VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, - .blend_equation_color = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD, - .blend_equation_alpha = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD, - }; - vdp_st = vdp-> - output_surface_render_output_surface(output_surface, - &output_indexed_rect_vid, - osd_surface, - &output_indexed_rect_vid, - NULL, &blend_state, - VDP_OUTPUT_SURFACE_RENDER_ROTATE_0); - CHECK_ST_WARNING("Error when calling " - "vdp_output_surface_render_output_surface"); + struct bitmap_packer *packer = talloc_zero(vo, struct bitmap_packer); + uint32_t w_max = 0, h_max = 0; + VdpStatus vdp_st = vdp-> + bitmap_surface_query_capabilities(vc->vdp_device, format, + &(VdpBool){0}, &w_max, &h_max); + CHECK_ST_WARNING("Query to get max EOSD surface size failed"); + packer->w_max = w_max; + packer->h_max = h_max; + return packer; } -#define EOSD_VDP_RC(r) &(VdpRect){r.x0, r.y0, r.x1, r.y1} - static void draw_eosd(struct vo *vo) { struct vdpctx *vc = vo->priv; @@ -1030,20 +978,13 @@ static void draw_eosd(struct vo *vo) .blend_equation_alpha = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD, }; - for (i = 0; i < vc->eosd_packer->targets_count; i++) { - struct eosd_target *target = &vc->eosd_packer->targets[i]; - VdpColor color = { - .alpha = 1.0 - ((target->color >> 0) & 0xff) / 255.0, - .blue = ((target->color >> 8) & 0xff) / 255.0, - .green = ((target->color >> 16) & 0xff) / 255.0, - .red = ((target->color >> 24) & 0xff) / 255.0, - }; + for (i = 0; i < vc->eosd_render_count; i++) { vdp_st = vdp-> output_surface_render_bitmap_surface(output_surface, - EOSD_VDP_RC(target->dest), - vc->eosd_surface, - EOSD_VDP_RC(target->source), - &color, + &vc->eosd_targets[i].dest, + vc->eosd_surface.surface, + &vc->eosd_targets[i].source, + &vc->eosd_targets[i].color, &blend_state, VDP_OUTPUT_SURFACE_RENDER_ROTATE_0); CHECK_ST_WARNING("EOSD: Error when rendering"); @@ -1055,41 +996,215 @@ static void generate_eosd(struct vo *vo, mp_eosd_images_t *imgs) struct vdpctx *vc = vo->priv; struct vdp_functions *vdp = vc->vdp; VdpStatus vdp_st; - struct eosd_packer *packer = vc->eosd_packer; - int i; + struct eosd_bitmap_surface *sfc = &vc->eosd_surface; + bool need_upload = false; - bool need_repos, need_upload, need_resize; - eosd_packer_generate(packer, imgs, &need_repos, &need_upload, &need_resize); + if (imgs->changed == 0 && sfc->packer) + return; // Nothing changed and we still have the old data - if (!need_upload) - return; + vc->eosd_render_count = 0; + + if (!imgs->imgs) + return; // There's nothing to render! + + if (imgs->changed == 1) + goto eosd_skip_upload; - if (need_resize) { - if (vc->eosd_surface != VDP_INVALID_HANDLE) { - vdp_st = vdp->bitmap_surface_destroy(vc->eosd_surface); + need_upload = true; + if (!sfc->packer) + sfc->packer = make_packer(vo, VDP_RGBA_FORMAT_A8); + int r = packer_pack_from_assimg(sfc->packer, imgs->imgs); + if (r < 0) { + mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] EOSD bitmaps do not fit on " + "a surface with the maximum supported size\n"); + return; + } else if (r == 1) { + if (sfc->surface != VDP_INVALID_HANDLE) { + vdp_st = vdp->bitmap_surface_destroy(sfc->surface); CHECK_ST_WARNING("Error when calling vdp_bitmap_surface_destroy"); } + mp_msg(MSGT_VO, MSGL_V, "[vdpau] Allocating a %dx%d surface for " + "EOSD bitmaps.\n", sfc->packer->w, sfc->packer->h); vdp_st = vdp->bitmap_surface_create(vc->vdp_device, VDP_RGBA_FORMAT_A8, - packer->surface.w, packer->surface.h, - true, &vc->eosd_surface); + sfc->packer->w, sfc->packer->h, + true, &sfc->surface); if (vdp_st != VDP_STATUS_OK) - vc->eosd_surface = VDP_INVALID_HANDLE; + sfc->surface = VDP_INVALID_HANDLE; CHECK_ST_WARNING("EOSD: error when creating surface"); } - if (vc->eosd_surface == VDP_INVALID_HANDLE) +eosd_skip_upload: + if (sfc->surface == VDP_INVALID_HANDLE) return; + if (sfc->packer->count > vc->eosd_targets_size) { + talloc_free(vc->eosd_targets); + vc->eosd_targets_size = sfc->packer->count; + vc->eosd_targets = talloc_size(vc, vc->eosd_targets_size + * sizeof(*vc->eosd_targets)); + } + + int i = 0; + for (ASS_Image *p = imgs->imgs; p; p = p->next, i++) { + if (p->w == 0 || p->h == 0) + continue; + struct eosd_target *target = &vc->eosd_targets[vc->eosd_render_count]; + int x = sfc->packer->result[i].x; + int y = sfc->packer->result[i].y; + target->source = (VdpRect){x, y, x + p->w, y + p->h}; + if (need_upload) { + vdp_st = vdp-> + bitmap_surface_put_bits_native(sfc->surface, + (const void *) &p->bitmap, + &p->stride, &target->source); + CHECK_ST_WARNING("EOSD: putbits failed"); + } + // Render dest, color, etc. + target->color.alpha = 1.0 - ((p->color >> 0) & 0xff) / 255.0; + target->color.blue = ((p->color >> 8) & 0xff) / 255.0; + target->color.green = ((p->color >> 16) & 0xff) / 255.0; + target->color.red = ((p->color >> 24) & 0xff) / 255.0; + target->dest.x0 = p->dst_x; + target->dest.y0 = p->dst_y; + target->dest.x1 = p->w + p->dst_x; + target->dest.y1 = p->h + p->dst_y; + vc->eosd_render_count++; + } +} - for (i = 0; i < vc->eosd_packer->targets_count; i++) { - struct eosd_target *target = &vc->eosd_packer->targets[i]; - ASS_Image *p = target->ass_img; +static void record_osd(void *ctx, int x0, int y0, int w, int h, + unsigned char *src, unsigned char *srca, int stride) +{ + struct vo *vo = ctx; + struct vdpctx *vc = vo->priv; + + assert(vc->old_osd_count < MAX_OLD_OSD_BITMAPS); + if (!w || !h) + return; + vc->old_osd_elements[vc->old_osd_count++] = (struct old_osd){ + x0, y0, w, h, src, srca, stride}; +} + +static void render_old_osd(struct vo *vo) +{ + struct vdpctx *vc = vo->priv; + struct vdp_functions *vdp = vc->vdp; + VdpOutputSurface output_surface = vc->output_surfaces[vc->surface_num]; + VdpStatus vdp_st; + struct eosd_bitmap_surface *sfc = &vc->osd_surface; + + if (!sfc->packer) + sfc->packer = make_packer(vo, VDP_RGBA_FORMAT_A8); + + packer_set_size(sfc->packer, vc->old_osd_count * 2); + for (int i = 0; i < vc->old_osd_count; i++) { + struct old_osd *o = &vc->old_osd_elements[i]; + sfc->packer->in[i*2] = sfc->packer->in[i*2 + 1] = + (struct pos){o->w, o->h}; + }; + int r = packer_pack(sfc->packer); + if (r < 0) { + mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] OSD bitmaps do not fit on " + "a surface with the maximum supported size\n"); + vc->old_osd_count = 0; + return; + } else if (r == 1) { + if (sfc->surface != VDP_INVALID_HANDLE) { + vdp_st = vdp->bitmap_surface_destroy(sfc->surface); + CHECK_ST_WARNING("Error when calling vdp_bitmap_surface_destroy"); + } + mp_msg(MSGT_VO, MSGL_V, "[vdpau] Allocating a %dx%d surface for " + "OSD bitmaps.\n", sfc->packer->w, sfc->packer->h); + vdp_st = vdp->bitmap_surface_create(vc->vdp_device, VDP_RGBA_FORMAT_A8, + sfc->packer->w, sfc->packer->h, + true, &sfc->surface); + if (vdp_st != VDP_STATUS_OK) + sfc->surface = VDP_INVALID_HANDLE; + CHECK_ST_WARNING("OSD: error when creating surface"); + } + + for (int i = 0; i < vc->old_osd_count; i++) { + struct old_osd *o = &vc->old_osd_elements[i]; + struct eosd_target *target1 = &vc->osd_targets[i][0]; + struct eosd_target *target2 = &vc->osd_targets[i][1]; + int w = o->w, h = o->h; + int sx = sfc->packer->result[i * 2].x; + int sy = sfc->packer->result[i * 2].y; + target1->source = (VdpRect){ sx, sy, sx + w, sy + h }; + target1->dest = (VdpRect){ o->x0, o->y0, o->x0 + w, o->y0 + h }; + sx = sfc->packer->result[i * 2 + 1].x; + sy = sfc->packer->result[i * 2 + 1].y; + target2->source = (VdpRect){ sx, sy, sx + w, sy + h }; + target2->dest = target1->dest; + vdp_st = vdp->bitmap_surface_put_bits_native(sfc->surface, + &(const void *){o->src}, + &(uint32_t){o->stride}, + &target1->source); + CHECK_ST_WARNING("OSD: putbits failed"); + int size_required = w * h; + if (vc->osd_data_size < size_required) { + talloc_free(vc->osd_data_temp); + vc->osd_data_temp = talloc_size(vc, size_required); + vc->osd_data_size = size_required; + } + for (int y = 0; y < h; y++) + for (int x = 0; x < w; x++) + vc->osd_data_temp[y * w + x] = -o->srca[y * o->stride + x]; + vdp_st = vdp->bitmap_surface_put_bits_native(sfc->surface, + &(const void *){vc->osd_data_temp}, + &(uint32_t){w}, + &target2->source); + CHECK_ST_WARNING("OSD: putbits failed"); + } + + VdpOutputSurfaceRenderBlendState blend_state_alpha = { + .struct_version = VDP_OUTPUT_SURFACE_RENDER_BLEND_STATE_VERSION, + .blend_factor_source_color = + VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ZERO, + .blend_factor_source_alpha = + VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ZERO, + .blend_factor_destination_color = + VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, + .blend_factor_destination_alpha = + VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, + .blend_equation_color = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD, + .blend_equation_alpha = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD, + }; + + VdpOutputSurfaceRenderBlendState blend_state_gray = { + .struct_version = VDP_OUTPUT_SURFACE_RENDER_BLEND_STATE_VERSION, + .blend_factor_source_color = + VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA, + .blend_factor_source_alpha = + VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_SRC_ALPHA, + .blend_factor_destination_color = + VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE, + .blend_factor_destination_alpha = + VDP_OUTPUT_SURFACE_RENDER_BLEND_FACTOR_ONE, + .blend_equation_color = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD, + .blend_equation_alpha = VDP_OUTPUT_SURFACE_RENDER_BLEND_EQUATION_ADD, + }; + + for (int i = 0; i < vc->old_osd_count; i++) { + struct eosd_target *target1 = &vc->osd_targets[i][0]; + struct eosd_target *target2 = &vc->osd_targets[i][1]; + vdp_st = vdp-> + output_surface_render_bitmap_surface(output_surface, + &target2->dest, + vc->osd_surface.surface, + &target2->source, + &(VdpColor){1, 1, 1, 1}, + &blend_state_alpha, + VDP_OUTPUT_SURFACE_RENDER_ROTATE_0); + CHECK_ST_WARNING("OSD: Error when rendering"); vdp_st = vdp-> - bitmap_surface_put_bits_native(vc->eosd_surface, - (const void *) &p->bitmap, - &p->stride, - EOSD_VDP_RC(target->source)); - CHECK_ST_WARNING("EOSD: putbits failed"); - target->ass_img = NULL; + output_surface_render_bitmap_surface(output_surface, + &target1->dest, + vc->osd_surface.surface, + &target1->source, + &(VdpColor){1, 1, 1, 1}, + &blend_state_gray, + VDP_OUTPUT_SURFACE_RENDER_ROTATE_0); + CHECK_ST_WARNING("OSD: Error when rendering"); } } @@ -1100,9 +1215,11 @@ static void draw_osd(struct vo *vo, struct osd_state *osd) if (handle_preemption(vo) < 0) return; + vc->old_osd_count = 0; osd_draw_text_ext(osd, vo->dwidth, vo->dheight, vc->border_x, vc->border_y, vc->border_x, vc->border_y, vc->vid_width, - vc->vid_height, draw_osd_I8A8, vo); + vc->vid_height, record_osd, vo); + render_old_osd(vo); } static int update_presentation_queue_status(struct vo *vo) @@ -1448,15 +1565,20 @@ static void destroy_vdpau_objects(struct vo *vo) "vdp_presentation_queue_target_destroy"); } - for (i = 0; i <= vc->num_output_surfaces; i++) { + for (i = 0; i < vc->num_output_surfaces; i++) { if (vc->output_surfaces[i] == VDP_INVALID_HANDLE) continue; vdp_st = vdp->output_surface_destroy(vc->output_surfaces[i]); CHECK_ST_WARNING("Error when calling vdp_output_surface_destroy"); } - if (vc->eosd_surface != VDP_INVALID_HANDLE) { - vdp_st = vdp->bitmap_surface_destroy(vc->eosd_surface); + if (vc->eosd_surface.surface != VDP_INVALID_HANDLE) { + vdp_st = vdp->bitmap_surface_destroy(vc->eosd_surface.surface); + CHECK_ST_WARNING("Error when calling vdp_bitmap_surface_destroy"); + } + + if (vc->osd_surface.surface != VDP_INVALID_HANDLE) { + vdp_st = vdp->bitmap_surface_destroy(vc->osd_surface.surface); CHECK_ST_WARNING("Error when calling vdp_bitmap_surface_destroy"); } @@ -1486,8 +1608,6 @@ static int preinit(struct vo *vo, const char *arg) { struct vdpctx *vc = vo->priv; - vc->eosd_packer = eosd_packer_create(vo); - // Mark everything as invalid first so uninit() can tell what has been // allocated mark_vdpau_objects_uninitialized(vo); @@ -1511,10 +1631,6 @@ static int preinit(struct vo *vo, const char *arg) return -1; } - // full grayscale palette. - for (int i = 0; i < PALETTE_SIZE; ++i) - vc->palette[i] = (i << 16) | (i << 8) | i; - return 0; } |