RepoMirrors
/
mpv
mirror of https://github.com/mpv-player/mpv
1
0
Fork 0
Code Issues Releases Wiki Activity
mpv/sub/draw_bmp.c

545 lines
19 KiB
C
Raw Normal View History

sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
/*
* This file is part of mpv.
*
* mpv 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.
*
* mpv 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
Update license headers Signed-off-by: wm4 <wm4@nowhere>
2015-04-13 07:36:54 +00:00
* with mpv. If not, see <http://www.gnu.org/licenses/>.
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
*/
options: remove subtitle related options that did nothing Most of these cased working when the OSD was switched to libass, or didn't do anything even before that. Also don't recursively include subreader.h in sub.h.
2012-10-22 14:15:52 +00:00
#include <stddef.h>
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
#include <stdbool.h>
sub: add cache to mp_draw_sub_bitmaps() This caches scaled RGBA sub-bitmaps.
2012-10-19 15:49:49 +00:00
#include <assert.h>
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
#include <math.h>
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
#include <inttypes.h>
sws_utils: don't recursively include libswscale header Add libswscale includes where they are actually needed instead.
2013-07-18 11:46:05 +00:00
#include <libswscale/swscale.h>
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
#include <libavutil/common.h>
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
Split mpvcore/ into common/, misc/, bstr/
2013-12-17 01:39:45 +00:00
#include "common/common.h"
Rename sub.c/.h to osd.c/.h This was way too misleading. osd.c merely calls the subtitle renderers, instead of actually dealing with subtitles.
2013-11-24 11:58:06 +00:00
#include "draw_bmp.h"
#include "img_convert.h"
Rename directories, move files (step 2 of 2) Finish renaming directories and moving files. Adjust all include statements to make the previous commit compile. The two commits are separate, because git is bad at tracking renames and content changes at the same time. Also take this as an opportunity to remove the separation between "common" and "mplayer" sources in the Makefile. ("common" used to be shared between mplayer and mencoder.)
2012-11-09 00:06:43 +00:00
#include "video/mp_image.h"
#include "video/sws_utils.h"
#include "video/img_format.h"
#include "video/csputils.h"
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
sub: add cache to mp_draw_sub_bitmaps() This caches scaled RGBA sub-bitmaps.
2012-10-19 15:49:49 +00:00
const bool mp_draw_sub_formats[SUBBITMAP_COUNT] = {
[SUBBITMAP_LIBASS] = true,
[SUBBITMAP_RGBA] = true,
};
struct sub_cache {
struct mp_image *i, *a;
};
struct part {
osd: simplify an aspect of change detection handling There was a somewhat obscure optimization in the OSD and subtitle rendering path: if only the position of the sub-images changed, and not the actual image data, uploading of the image data could be skipped. In theory, this could speed up things like scrolling subtitles. But it turns out that even in the rare cases subtitles have such scrolls or axis-aligned movement, modern libass rarely signals this kind of change. Possibly this is because of sub-pixel handling and such, which break this. As such, it's a worthless optimization and just introduces additional complexity and subtle bugs (especially in cases libass does the opposite: incorrectly signaling a position change only, which happened before). Remove this optimization, and rename bitmap_pos_id to change_id.
2015-03-18 11:33:14 +00:00
int change_id;
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
int imgfmt;
enum mp_csp colorspace;
enum mp_csp_levels levels;
sub: add cache to mp_draw_sub_bitmaps() This caches scaled RGBA sub-bitmaps.
2012-10-19 15:49:49 +00:00
int num_imgs;
struct sub_cache *imgs;
};
struct mp_draw_sub_cache
{
struct part *parts[MAX_OSD_PARTS];
draw_bmp: do not reallocate upsample temp image on each frame Doesn't seem to help too much...
2012-12-25 14:39:47 +00:00
struct mp_image *upsample_img;
struct mp_image upsample_temp;
sub: add cache to mp_draw_sub_bitmaps() This caches scaled RGBA sub-bitmaps.
2012-10-19 15:49:49 +00:00
};
draw_bmp: do not reallocate upsample temp image on each frame Doesn't seem to help too much...
2012-12-25 14:39:47 +00:00
draw_bmp: always allocate cache Allocate it even if it's needed. The actually done work is almost the same, except that the code is a bit simpler. May need more memory at once for RGB subs that use more than one part, which is rare.
2012-12-25 14:11:07 +00:00
static struct part *get_cache(struct mp_draw_sub_cache *cache,
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
struct sub_bitmaps *sbs, struct mp_image *format);
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
static bool get_sub_area(struct mp_rect bb, struct mp_image *temp,
struct sub_bitmap *sb, struct mp_image *out_area,
int *out_src_x, int *out_src_y);
sub: use macros to remove code duplication Meh.
2015-12-24 16:32:05 +00:00
#define CONDITIONAL 1
#define BLEND_CONST_ALPHA(TYPE) \
TYPE *dst_r = dst_rp; \
for (int x = 0; x < w; x++) { \
uint32_t srcap = srca_r[x]; \
if (CONDITIONAL && !srcap) continue; \
srcap *= srcamul; /* now 0..65025 */ \
dst_r[x] = (srcp * srcap + dst_r[x] * (65025 - srcap) + 32512) / 65025; \
}
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
sub: merge bitmap render functions into one for each kind Merge blend_src8_alpha and blend_src16_alpha into blend_src_alpha, and the same for blend_const_alpha. One thing that changes is that the vertical loop is now shared for both code paths. I think this is slightly easier to read, and it's a bit shorter as well.
2015-12-24 16:22:32 +00:00
// dst = srcp * (srca * srcamul) + dst * (1 - (srca * srcamul))
static void blend_const_alpha(void *dst, int dst_stride, int srcp,
uint8_t *srca, int srca_stride, uint8_t srcamul,
int w, int h, int bytes)
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
{
if (!srcamul)
return;
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
for (int y = 0; y < h; y++) {
sub: merge bitmap render functions into one for each kind Merge blend_src8_alpha and blend_src16_alpha into blend_src_alpha, and the same for blend_const_alpha. One thing that changes is that the vertical loop is now shared for both code paths. I think this is slightly easier to read, and it's a bit shorter as well.
2015-12-24 16:22:32 +00:00
void *dst_rp = (uint8_t *)dst + dst_stride * y;
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
uint8_t *srca_r = srca + srca_stride * y;
sub: merge bitmap render functions into one for each kind Merge blend_src8_alpha and blend_src16_alpha into blend_src_alpha, and the same for blend_const_alpha. One thing that changes is that the vertical loop is now shared for both code paths. I think this is slightly easier to read, and it's a bit shorter as well.
2015-12-24 16:22:32 +00:00
if (bytes == 2) {
sub: use macros to remove code duplication Meh.
2015-12-24 16:32:05 +00:00
BLEND_CONST_ALPHA(uint16_t)
sub: merge bitmap render functions into one for each kind Merge blend_src8_alpha and blend_src16_alpha into blend_src_alpha, and the same for blend_const_alpha. One thing that changes is that the vertical loop is now shared for both code paths. I think this is slightly easier to read, and it's a bit shorter as well.
2015-12-24 16:22:32 +00:00
} else if (bytes == 1) {
sub: use macros to remove code duplication Meh.
2015-12-24 16:32:05 +00:00
BLEND_CONST_ALPHA(uint8_t)
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
}
}
}
sub: use macros to remove code duplication Meh.
2015-12-24 16:32:05 +00:00
#define BLEND_SRC_ALPHA(TYPE) \
TYPE *dst_r = dst_rp, *src_r = src_rp; \
for (int x = 0; x < w; x++) { \
uint32_t srcap = srca_r[x]; \
if (CONDITIONAL && !srcap) continue; \
dst_r[x] = (src_r[x] * srcap + dst_r[x] * (255 - srcap) + 127) / 255; \
}
sub: merge bitmap render functions into one for each kind Merge blend_src8_alpha and blend_src16_alpha into blend_src_alpha, and the same for blend_const_alpha. One thing that changes is that the vertical loop is now shared for both code paths. I think this is slightly easier to read, and it's a bit shorter as well.
2015-12-24 16:22:32 +00:00
// dst = src * srca + dst * (1 - srca)
static void blend_src_alpha(void *dst, int dst_stride, void *src,
int src_stride, uint8_t *srca, int srca_stride,
int w, int h, int bytes)
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
{
for (int y = 0; y < h; y++) {
sub: merge bitmap render functions into one for each kind Merge blend_src8_alpha and blend_src16_alpha into blend_src_alpha, and the same for blend_const_alpha. One thing that changes is that the vertical loop is now shared for both code paths. I think this is slightly easier to read, and it's a bit shorter as well.
2015-12-24 16:22:32 +00:00
void *dst_rp = (uint8_t *)dst + dst_stride * y;
void *src_rp = (uint8_t *)src + src_stride * y;
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
uint8_t *srca_r = srca + srca_stride * y;
sub: merge bitmap render functions into one for each kind Merge blend_src8_alpha and blend_src16_alpha into blend_src_alpha, and the same for blend_const_alpha. One thing that changes is that the vertical loop is now shared for both code paths. I think this is slightly easier to read, and it's a bit shorter as well.
2015-12-24 16:22:32 +00:00
if (bytes == 2) {
sub: use macros to remove code duplication Meh.
2015-12-24 16:32:05 +00:00
BLEND_SRC_ALPHA(uint16_t)
sub: merge bitmap render functions into one for each kind Merge blend_src8_alpha and blend_src16_alpha into blend_src_alpha, and the same for blend_const_alpha. One thing that changes is that the vertical loop is now shared for both code paths. I think this is slightly easier to read, and it's a bit shorter as well.
2015-12-24 16:22:32 +00:00
} else if (bytes == 1) {
sub: use macros to remove code duplication Meh.
2015-12-24 16:32:05 +00:00
BLEND_SRC_ALPHA(uint8_t)
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
}
}
}
sub: use macros to remove code duplication Meh.
2015-12-24 16:32:05 +00:00
#define BLEND_SRC_DST_MUL(TYPE, MAX) \
TYPE *dst_r = dst_rp; \
for (int x = 0; x < w; x++) { \
uint16_t srcp = src_r[x] * srcmul; /* now 0..65025 */ \
dst_r[x] = (srcp * (MAX) + dst_r[x] * (65025 - srcp) + 32512) / 65025; \
}
sub: better alpha blending when rendering to alpha surfaces This actually treats destination alpha correctly, and gives much better results than before. I don't know if this is perfectly correct yet, though. Slight difference with vo_opengl behavior suggests it might not be. Note that this does not affect VOs with true alpha support. vo_opengl does not use this code at all, and does the alpha calculations in OpenGL instead.
2015-12-24 13:43:23 +00:00
// dst = src * srcmul + dst * (1 - src * srcmul)
static void blend_src_dst_mul(void *dst, int dst_stride,
uint8_t *src, int src_stride, uint8_t srcmul,
int w, int h, int dst_bytes)
{
for (int y = 0; y < h; y++) {
void *dst_rp = (uint8_t *)dst + dst_stride * y;
uint8_t *src_r = (uint8_t *)src + src_stride * y;
if (dst_bytes == 2) {
sub: use macros to remove code duplication Meh.
2015-12-24 16:32:05 +00:00
BLEND_SRC_DST_MUL(uint16_t, 65025)
sub: better alpha blending when rendering to alpha surfaces This actually treats destination alpha correctly, and gives much better results than before. I don't know if this is perfectly correct yet, though. Slight difference with vo_opengl behavior suggests it might not be. Note that this does not affect VOs with true alpha support. vo_opengl does not use this code at all, and does the alpha calculations in OpenGL instead.
2015-12-24 13:43:23 +00:00
} else if (dst_bytes == 1) {
sub: use macros to remove code duplication Meh.
2015-12-24 16:32:05 +00:00
BLEND_SRC_DST_MUL(uint8_t, 255)
sub: better alpha blending when rendering to alpha surfaces This actually treats destination alpha correctly, and gives much better results than before. I don't know if this is perfectly correct yet, though. Slight difference with vo_opengl behavior suggests it might not be. Note that this does not affect VOs with true alpha support. vo_opengl does not use this code at all, and does the alpha calculations in OpenGL instead.
2015-12-24 13:43:23 +00:00
}
}
}
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
static void unpremultiply_and_split_BGR32(struct mp_image *img,
struct mp_image *alpha)
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
{
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
for (int y = 0; y < img->h; ++y) {
draw_bmp: fix IMGFMT_BGR32 use
2012-10-22 15:28:36 +00:00
uint32_t *irow = (uint32_t *) &img->planes[0][img->stride[0] * y];
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
uint8_t *arow = &alpha->planes[0][alpha->stride[0] * y];
for (int x = 0; x < img->w; ++x) {
draw_bmp: fix IMGFMT_BGR32 use
2012-10-22 15:28:36 +00:00
uint32_t pval = irow[x];
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
uint8_t aval = (pval >> 24);
uint8_t rval = (pval >> 16) & 0xFF;
uint8_t gval = (pval >> 8) & 0xFF;
uint8_t bval = pval & 0xFF;
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
// multiplied = separate * alpha / 255
// separate = rint(multiplied * 255 / alpha)
// = floor(multiplied * 255 / alpha + 0.5)
// = floor((multiplied * 255 + 0.5 * alpha) / alpha)
// = floor((multiplied * 255 + floor(0.5 * alpha)) / alpha)
int div = (int) aval;
int add = div / 2;
if (aval) {
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
rval = FFMIN(255, (rval * 255 + add) / div);
gval = FFMIN(255, (gval * 255 + add) / div);
bval = FFMIN(255, (bval * 255 + add) / div);
draw_bmp: fix IMGFMT_BGR32 use
2012-10-22 15:28:36 +00:00
irow[x] = bval + (gval << 8) + (rval << 16) + (aval << 24);
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
}
arow[x] = aval;
}
}
}
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
// dst_format merely contains the target colorspace/format information
static void scale_sb_rgba(struct sub_bitmap *sb, struct mp_image *dst_format,
struct mp_image **out_sbi, struct mp_image **out_sba)
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
{
mp_image: simplify image allocation mp_image_alloc_planes() allocated images with minimal stride, even if the resulting stride was unaligned. It was the responsibility of vf_get_image() to set an image's width to something larger than required to get an aligned stride, and then crop it. Always allocate with aligned strides instead. Get rid of IMGFMT_IF09 special handling. This format is not used anymore. (IF09 has 4x4 chroma sub-sampling, and that is what it was mainly used for - this is still supported.) Get rid of swapped chroma plane allocation. This is not used anywhere, and VOs like vo_xv, vo_direct3d and vo_sdl do their own swapping. Always round chroma width/height up instead of down. Consider 4:2:0 and an uneven image size. For luma, the size was left uneven, and the chroma size was rounded down. This doesn't make sense, because chroma would be missing for the bottom/right border. Remove mp_image_new_empty() and mp_image_alloc_planes(), they were not used anymore, except in draw_bmp.c. (It's still allowed to setup mp_images manually, you just can't allocate image data with them anymore - this is also done in draw_bmp.c.)
2012-12-19 11:04:32 +00:00
struct mp_image sbisrc = {0};
mp_image_setfmt(&sbisrc, IMGFMT_BGR32);
mp_image_set_size(&sbisrc, sb->w, sb->h);
sbisrc.planes[0] = sb->bitmap;
sbisrc.stride[0] = sb->stride;
struct mp_image *sbisrc2 = mp_image_alloc(IMGFMT_BGR32, sb->dw, sb->dh);
struct mp_image *sba = mp_image_alloc(IMGFMT_Y8, sb->dw, sb->dh);
video: introduce failure path for image allocations Until now, failure to allocate image data resulted in a crash (i.e. abort() was called). This was intentional, because it's pretty silly to degrade playback, and in almost all situations, the OOM will probably kill you anyway. (And then there's the standard Linux overcommit behavior, which also will kill you at some point.) But I changed my opinion, so here we go. This change does not affect _all_ memory allocations, just image data. Now in most failure cases, the output will just be skipped. For video filters, this coincidentally means that failure is treated as EOF (because the playback core assumes EOF if nothing comes out of the video filter chain). In other situations, output might be in some way degraded, like skipping frames, not scaling OSD, and such. Functions whose return values changed semantics: mp_image_alloc mp_image_new_copy mp_image_new_ref mp_image_make_writeable mp_image_setrefp mp_image_to_av_frame_and_unref mp_image_from_av_frame mp_image_new_external_ref mp_image_new_custom_ref mp_image_pool_make_writeable mp_image_pool_get mp_image_pool_new_copy mp_vdpau_mixed_frame_create vf_alloc_out_image vf_make_out_image_writeable glGetWindowScreenshot
2014-06-17 20:43:43 +00:00
struct mp_image *sbi = mp_image_alloc(dst_format->imgfmt, sb->dw, sb->dh);
if (!sbisrc2 || !sba || !sbi) {
talloc_free(sbisrc2);
talloc_free(sba);
talloc_free(sbi);
return;
}
mp_image_swscale(sbisrc2, &sbisrc, SWS_BILINEAR);
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
unpremultiply_and_split_BGR32(sbisrc2, sba);
video: make mp_image use mp_image_params directly Minor cleanup, so that we can stuff more information into mp_image_params later.
2014-04-20 19:27:45 +00:00
sbi->params.colorspace = dst_format->params.colorspace;
sbi->params.colorlevels = dst_format->params.colorlevels;
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
mp_image_swscale(sbi, sbisrc2, SWS_BILINEAR);
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
mp_image: simplify image allocation mp_image_alloc_planes() allocated images with minimal stride, even if the resulting stride was unaligned. It was the responsibility of vf_get_image() to set an image's width to something larger than required to get an aligned stride, and then crop it. Always allocate with aligned strides instead. Get rid of IMGFMT_IF09 special handling. This format is not used anymore. (IF09 has 4x4 chroma sub-sampling, and that is what it was mainly used for - this is still supported.) Get rid of swapped chroma plane allocation. This is not used anywhere, and VOs like vo_xv, vo_direct3d and vo_sdl do their own swapping. Always round chroma width/height up instead of down. Consider 4:2:0 and an uneven image size. For luma, the size was left uneven, and the chroma size was rounded down. This doesn't make sense, because chroma would be missing for the bottom/right border. Remove mp_image_new_empty() and mp_image_alloc_planes(), they were not used anymore, except in draw_bmp.c. (It's still allowed to setup mp_images manually, you just can't allocate image data with them anymore - this is also done in draw_bmp.c.)
2012-12-19 11:04:32 +00:00
talloc_free(sbisrc2);
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
*out_sbi = sbi;
*out_sba = sba;
}
draw_bmp: always allocate cache Allocate it even if it's needed. The actually done work is almost the same, except that the code is a bit simpler. May need more memory at once for RGB subs that use more than one part, which is rare.
2012-12-25 14:11:07 +00:00
static void draw_rgba(struct mp_draw_sub_cache *cache, struct mp_rect bb,
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
struct mp_image *temp, int bits,
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
struct sub_bitmaps *sbs)
{
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
struct part *part = get_cache(cache, sbs, temp);
draw_bmp: always allocate cache Allocate it even if it's needed. The actually done work is almost the same, except that the code is a bit simpler. May need more memory at once for RGB subs that use more than one part, which is rare.
2012-12-25 14:11:07 +00:00
assert(part);
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
for (int i = 0; i < sbs->num_parts; ++i) {
struct sub_bitmap *sb = &sbs->parts[i];
draw_bmp: remove swscale bug workaround ffmpeg ticket #1852 is fixed with 425c30dda. This didn't actually happen in practice.
2012-10-28 15:08:19 +00:00
if (sb->w < 1 || sb->h < 1)
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
continue;
struct mp_image dst;
int src_x, src_y;
if (!get_sub_area(bb, temp, sb, &dst, &src_x, &src_y))
continue;
draw_bmp: always allocate cache Allocate it even if it's needed. The actually done work is almost the same, except that the code is a bit simpler. May need more memory at once for RGB subs that use more than one part, which is rare.
2012-12-25 14:11:07 +00:00
struct mp_image *sbi = part->imgs[i].i;
struct mp_image *sba = part->imgs[i].a;
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
if (!(sbi && sba))
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
scale_sb_rgba(sb, temp, &sbi, &sba);
video: introduce failure path for image allocations Until now, failure to allocate image data resulted in a crash (i.e. abort() was called). This was intentional, because it's pretty silly to degrade playback, and in almost all situations, the OOM will probably kill you anyway. (And then there's the standard Linux overcommit behavior, which also will kill you at some point.) But I changed my opinion, so here we go. This change does not affect _all_ memory allocations, just image data. Now in most failure cases, the output will just be skipped. For video filters, this coincidentally means that failure is treated as EOF (because the playback core assumes EOF if nothing comes out of the video filter chain). In other situations, output might be in some way degraded, like skipping frames, not scaling OSD, and such. Functions whose return values changed semantics: mp_image_alloc mp_image_new_copy mp_image_new_ref mp_image_make_writeable mp_image_setrefp mp_image_to_av_frame_and_unref mp_image_from_av_frame mp_image_new_external_ref mp_image_new_custom_ref mp_image_pool_make_writeable mp_image_pool_get mp_image_pool_new_copy mp_vdpau_mixed_frame_create vf_alloc_out_image vf_make_out_image_writeable glGetWindowScreenshot
2014-06-17 20:43:43 +00:00
// on OOM, skip drawing
if (!(sbi && sba))
continue;
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
int bytes = (bits + 7) / 8;
uint8_t *alpha_p = sba->planes[0] + src_y * sba->stride[0] + src_x;
draw_bmp: better way to find 444 format Even though #ifdef ACCURATE is removed, the result should be about the same. The fallback is only used by packed YUV formats (YUYV, NV12), and doing 16 bit for them instead of 8 bit is not useful. A side effect is that Y8 (gray) is not converted drawing subs, and for alpha formats, the alpha plane is not removed. This means the number of planes after upsampling can be 1-4 (1: gray, 2: gray+alpha, 3: planar, 4: planar+alpha). The code has to be adjusted accordingly to work on the color planes only. Also remove the workaround for the chroma shift 31 hack.
2012-12-25 13:54:42 +00:00
for (int p = 0; p < (temp->num_planes > 2 ? 3 : 1); p++) {
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
void *src = sbi->planes[p] + src_y * sbi->stride[p] + src_x * bytes;
blend_src_alpha(dst.planes[p], dst.stride[p], src, sbi->stride[p],
alpha_p, sba->stride[0], dst.w, dst.h, bytes);
}
sub: better alpha blending when rendering to alpha surfaces This actually treats destination alpha correctly, and gives much better results than before. I don't know if this is perfectly correct yet, though. Slight difference with vo_opengl behavior suggests it might not be. Note that this does not affect VOs with true alpha support. vo_opengl does not use this code at all, and does the alpha calculations in OpenGL instead.
2015-12-24 13:43:23 +00:00
if (temp->num_planes >= 4) {
blend_src_dst_mul(dst.planes[3], dst.stride[3], alpha_p,
sba->stride[0], 255, dst.w, dst.h, bytes);
}
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
draw_bmp: always allocate cache Allocate it even if it's needed. The actually done work is almost the same, except that the code is a bit simpler. May need more memory at once for RGB subs that use more than one part, which is rare.
2012-12-25 14:11:07 +00:00
part->imgs[i].i = talloc_steal(part, sbi);
part->imgs[i].a = talloc_steal(part, sba);
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
}
}
draw_bmp: always allocate cache Allocate it even if it's needed. The actually done work is almost the same, except that the code is a bit simpler. May need more memory at once for RGB subs that use more than one part, which is rare.
2012-12-25 14:11:07 +00:00
static void draw_ass(struct mp_draw_sub_cache *cache, struct mp_rect bb,
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
struct mp_image *temp, int bits, struct sub_bitmaps *sbs)
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
{
draw_bmp, csputils: use function instead of macro
2012-10-25 17:37:47 +00:00
struct mp_csp_params cspar = MP_CSP_PARAMS_DEFAULTS;
csputils: move image_params -> csp_params into a function Although the line count increases, this is better for making sure everything is handled consistently for all users of the mp_csp_params stuff. This also makes sure mp_csp_params is always initialized with MP_CSP_PARAMS_DEFAULTS (for consistency).
2015-01-06 14:21:26 +00:00
mp_csp_set_image_params(&cspar, &temp->params);
csputils: get rid of mp_csp_details It used to be central, but now it's just unneeded.
2015-01-06 14:04:29 +00:00
cspar.levels_out = MP_CSP_LEVELS_PC; // RGB (libass.color)
csputils: remove obscure int_bits matrix scaling This has no reason to be there. Put the functionality into another function instead. While we're at it, also adjust for possible accuracy issues with high bit depth YUV (matters for rendering subtitles into screenshots only).
2015-12-08 23:08:00 +00:00
cspar.input_bits = bits;
cspar.texture_bits = (bits + 7) / 8 * 8;
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
csputils: replace float[3][4] with a struct Not being able to use the 3x3 part of the matrix was annoying, so split it into a float[3][3] matrix and a separate float[3] constant vector.
2015-01-06 15:49:53 +00:00
struct mp_cmat yuv2rgb, rgb2yuv;
mp_image: remove redundant flags field Because gcc (and clang) is a goddamn PITA and unnecessarily warns if the universal initializer for structs is used (like mp_image x = {}) and the first member of the struct is also a struct, move the w/h fields to the top.
2015-04-10 19:06:18 +00:00
bool need_conv = temp->fmt.flags & MP_IMGFLAG_YUV;
draw_bmp: make code more obvious, remove assertion Silences a Coverity warning. Also, drop the assert(); although it should be pretty much guaranteed that things happen this way, it's still a bit fuzzy.
2014-11-21 04:56:55 +00:00
if (need_conv) {
csputils: rename "yuv2rgb" functions They're not necessarily restricted to YUV aka YCbCr. vo_direct3d.c and demux_disc.c (DVD specific code) changes untested.
2015-12-08 23:22:12 +00:00
mp_get_csp_matrix(&cspar, &yuv2rgb);
mp_invert_cmat(&rgb2yuv, &yuv2rgb);
sub: don't crash on GBRP video mp_get_yuv2rgb_coeffs() will crash if the colorspace is explicitly set to RGB.
2013-03-28 19:35:36 +00:00
}
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
for (int i = 0; i < sbs->num_parts; ++i) {
struct sub_bitmap *sb = &sbs->parts[i];
struct mp_image dst;
int src_x, src_y;
if (!get_sub_area(bb, temp, sb, &dst, &src_x, &src_y))
continue;
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
int r = (sb->libass.color >> 24) & 0xFF;
int g = (sb->libass.color >> 16) & 0xFF;
int b = (sb->libass.color >> 8) & 0xFF;
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
int a = 255 - (sb->libass.color & 0xFF);
csputils: remove obscure int_bits matrix scaling This has no reason to be there. Put the functionality into another function instead. While we're at it, also adjust for possible accuracy issues with high bit depth YUV (matters for rendering subtitles into screenshots only).
2015-12-08 23:08:00 +00:00
int color_yuv[3];
draw_bmp: make code more obvious, remove assertion Silences a Coverity warning. Also, drop the assert(); although it should be pretty much guaranteed that things happen this way, it's still a bit fuzzy.
2014-11-21 04:56:55 +00:00
if (need_conv) {
csputils: remove obscure int_bits matrix scaling This has no reason to be there. Put the functionality into another function instead. While we're at it, also adjust for possible accuracy issues with high bit depth YUV (matters for rendering subtitles into screenshots only).
2015-12-08 23:08:00 +00:00
int rgb[3] = {r, g, b};
mp_map_fixp_color(&rgb2yuv, 8, rgb, cspar.texture_bits, color_yuv);
draw_bmp: add RGB rendering to fix image quality issues As pointed out in commit ed01df, the quality loss due to frequent conversion between RGB and YUV is too much when drawing OSD and subtitles. Fix this by staying in the same colorspace when drawing subtitles. Render directly to RGB, without converting to YUV first. The bad thing about packed RGB is that there are many pixel formats, which would all require special code for blending. It's also completely incompatible to planar YUV. Use planar RGB instead, which allows us to reuse all code originally written for planar YUV. The only thing that needs to be changed is the color conversion in the libass case. (In exchange for simpler code, the image has to be copied, but this is still much better than converting to YUV.) Unfortunately, libswscale doesn't support planar RGB output. Add a hack to sws_utils.c to handle conversion to planar RGB. In the common case, when converting 32 bit per pixel RGB, calling swscale can be avoided entirely. The change in mp_image.c is needed to allocate GBRP images correctly. (The issue with vo_x11 could be easily solved by always backing up the same bounding box as the bitmap drawing RGB<->YUV conversion does, but this commit is probably the better fix.)
2012-11-22 12:30:16 +00:00
} else {
color_yuv[0] = g;
color_yuv[1] = b;
color_yuv[2] = r;
}
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
int bytes = (bits + 7) / 8;
uint8_t *alpha_p = (uint8_t *)sb->bitmap + src_y * sb->stride + src_x;
draw_bmp: better way to find 444 format Even though #ifdef ACCURATE is removed, the result should be about the same. The fallback is only used by packed YUV formats (YUYV, NV12), and doing 16 bit for them instead of 8 bit is not useful. A side effect is that Y8 (gray) is not converted drawing subs, and for alpha formats, the alpha plane is not removed. This means the number of planes after upsampling can be 1-4 (1: gray, 2: gray+alpha, 3: planar, 4: planar+alpha). The code has to be adjusted accordingly to work on the color planes only. Also remove the workaround for the chroma shift 31 hack.
2012-12-25 13:54:42 +00:00
for (int p = 0; p < (temp->num_planes > 2 ? 3 : 1); p++) {
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
blend_const_alpha(dst.planes[p], dst.stride[p], color_yuv[p],
alpha_p, sb->stride, a, dst.w, dst.h, bytes);
}
sub: better alpha blending when rendering to alpha surfaces This actually treats destination alpha correctly, and gives much better results than before. I don't know if this is perfectly correct yet, though. Slight difference with vo_opengl behavior suggests it might not be. Note that this does not affect VOs with true alpha support. vo_opengl does not use this code at all, and does the alpha calculations in OpenGL instead.
2015-12-24 13:43:23 +00:00
if (temp->num_planes >= 4) {
blend_src_dst_mul(dst.planes[3], dst.stride[3], alpha_p,
sb->stride, a, dst.w, dst.h, bytes);
}
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
}
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
}
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
static void get_swscale_alignment(const struct mp_image *img, int *out_xstep,
int *out_ystep)
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
{
mp_image: remove redundant chroma_x/y_shift fields
2015-04-10 19:02:16 +00:00
int sx = (1 << img->fmt.chroma_xs);
int sy = (1 << img->fmt.chroma_ys);
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
for (int p = 0; p < img->num_planes; ++p) {
mp_image: simplify image allocation mp_image_alloc_planes() allocated images with minimal stride, even if the resulting stride was unaligned. It was the responsibility of vf_get_image() to set an image's width to something larger than required to get an aligned stride, and then crop it. Always allocate with aligned strides instead. Get rid of IMGFMT_IF09 special handling. This format is not used anymore. (IF09 has 4x4 chroma sub-sampling, and that is what it was mainly used for - this is still supported.) Get rid of swapped chroma plane allocation. This is not used anywhere, and VOs like vo_xv, vo_direct3d and vo_sdl do their own swapping. Always round chroma width/height up instead of down. Consider 4:2:0 and an uneven image size. For luma, the size was left uneven, and the chroma size was rounded down. This doesn't make sense, because chroma would be missing for the bottom/right border. Remove mp_image_new_empty() and mp_image_alloc_planes(), they were not used anymore, except in draw_bmp.c. (It's still allowed to setup mp_images manually, you just can't allocate image data with them anymore - this is also done in draw_bmp.c.)
2012-12-19 11:04:32 +00:00
int bits = img->fmt.bpp[p];
draw_bmp: compensate for libswscale writing past image bounds libswscale tends to overwrite the area between (w,y)-(0,y+1). It tries to process multiple pixels at once, and if the memory past the last x pixel is inside a SIMD operation, but still below the image stride, it overwrites that data with black. This happens with vo_x11 and 32 bit RGBA formats. The bug is visible as black bar right of the subtitle bounding box. Fix by giving libswscale more alignment. Then the "outside" pixels are inside, and are processed normally instead of overwritten with black. NOTE: we do not increase the alignment constant, because this is a separate issue from pointer alignment. libavutil's av_malloc() wouldn't actually satisfy the increased alignment either.
2012-10-17 12:06:03 +00:00
// the * 2 fixes problems with writing past the destination width
mp_image: remove redundant chroma_x/y_shift fields
2015-04-10 19:02:16 +00:00
while (((sx >> img->fmt.chroma_xs) * bits) % (SWS_MIN_BYTE_ALIGN * 8 * 2))
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
sx *= 2;
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
}
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
*out_xstep = sx;
*out_ystep = sy;
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
}
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
static void align_bbox(int xstep, int ystep, struct mp_rect *rc)
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
{
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
rc->x0 = rc->x0 & ~(xstep - 1);
rc->y0 = rc->y0 & ~(ystep - 1);
rc->x1 = FFALIGN(rc->x1, xstep);
rc->y1 = FFALIGN(rc->y1, ystep);
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
}
vo_xv: don't require frame stepping to remove OSD or subs In order to improve performance, vo_xv didn't create a backup of the video frame before drawing OSD and subtitles during normal playback. It required the frontend to do frame stepping if it wanted to redraw the OSD, but no backup of the video frame was available. (Consider the following use case: enable the OSD permanently with --osd-level=3, then pause during playback and do something that shows an OSD message. The player will advance the video by one frame at the time the new OSD message is first drawn.) This also meant that taking a screenshot during playback with vo_xv would include OSD and subtitles in the resulting image. Fix this by always creating a backup before drawing OSD or subtitles. In order to avoid having to create a full copy of the whole image frame, introduce a complex scheme that tries to backup only the changed regions. It's unclear whether the additional complexity in draw_bmp.c for backing up only the changed areas of the frame is worth it. Possibly a simpler implementation would suffice, such as tracking only Y ranges of changed image data, or even just copying the full frame. vo_xv's get_screenshot() now always creates a copy in order not to modify the currently displayed frame.
2012-11-21 16:59:24 +00:00
// Post condition, if true returned: rc is inside img
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
static bool align_bbox_for_swscale(struct mp_image *img, struct mp_rect *rc)
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
{
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
struct mp_rect img_rect = {0, 0, img->w, img->h};
// Get rid of negative coordinates
draw_bmp: use multiple bounding boxes Seems to make it about up to 20% faster in some cases. Slightly slower in some others.
2012-12-25 16:27:22 +00:00
if (!mp_rect_intersection(rc, &img_rect))
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
return false;
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
int xstep, ystep;
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
get_swscale_alignment(img, &xstep, &ystep);
align_bbox(xstep, ystep, rc);
draw_bmp: use multiple bounding boxes Seems to make it about up to 20% faster in some cases. Slightly slower in some others.
2012-12-25 16:27:22 +00:00
return mp_rect_intersection(rc, &img_rect);
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
}
draw_bmp: better way to find 444 format Even though #ifdef ACCURATE is removed, the result should be about the same. The fallback is only used by packed YUV formats (YUYV, NV12), and doing 16 bit for them instead of 8 bit is not useful. A side effect is that Y8 (gray) is not converted drawing subs, and for alpha formats, the alpha plane is not removed. This means the number of planes after upsampling can be 1-4 (1: gray, 2: gray+alpha, 3: planar, 4: planar+alpha). The code has to be adjusted accordingly to work on the color planes only. Also remove the workaround for the chroma shift 31 hack.
2012-12-25 13:54:42 +00:00
// Try to find best/closest YUV 444 format (or similar) for imgfmt
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
static void get_closest_y444_format(int imgfmt, int *out_format, int *out_bits)
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
{
draw_bmp: better way to find 444 format Even though #ifdef ACCURATE is removed, the result should be about the same. The fallback is only used by packed YUV formats (YUYV, NV12), and doing 16 bit for them instead of 8 bit is not useful. A side effect is that Y8 (gray) is not converted drawing subs, and for alpha formats, the alpha plane is not removed. This means the number of planes after upsampling can be 1-4 (1: gray, 2: gray+alpha, 3: planar, 4: planar+alpha). The code has to be adjusted accordingly to work on the color planes only. Also remove the workaround for the chroma shift 31 hack.
2012-12-25 13:54:42 +00:00
struct mp_imgfmt_desc desc = mp_imgfmt_get_desc(imgfmt);
sub: find GBRP format automatically when rendering to RGB This removes the need to define IMGFMT_GBRAP, which fixes compilation with the current Libav release. This also makes it automatically pick up a GBRP format with the same bit width. (Unfortunately, it seems libswscale does not support conversion to AV_PIX_FMT_GBRAP16, so our code falls back to 8 bit, removing precision for video covered by subtitles in cases this code is used.) Also, when the source video is e.g. 10 bit YUV, upsample to 16 bit. Whether this is good or bad, it fixes behavior with alpha. Although I'm not sure if the alpha range is really correct ([0,2^16-1] vs. [0,255*256]). Keep in mind that libswscale doesn't even agree with the way we do it.
2015-12-24 15:42:21 +00:00
int planes = desc.flags & MP_IMGFLAG_ALPHA ? 4 : 3;
int bits = desc.component_bits > 8 ? 16 : 8;
draw_bmp: better way to find 444 format Even though #ifdef ACCURATE is removed, the result should be about the same. The fallback is only used by packed YUV formats (YUYV, NV12), and doing 16 bit for them instead of 8 bit is not useful. A side effect is that Y8 (gray) is not converted drawing subs, and for alpha formats, the alpha plane is not removed. This means the number of planes after upsampling can be 1-4 (1: gray, 2: gray+alpha, 3: planar, 4: planar+alpha). The code has to be adjusted accordingly to work on the color planes only. Also remove the workaround for the chroma shift 31 hack.
2012-12-25 13:54:42 +00:00
if (desc.flags & MP_IMGFLAG_RGB) {
sub: find GBRP format automatically when rendering to RGB This removes the need to define IMGFMT_GBRAP, which fixes compilation with the current Libav release. This also makes it automatically pick up a GBRP format with the same bit width. (Unfortunately, it seems libswscale does not support conversion to AV_PIX_FMT_GBRAP16, so our code falls back to 8 bit, removing precision for video covered by subtitles in cases this code is used.) Also, when the source video is e.g. 10 bit YUV, upsample to 16 bit. Whether this is good or bad, it fixes behavior with alpha. Although I'm not sure if the alpha range is really correct ([0,2^16-1] vs. [0,255*256]). Keep in mind that libswscale doesn't even agree with the way we do it.
2015-12-24 15:42:21 +00:00
*out_format = mp_imgfmt_find(0, 0, planes, bits, MP_IMGFLAG_RGB_P);
if (!mp_sws_supported_format(*out_format))
*out_format = mp_imgfmt_find(0, 0, planes, 8, MP_IMGFLAG_RGB_P);
draw_bmp: better way to find 444 format Even though #ifdef ACCURATE is removed, the result should be about the same. The fallback is only used by packed YUV formats (YUYV, NV12), and doing 16 bit for them instead of 8 bit is not useful. A side effect is that Y8 (gray) is not converted drawing subs, and for alpha formats, the alpha plane is not removed. This means the number of planes after upsampling can be 1-4 (1: gray, 2: gray+alpha, 3: planar, 4: planar+alpha). The code has to be adjusted accordingly to work on the color planes only. Also remove the workaround for the chroma shift 31 hack.
2012-12-25 13:54:42 +00:00
} else if (desc.flags & MP_IMGFLAG_YUV_P) {
sub: find GBRP format automatically when rendering to RGB This removes the need to define IMGFMT_GBRAP, which fixes compilation with the current Libav release. This also makes it automatically pick up a GBRP format with the same bit width. (Unfortunately, it seems libswscale does not support conversion to AV_PIX_FMT_GBRAP16, so our code falls back to 8 bit, removing precision for video covered by subtitles in cases this code is used.) Also, when the source video is e.g. 10 bit YUV, upsample to 16 bit. Whether this is good or bad, it fixes behavior with alpha. Although I'm not sure if the alpha range is really correct ([0,2^16-1] vs. [0,255*256]). Keep in mind that libswscale doesn't even agree with the way we do it.
2015-12-24 15:42:21 +00:00
*out_format = mp_imgfmt_find(0, 0, planes, bits, MP_IMGFLAG_YUV_P);
} else {
*out_format = 0;
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
}
sub: find GBRP format automatically when rendering to RGB This removes the need to define IMGFMT_GBRAP, which fixes compilation with the current Libav release. This also makes it automatically pick up a GBRP format with the same bit width. (Unfortunately, it seems libswscale does not support conversion to AV_PIX_FMT_GBRAP16, so our code falls back to 8 bit, removing precision for video covered by subtitles in cases this code is used.) Also, when the source video is e.g. 10 bit YUV, upsample to 16 bit. Whether this is good or bad, it fixes behavior with alpha. Although I'm not sure if the alpha range is really correct ([0,2^16-1] vs. [0,255*256]). Keep in mind that libswscale doesn't even agree with the way we do it.
2015-12-24 15:42:21 +00:00
if (!mp_sws_supported_format(*out_format))
*out_format = IMGFMT_444P; // generic fallback
*out_bits = mp_imgfmt_get_desc(*out_format).component_bits;
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
}
draw_bmp: don't try to call swscale if image format not supported If that happens, we silently fail.
2012-10-19 17:11:58 +00:00
draw_bmp: always allocate cache Allocate it even if it's needed. The actually done work is almost the same, except that the code is a bit simpler. May need more memory at once for RGB subs that use more than one part, which is rare.
2012-12-25 14:11:07 +00:00
static struct part *get_cache(struct mp_draw_sub_cache *cache,
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
struct sub_bitmaps *sbs, struct mp_image *format)
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
{
sub: add cache to mp_draw_sub_bitmaps() This caches scaled RGBA sub-bitmaps.
2012-10-19 15:49:49 +00:00
struct part *part = NULL;
bool use_cache = sbs->format == SUBBITMAP_RGBA;
draw_bmp: always allocate cache Allocate it even if it's needed. The actually done work is almost the same, except that the code is a bit simpler. May need more memory at once for RGB subs that use more than one part, which is rare.
2012-12-25 14:11:07 +00:00
if (use_cache) {
part = cache->parts[sbs->render_index];
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
if (part) {
osd: simplify an aspect of change detection handling There was a somewhat obscure optimization in the OSD and subtitle rendering path: if only the position of the sub-images changed, and not the actual image data, uploading of the image data could be skipped. In theory, this could speed up things like scrolling subtitles. But it turns out that even in the rare cases subtitles have such scrolls or axis-aligned movement, modern libass rarely signals this kind of change. Possibly this is because of sub-pixel handling and such, which break this. As such, it's a worthless optimization and just introduces additional complexity and subtle bugs (especially in cases libass does the opposite: incorrectly signaling a position change only, which happened before). Remove this optimization, and rename bitmap_pos_id to change_id.
2015-03-18 11:33:14 +00:00
if (part->change_id != sbs->change_id
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
|| part->imgfmt != format->imgfmt
video: make mp_image use mp_image_params directly Minor cleanup, so that we can stuff more information into mp_image_params later.
2014-04-20 19:27:45 +00:00
|| part->colorspace != format->params.colorspace
|| part->levels != format->params.colorlevels)
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
{
talloc_free(part);
part = NULL;
}
sub: add cache to mp_draw_sub_bitmaps() This caches scaled RGBA sub-bitmaps.
2012-10-19 15:49:49 +00:00
}
if (!part) {
draw_bmp: always allocate cache Allocate it even if it's needed. The actually done work is almost the same, except that the code is a bit simpler. May need more memory at once for RGB subs that use more than one part, which is rare.
2012-12-25 14:11:07 +00:00
part = talloc(cache, struct part);
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
*part = (struct part) {
osd: simplify an aspect of change detection handling There was a somewhat obscure optimization in the OSD and subtitle rendering path: if only the position of the sub-images changed, and not the actual image data, uploading of the image data could be skipped. In theory, this could speed up things like scrolling subtitles. But it turns out that even in the rare cases subtitles have such scrolls or axis-aligned movement, modern libass rarely signals this kind of change. Possibly this is because of sub-pixel handling and such, which break this. As such, it's a worthless optimization and just introduces additional complexity and subtle bugs (especially in cases libass does the opposite: incorrectly signaling a position change only, which happened before). Remove this optimization, and rename bitmap_pos_id to change_id.
2015-03-18 11:33:14 +00:00
.change_id = sbs->change_id,
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
.num_imgs = sbs->num_parts,
.imgfmt = format->imgfmt,
video: make mp_image use mp_image_params directly Minor cleanup, so that we can stuff more information into mp_image_params later.
2014-04-20 19:27:45 +00:00
.levels = format->params.colorlevels,
.colorspace = format->params.colorspace,
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
};
sub: add cache to mp_draw_sub_bitmaps() This caches scaled RGBA sub-bitmaps.
2012-10-19 15:49:49 +00:00
part->imgs = talloc_zero_array(part, struct sub_cache,
part->num_imgs);
}
assert(part->num_imgs == sbs->num_parts);
draw_bmp: always allocate cache Allocate it even if it's needed. The actually done work is almost the same, except that the code is a bit simpler. May need more memory at once for RGB subs that use more than one part, which is rare.
2012-12-25 14:11:07 +00:00
cache->parts[sbs->render_index] = part;
sub: add cache to mp_draw_sub_bitmaps() This caches scaled RGBA sub-bitmaps.
2012-10-19 15:49:49 +00:00
}
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
return part;
}
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
// Return area of intersection between target and sub-bitmap as cropped image
static bool get_sub_area(struct mp_rect bb, struct mp_image *temp,
struct sub_bitmap *sb, struct mp_image *out_area,
int *out_src_x, int *out_src_y)
{
// coordinates are relative to the bbox
struct mp_rect dst = {sb->x - bb.x0, sb->y - bb.y0};
dst.x1 = dst.x0 + sb->dw;
dst.y1 = dst.y0 + sb->dh;
draw_bmp: use multiple bounding boxes Seems to make it about up to 20% faster in some cases. Slightly slower in some others.
2012-12-25 16:27:22 +00:00
if (!mp_rect_intersection(&dst, &(struct mp_rect){0, 0, temp->w, temp->h}))
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
return false;
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
*out_src_x = (dst.x0 - sb->x) + bb.x0;
*out_src_y = (dst.y0 - sb->y) + bb.y0;
*out_area = *temp;
mp_image: add mp_image_crop() Actually stolen from draw_bmp.c.
2012-12-25 21:29:49 +00:00
mp_image_crop_rc(out_area, dst);
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
return true;
}
draw_bmp: refactor
2012-12-25 14:23:16 +00:00
// Convert the src image to imgfmt (which should be a 444 format)
static struct mp_image *chroma_up(struct mp_draw_sub_cache *cache, int imgfmt,
struct mp_image *src)
{
if (src->imgfmt == imgfmt)
return src;
draw_bmp: do not reallocate upsample temp image on each frame Doesn't seem to help too much...
2012-12-25 14:39:47 +00:00
if (!cache->upsample_img || cache->upsample_img->imgfmt != imgfmt ||
cache->upsample_img->w < src->w || cache->upsample_img->h < src->h)
{
talloc_free(cache->upsample_img);
cache->upsample_img = mp_image_alloc(imgfmt, src->w, src->h);
talloc_steal(cache, cache->upsample_img);
video: introduce failure path for image allocations Until now, failure to allocate image data resulted in a crash (i.e. abort() was called). This was intentional, because it's pretty silly to degrade playback, and in almost all situations, the OOM will probably kill you anyway. (And then there's the standard Linux overcommit behavior, which also will kill you at some point.) But I changed my opinion, so here we go. This change does not affect _all_ memory allocations, just image data. Now in most failure cases, the output will just be skipped. For video filters, this coincidentally means that failure is treated as EOF (because the playback core assumes EOF if nothing comes out of the video filter chain). In other situations, output might be in some way degraded, like skipping frames, not scaling OSD, and such. Functions whose return values changed semantics: mp_image_alloc mp_image_new_copy mp_image_new_ref mp_image_make_writeable mp_image_setrefp mp_image_to_av_frame_and_unref mp_image_from_av_frame mp_image_new_external_ref mp_image_new_custom_ref mp_image_pool_make_writeable mp_image_pool_get mp_image_pool_new_copy mp_vdpau_mixed_frame_create vf_alloc_out_image vf_make_out_image_writeable glGetWindowScreenshot
2014-06-17 20:43:43 +00:00
if (!cache->upsample_img)
return NULL;
draw_bmp: do not reallocate upsample temp image on each frame Doesn't seem to help too much...
2012-12-25 14:39:47 +00:00
}
cache->upsample_temp = *cache->upsample_img;
struct mp_image *temp = &cache->upsample_temp;
mp_image_set_size(temp, src->w, src->h);
draw_bmp: don't copy Y plane on up/down-sampling Image areas with subtitles are upsampled to 4:4:4 in order to render the subtitles (makes blending easier). Try not to copy the Y plane on upsampling. The libswscale API requires this, but this commit works it around by scaling the chroma planes separately as AV_PIX_FMT_GRAY8. The Y plane is not touched at all. This is done for 420p8 only, which is the most commonly needed case. For other formats, the old way is used. Seems to make ASS rendering faster about 15% in the setup I tested.
2012-12-25 15:27:20 +00:00
// The temp image is always YUV, but src not necessarily.
// Reduce amount of conversions in YUV case (upsampling/shifting only)
mp_image: remove redundant flags field Because gcc (and clang) is a goddamn PITA and unnecessarily warns if the universal initializer for structs is used (like mp_image x = {}) and the first member of the struct is also a struct, move the w/h fields to the top.
2015-04-10 19:06:18 +00:00
if (src->fmt.flags & MP_IMGFLAG_YUV) {
video: make mp_image use mp_image_params directly Minor cleanup, so that we can stuff more information into mp_image_params later.
2014-04-20 19:27:45 +00:00
temp->params.colorspace = src->params.colorspace;
temp->params.colorlevels = src->params.colorlevels;
draw_bmp: refactor
2012-12-25 14:23:16 +00:00
}
draw_bmp: don't copy Y plane on up/down-sampling Image areas with subtitles are upsampled to 4:4:4 in order to render the subtitles (makes blending easier). Try not to copy the Y plane on upsampling. The libswscale API requires this, but this commit works it around by scaling the chroma planes separately as AV_PIX_FMT_GRAY8. The Y plane is not touched at all. This is done for 420p8 only, which is the most commonly needed case. For other formats, the old way is used. Seems to make ASS rendering faster about 15% in the setup I tested.
2012-12-25 15:27:20 +00:00
if (src->imgfmt == IMGFMT_420P) {
assert(imgfmt == IMGFMT_444P);
// Faster upsampling: keep Y plane, upsample chroma planes only
// The whole point is not having swscale copy the Y plane
struct mp_image t_dst = *temp;
mp_image_setfmt(&t_dst, IMGFMT_Y8);
mp_image: get rid of chroma_width/height fields They are redundant. They were used by draw_bmp.c only, and only in a special code path that 1. used fixed image formats, and 2. had image sized perfectly aligned to chroma boundaries (so computing the chroma width/height is trivial).
2015-04-09 19:11:20 +00:00
mp_image_set_size(&t_dst, temp->w, temp->h);
draw_bmp: don't copy Y plane on up/down-sampling Image areas with subtitles are upsampled to 4:4:4 in order to render the subtitles (makes blending easier). Try not to copy the Y plane on upsampling. The libswscale API requires this, but this commit works it around by scaling the chroma planes separately as AV_PIX_FMT_GRAY8. The Y plane is not touched at all. This is done for 420p8 only, which is the most commonly needed case. For other formats, the old way is used. Seems to make ASS rendering faster about 15% in the setup I tested.
2012-12-25 15:27:20 +00:00
struct mp_image t_src = t_dst;
mp_image: get rid of chroma_width/height fields They are redundant. They were used by draw_bmp.c only, and only in a special code path that 1. used fixed image formats, and 2. had image sized perfectly aligned to chroma boundaries (so computing the chroma width/height is trivial).
2015-04-09 19:11:20 +00:00
mp_image_set_size(&t_src, src->w >> 1, src->h >> 1);
draw_bmp: don't copy Y plane on up/down-sampling Image areas with subtitles are upsampled to 4:4:4 in order to render the subtitles (makes blending easier). Try not to copy the Y plane on upsampling. The libswscale API requires this, but this commit works it around by scaling the chroma planes separately as AV_PIX_FMT_GRAY8. The Y plane is not touched at all. This is done for 420p8 only, which is the most commonly needed case. For other formats, the old way is used. Seems to make ASS rendering faster about 15% in the setup I tested.
2012-12-25 15:27:20 +00:00
for (int c = 0; c < 2; c++) {
t_dst.planes[0] = temp->planes[1 + c];
t_dst.stride[0] = temp->stride[1 + c];
t_src.planes[0] = src->planes[1 + c];
t_src.stride[0] = src->stride[1 + c];
mp_image_swscale(&t_dst, &t_src, SWS_POINT);
}
temp->planes[0] = src->planes[0];
temp->stride[0] = src->stride[0];
} else {
mp_image_swscale(temp, src, SWS_POINT);
}
draw_bmp: refactor
2012-12-25 14:23:16 +00:00
return temp;
}
draw_bmp: don't copy Y plane on up/down-sampling Image areas with subtitles are upsampled to 4:4:4 in order to render the subtitles (makes blending easier). Try not to copy the Y plane on upsampling. The libswscale API requires this, but this commit works it around by scaling the chroma planes separately as AV_PIX_FMT_GRAY8. The Y plane is not touched at all. This is done for 420p8 only, which is the most commonly needed case. For other formats, the old way is used. Seems to make ASS rendering faster about 15% in the setup I tested.
2012-12-25 15:27:20 +00:00
// Undo chroma_up() (copy temp to old_src if needed)
draw_bmp: refactor
2012-12-25 14:23:16 +00:00
static void chroma_down(struct mp_image *old_src, struct mp_image *temp)
{
assert(old_src->w == temp->w && old_src->h == temp->h);
if (temp != old_src) {
draw_bmp: don't copy Y plane on up/down-sampling Image areas with subtitles are upsampled to 4:4:4 in order to render the subtitles (makes blending easier). Try not to copy the Y plane on upsampling. The libswscale API requires this, but this commit works it around by scaling the chroma planes separately as AV_PIX_FMT_GRAY8. The Y plane is not touched at all. This is done for 420p8 only, which is the most commonly needed case. For other formats, the old way is used. Seems to make ASS rendering faster about 15% in the setup I tested.
2012-12-25 15:27:20 +00:00
if (old_src->imgfmt == IMGFMT_420P) {
// Downsampling, skipping the Y plane (see chroma_up())
assert(temp->imgfmt == IMGFMT_444P);
assert(temp->planes[0] == old_src->planes[0]);
struct mp_image t_dst = *temp;
mp_image_setfmt(&t_dst, IMGFMT_Y8);
mp_image: get rid of chroma_width/height fields They are redundant. They were used by draw_bmp.c only, and only in a special code path that 1. used fixed image formats, and 2. had image sized perfectly aligned to chroma boundaries (so computing the chroma width/height is trivial).
2015-04-09 19:11:20 +00:00
mp_image_set_size(&t_dst, old_src->w >> 1, old_src->h >> 1);
draw_bmp: don't copy Y plane on up/down-sampling Image areas with subtitles are upsampled to 4:4:4 in order to render the subtitles (makes blending easier). Try not to copy the Y plane on upsampling. The libswscale API requires this, but this commit works it around by scaling the chroma planes separately as AV_PIX_FMT_GRAY8. The Y plane is not touched at all. This is done for 420p8 only, which is the most commonly needed case. For other formats, the old way is used. Seems to make ASS rendering faster about 15% in the setup I tested.
2012-12-25 15:27:20 +00:00
struct mp_image t_src = t_dst;
mp_image: get rid of chroma_width/height fields They are redundant. They were used by draw_bmp.c only, and only in a special code path that 1. used fixed image formats, and 2. had image sized perfectly aligned to chroma boundaries (so computing the chroma width/height is trivial).
2015-04-09 19:11:20 +00:00
mp_image_set_size(&t_src, temp->w, temp->h);
draw_bmp: don't copy Y plane on up/down-sampling Image areas with subtitles are upsampled to 4:4:4 in order to render the subtitles (makes blending easier). Try not to copy the Y plane on upsampling. The libswscale API requires this, but this commit works it around by scaling the chroma planes separately as AV_PIX_FMT_GRAY8. The Y plane is not touched at all. This is done for 420p8 only, which is the most commonly needed case. For other formats, the old way is used. Seems to make ASS rendering faster about 15% in the setup I tested.
2012-12-25 15:27:20 +00:00
for (int c = 0; c < 2; c++) {
t_dst.planes[0] = old_src->planes[1 + c];
t_dst.stride[0] = old_src->stride[1 + c];
t_src.planes[0] = temp->planes[1 + c];
t_src.stride[0] = temp->stride[1 + c];
mp_image_swscale(&t_dst, &t_src, SWS_AREA);
}
} else {
mp_image_swscale(old_src, temp, SWS_AREA); // chroma down
}
draw_bmp: refactor
2012-12-25 14:23:16 +00:00
}
}
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
// cache: if not NULL, the function will set *cache to a talloc-allocated cache
// containing scaled versions of sbs contents - free the cache with
// talloc_free()
void mp_draw_sub_bitmaps(struct mp_draw_sub_cache **cache, struct mp_image *dst,
screenshot, draw_bmp: use colorspace passed with mp_image Remove the explicit struct mp_csp_details parameters from all related functions, and use mp_image.colorspace/levels instead.
2012-10-27 16:06:09 +00:00
struct sub_bitmaps *sbs)
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
{
assert(mp_draw_sub_formats[sbs->format]);
if (!mp_sws_supported_format(dst->imgfmt))
return;
draw_bmp: always allocate cache Allocate it even if it's needed. The actually done work is almost the same, except that the code is a bit simpler. May need more memory at once for RGB subs that use more than one part, which is rare.
2012-12-25 14:11:07 +00:00
struct mp_draw_sub_cache *cache_ = cache ? *cache : NULL;
if (!cache_)
cache_ = talloc_zero(NULL, struct mp_draw_sub_cache);
draw_bmp: cosmetics, refactor Mostly pedantic bikeshedding issues. Move some code around, so that the sub_bitmap_to_mp_images() function can be split into two parts. This is better than having a big function with many input and outputs, of which only half are used in each code path. Also, try to make code simpler by using a mp_rect type.
2012-10-25 17:37:43 +00:00
int format, bits;
get_closest_y444_format(dst->imgfmt, &format, &bits);
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
draw_bmp: use multiple bounding boxes Seems to make it about up to 20% faster in some cases. Slightly slower in some others.
2012-12-25 16:27:22 +00:00
struct mp_rect rc_list[MP_SUB_BB_LIST_MAX];
int num_rc = mp_get_sub_bb_list(sbs, rc_list, MP_SUB_BB_LIST_MAX);
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
draw_bmp: use multiple bounding boxes Seems to make it about up to 20% faster in some cases. Slightly slower in some others.
2012-12-25 16:27:22 +00:00
for (int r = 0; r < num_rc; r++) {
struct mp_rect bb = rc_list[r];
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
draw_bmp: use multiple bounding boxes Seems to make it about up to 20% faster in some cases. Slightly slower in some others.
2012-12-25 16:27:22 +00:00
if (!align_bbox_for_swscale(dst, &bb))
return;
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
draw_bmp: use multiple bounding boxes Seems to make it about up to 20% faster in some cases. Slightly slower in some others.
2012-12-25 16:27:22 +00:00
struct mp_image dst_region = *dst;
mp_image_crop_rc(&dst_region, bb);
struct mp_image *temp = chroma_up(cache_, format, &dst_region);
video: introduce failure path for image allocations Until now, failure to allocate image data resulted in a crash (i.e. abort() was called). This was intentional, because it's pretty silly to degrade playback, and in almost all situations, the OOM will probably kill you anyway. (And then there's the standard Linux overcommit behavior, which also will kill you at some point.) But I changed my opinion, so here we go. This change does not affect _all_ memory allocations, just image data. Now in most failure cases, the output will just be skipped. For video filters, this coincidentally means that failure is treated as EOF (because the playback core assumes EOF if nothing comes out of the video filter chain). In other situations, output might be in some way degraded, like skipping frames, not scaling OSD, and such. Functions whose return values changed semantics: mp_image_alloc mp_image_new_copy mp_image_new_ref mp_image_make_writeable mp_image_setrefp mp_image_to_av_frame_and_unref mp_image_from_av_frame mp_image_new_external_ref mp_image_new_custom_ref mp_image_pool_make_writeable mp_image_pool_get mp_image_pool_new_copy mp_vdpau_mixed_frame_create vf_alloc_out_image vf_make_out_image_writeable glGetWindowScreenshot
2014-06-17 20:43:43 +00:00
if (!temp)
continue; // on OOM, skip region
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
draw_bmp: use multiple bounding boxes Seems to make it about up to 20% faster in some cases. Slightly slower in some others.
2012-12-25 16:27:22 +00:00
if (sbs->format == SUBBITMAP_RGBA) {
draw_rgba(cache_, bb, temp, bits, sbs);
} else if (sbs->format == SUBBITMAP_LIBASS) {
draw_ass(cache_, bb, temp, bits, sbs);
}
chroma_down(&dst_region, temp);
}
draw_bmp: always allocate cache Allocate it even if it's needed. The actually done work is almost the same, except that the code is a bit simpler. May need more memory at once for RGB subs that use more than one part, which is rare.
2012-12-25 14:11:07 +00:00
if (cache) {
*cache = cache_;
} else {
talloc_free(cache_);
}
sub: add helper to draw sub-bitmaps into an image Merged by wm4 from commits 93978f17b76d..13211ef5fc20. Changed copyright header in draw_bmp.c to "mpv", and removed the one in draw_bmp.h.
2012-10-24 17:11:42 +00:00
}
// vim: ts=4 sw=4 et tw=80