FFmpeg
alphablend.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2015 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "swscale_internal.h"
22 
23 int ff_sws_alphablendaway(SwsInternal *c, const uint8_t *const src[],
24  const int srcStride[], int srcSliceY, int srcSliceH,
25  uint8_t *const dst[], const int dstStride[])
26 {
27  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.src_format);
28  const int lum_w = c->opts.src_w;
29  const int lum_h = c->opts.src_h;
30  int nb_components = desc->nb_components;
31  int plane, x, ysrc;
32  int plane_count = isGray(c->opts.src_format) ? 1 : 3;
33  int sixteen_bits = desc->comp[0].depth >= 9;
34  unsigned off = 1<<(desc->comp[0].depth - 1);
35  unsigned shift = desc->comp[0].depth;
36  unsigned max = (1<<shift) - 1;
37  int target_table[2][3];
38 
39  for (plane = 0; plane < plane_count; plane++) {
40  int a = 0, b = 0;
41  if (c->opts.alpha_blend == SWS_ALPHA_BLEND_CHECKERBOARD) {
42  a = (1<<(desc->comp[0].depth - 1))/2;
43  b = 3*(1<<(desc->comp[0].depth-1))/2;
44  }
45  target_table[0][plane] = plane && !(desc->flags & AV_PIX_FMT_FLAG_RGB) ? 1<<(desc->comp[0].depth - 1) : a;
46  target_table[1][plane] = plane && !(desc->flags & AV_PIX_FMT_FLAG_RGB) ? 1<<(desc->comp[0].depth - 1) : b;
47  }
48 
49  av_assert0(plane_count == nb_components - 1);
50  if (desc->flags & AV_PIX_FMT_FLAG_PLANAR) {
51  for (plane = 0; plane < plane_count; plane++) {
52  int w = plane ? c->chrSrcW : c->opts.src_w;
53  int x_subsample = plane ? desc->log2_chroma_w: 0;
54  int y_subsample = plane ? desc->log2_chroma_h: 0;
55  for (ysrc = 0; ysrc < AV_CEIL_RSHIFT(srcSliceH, y_subsample); ysrc++) {
56  int y = ysrc + (srcSliceY >> y_subsample);
57  int subsample_row = y_subsample && (y << y_subsample) + 1 < lum_h;
58  if (x_subsample || subsample_row) {
59  int alpha;
60  unsigned u;
61  if (sixteen_bits) {
62  ptrdiff_t alpha_step = srcStride[plane_count] >> 1;
63  const uint16_t *s = (const uint16_t *)(src[plane ] + srcStride[plane ] * ysrc);
64  const uint16_t *a = (const uint16_t *)(src[plane_count] + (srcStride[plane_count] * ysrc << y_subsample));
65  uint16_t *d = ( uint16_t *)(dst[plane ] + dstStride[plane ] * y);
66  if ((!isBE(c->opts.src_format)) == !HAVE_BIGENDIAN) {
67  for (x = 0; x < w; x++) {
68  const int xnext = FFMIN(2*x + 1, lum_w - 1);
69  if (subsample_row) {
70  alpha = (a[2*x] + a[xnext] + 2 +
71  a[2*x + alpha_step] + a[xnext + alpha_step]) >> 2;
72  } else
73  alpha = (a[2*x] + a[xnext]) >> 1;
74  u = s[x]*alpha + target_table[((x^y)>>5)&1][plane]*(max-alpha) + off;
75  d[x] = av_clip((u + (u >> shift)) >> shift, 0, max);
76  }
77  } else {
78  for (x = 0; x < w; x++) {
79  const int xnext = FFMIN(2*x + 1, lum_w - 1);
80  if (subsample_row) {
81  alpha = (av_bswap16(a[2*x]) + av_bswap16(a[xnext]) + 2 +
82  av_bswap16(a[2*x + alpha_step]) + av_bswap16(a[xnext + alpha_step])) >> 2;
83  } else
84  alpha = (av_bswap16(a[2*x]) + av_bswap16(a[xnext])) >> 1;
85  u = av_bswap16(s[x])*alpha + target_table[((x^y)>>5)&1][plane]*(max-alpha) + off;
86  d[x] = av_clip((u + (u >> shift)) >> shift, 0, max);
87  }
88  }
89  } else {
90  ptrdiff_t alpha_step = srcStride[plane_count];
91  const uint8_t *s = src[plane ] + srcStride[plane] * ysrc;
92  const uint8_t *a = src[plane_count] + (srcStride[plane_count] * ysrc << y_subsample);
93  uint8_t *d = dst[plane ] + dstStride[plane] * y;
94  for (x = 0; x < w; x++) {
95  const int xnext = FFMIN(2*x + 1, lum_w - 1);
96  if (subsample_row) {
97  alpha = (a[2*x] + a[xnext] + 2 +
98  a[2*x + alpha_step] + a[xnext + alpha_step]) >> 2;
99  } else
100  alpha = (a[2*x] + a[xnext]) >> 1;
101  u = s[x]*alpha + target_table[((x^y)>>5)&1][plane]*(255-alpha) + 128;
102  d[x] = (257*u) >> 16;
103  }
104  }
105  } else {
106  if (sixteen_bits) {
107  const uint16_t *s = (const uint16_t *)(src[plane ] + srcStride[plane ] * ysrc);
108  const uint16_t *a = (const uint16_t *)(src[plane_count] + srcStride[plane_count] * ysrc);
109  uint16_t *d = ( uint16_t *)(dst[plane ] + dstStride[plane ] * y);
110  if ((!isBE(c->opts.src_format)) == !HAVE_BIGENDIAN) {
111  for (x = 0; x < w; x++) {
112  unsigned u = s[x]*a[x] + target_table[((x^y)>>5)&1][plane]*(max-a[x]) + off;
113  d[x] = av_clip((u + (u >> shift)) >> shift, 0, max);
114  }
115  } else {
116  for (x = 0; x < w; x++) {
117  unsigned aswap =av_bswap16(a[x]);
118  unsigned u = av_bswap16(s[x])*aswap + target_table[((x^y)>>5)&1][plane]*(max-aswap) + off;
119  d[x] = av_clip((u + (u >> shift)) >> shift, 0, max);
120  }
121  }
122  } else {
123  const uint8_t *s = src[plane ] + srcStride[plane] * ysrc;
124  const uint8_t *a = src[plane_count] + srcStride[plane_count] * ysrc;
125  uint8_t *d = dst[plane ] + dstStride[plane] * y;
126  for (x = 0; x < w; x++) {
127  unsigned u = s[x]*a[x] + target_table[((x^y)>>5)&1][plane]*(255-a[x]) + 128;
128  d[x] = (257*u) >> 16;
129  }
130  }
131  }
132  }
133  }
134  } else {
135  int alpha_pos = desc->comp[plane_count].offset;
136  int w = c->opts.src_w;
137  for (ysrc = 0; ysrc < srcSliceH; ysrc++) {
138  int y = ysrc + srcSliceY;
139  if (sixteen_bits) {
140  const uint16_t *s = (const uint16_t *)(src[0] + srcStride[0] * ysrc + 2*!alpha_pos);
141  const uint16_t *a = (const uint16_t *)(src[0] + srcStride[0] * ysrc + alpha_pos);
142  uint16_t *d = ( uint16_t *)(dst[0] + dstStride[0] * y);
143  if ((!isBE(c->opts.src_format)) == !HAVE_BIGENDIAN) {
144  for (x = 0; x < w; x++) {
145  for (plane = 0; plane < plane_count; plane++) {
146  int x_index = (plane_count + 1) * x;
147  unsigned u = s[x_index + plane]*a[x_index] + target_table[((x^y)>>5)&1][plane]*(max-a[x_index]) + off;
148  d[plane_count*x + plane] = av_clip((u + (u >> shift)) >> shift, 0, max);
149  }
150  }
151  } else {
152  for (x = 0; x < w; x++) {
153  for (plane = 0; plane < plane_count; plane++) {
154  int x_index = (plane_count + 1) * x;
155  unsigned aswap =av_bswap16(a[x_index]);
156  unsigned u = av_bswap16(s[x_index + plane])*aswap + target_table[((x^y)>>5)&1][plane]*(max-aswap) + off;
157  d[plane_count*x + plane] = av_clip((u + (u >> shift)) >> shift, 0, max);
158  }
159  }
160  }
161  } else {
162  const uint8_t *s = src[0] + srcStride[0] * ysrc + !alpha_pos;
163  const uint8_t *a = src[0] + srcStride[0] * ysrc + alpha_pos;
164  uint8_t *d = dst[0] + dstStride[0] * y;
165  for (x = 0; x < w; x++) {
166  for (plane = 0; plane < plane_count; plane++) {
167  int x_index = (plane_count + 1) * x;
168  unsigned u = s[x_index + plane]*a[x_index] + target_table[((x^y)>>5)&1][plane]*(255-a[x_index]) + 128;
169  d[plane_count*x + plane] = (257*u) >> 16;
170  }
171  }
172  }
173  }
174  }
175 
176  return 0;
177 }
av_clip
#define av_clip
Definition: common.h:100
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3441
SWS_ALPHA_BLEND_CHECKERBOARD
@ SWS_ALPHA_BLEND_CHECKERBOARD
Definition: swscale.h:90
w
uint8_t w
Definition: llviddspenc.c:38
u
#define u(width, name, range_min, range_max)
Definition: cbs_apv.c:83
isGray
static av_always_inline int isGray(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:787
b
#define b
Definition: input.c:42
max
#define max(a, b)
Definition: cuda_runtime.h:33
ff_sws_alphablendaway
int ff_sws_alphablendaway(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: alphablend.c:23
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
isBE
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:748
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
shift
static int shift(int a, int b)
Definition: bonk.c:261
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
swscale_internal.h
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
SwsInternal
Definition: swscale_internal.h:317
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:132
desc
const char * desc
Definition: libsvtav1.c:79
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
av_bswap16
#define av_bswap16
Definition: bswap.h:28
src
#define src
Definition: vp8dsp.c:248
Generated on Sat Aug 2 2025 19:23:21 for FFmpeg by   doxygen 1.8.17