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(SwsContext *c, const uint8_t *src[],
24  int srcStride[], int srcSliceY, int srcSliceH,
25  uint8_t *dst[], int dstStride[])
26 {
27  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->srcFormat);
28  int nb_components = desc->nb_components;
29  int plane, x, ysrc;
30  int plane_count = isGray(c->srcFormat) ? 1 : 3;
31  int sixteen_bits = desc->comp[0].depth >= 9;
32  unsigned off = 1<<(desc->comp[0].depth - 1);
33  unsigned shift = desc->comp[0].depth;
34  unsigned max = (1<<shift) - 1;
35  int target_table[2][3];
36 
37  for (plane = 0; plane < plane_count; plane++) {
38  int a = 0, b = 0;
39  if (c->alphablend == SWS_ALPHA_BLEND_CHECKERBOARD) {
40  a = (1<<(desc->comp[0].depth - 1))/2;
41  b = 3*(1<<(desc->comp[0].depth-1))/2;
42  }
43  target_table[0][plane] = plane && !(desc->flags & AV_PIX_FMT_FLAG_RGB) ? 1<<(desc->comp[0].depth - 1) : a;
44  target_table[1][plane] = plane && !(desc->flags & AV_PIX_FMT_FLAG_RGB) ? 1<<(desc->comp[0].depth - 1) : b;
45  }
46 
47  av_assert0(plane_count == nb_components - 1);
48  if (desc->flags & AV_PIX_FMT_FLAG_PLANAR) {
49  for (plane = 0; plane < plane_count; plane++) {
50  int w = plane ? c->chrSrcW : c->srcW;
51  int x_subsample = plane ? desc->log2_chroma_w: 0;
52  int y_subsample = plane ? desc->log2_chroma_h: 0;
53  for (ysrc = 0; ysrc < AV_CEIL_RSHIFT(srcSliceH, y_subsample); ysrc++) {
54  int y = ysrc + (srcSliceY >> y_subsample);
55  if (x_subsample || y_subsample) {
56  int alpha;
57  unsigned u;
58  if (sixteen_bits) {
59  ptrdiff_t alpha_step = srcStride[plane_count] >> 1;
60  const uint16_t *s = (const uint16_t *)(src[plane ] + srcStride[plane ] * ysrc);
61  const uint16_t *a = (const uint16_t *)(src[plane_count] + (srcStride[plane_count] * ysrc << y_subsample));
62  uint16_t *d = ( uint16_t *)(dst[plane ] + dstStride[plane ] * y);
63  if ((!isBE(c->srcFormat)) == !HAVE_BIGENDIAN) {
64  for (x = 0; x < w; x++) {
65  if (y_subsample) {
66  alpha = (a[2*x] + a[2*x + 1] + 2 +
67  a[2*x + alpha_step] + a[2*x + alpha_step + 1]) >> 2;
68  } else
69  alpha = (a[2*x] + a[2*x + 1]) >> 1;
70  u = s[x]*alpha + target_table[((x^y)>>5)&1][plane]*(max-alpha) + off;
71  d[x] = av_clip((u + (u >> shift)) >> shift, 0, max);
72  }
73  } else {
74  for (x = 0; x < w; x++) {
75  if (y_subsample) {
76  alpha = (av_bswap16(a[2*x]) + av_bswap16(a[2*x + 1]) + 2 +
77  av_bswap16(a[2*x + alpha_step]) + av_bswap16(a[2*x + alpha_step + 1])) >> 2;
78  } else
79  alpha = (av_bswap16(a[2*x]) + av_bswap16(a[2*x + 1])) >> 1;
80  u = av_bswap16(s[x])*alpha + target_table[((x^y)>>5)&1][plane]*(max-alpha) + off;
81  d[x] = av_clip((u + (u >> shift)) >> shift, 0, max);
82  }
83  }
84  } else {
85  ptrdiff_t alpha_step = srcStride[plane_count];
86  const uint8_t *s = src[plane ] + srcStride[plane] * ysrc;
87  const uint8_t *a = src[plane_count] + (srcStride[plane_count] * ysrc << y_subsample);
88  uint8_t *d = dst[plane ] + dstStride[plane] * y;
89  for (x = 0; x < w; x++) {
90  if (y_subsample) {
91  alpha = (a[2*x] + a[2*x + 1] + 2 +
92  a[2*x + alpha_step] + a[2*x + alpha_step + 1]) >> 2;
93  } else
94  alpha = (a[2*x] + a[2*x + 1]) >> 1;
95  u = s[x]*alpha + target_table[((x^y)>>5)&1][plane]*(255-alpha) + 128;
96  d[x] = (257*u) >> 16;
97  }
98  }
99  } else {
100  if (sixteen_bits) {
101  const uint16_t *s = (const uint16_t *)(src[plane ] + srcStride[plane ] * ysrc);
102  const uint16_t *a = (const uint16_t *)(src[plane_count] + srcStride[plane_count] * ysrc);
103  uint16_t *d = ( uint16_t *)(dst[plane ] + dstStride[plane ] * y);
104  if ((!isBE(c->srcFormat)) == !HAVE_BIGENDIAN) {
105  for (x = 0; x < w; x++) {
106  unsigned u = s[x]*a[x] + target_table[((x^y)>>5)&1][plane]*(max-a[x]) + off;
107  d[x] = av_clip((u + (u >> shift)) >> shift, 0, max);
108  }
109  } else {
110  for (x = 0; x < w; x++) {
111  unsigned aswap =av_bswap16(a[x]);
112  unsigned u = av_bswap16(s[x])*aswap + target_table[((x^y)>>5)&1][plane]*(max-aswap) + off;
113  d[x] = av_clip((u + (u >> shift)) >> shift, 0, max);
114  }
115  }
116  } else {
117  const uint8_t *s = src[plane ] + srcStride[plane] * ysrc;
118  const uint8_t *a = src[plane_count] + srcStride[plane_count] * ysrc;
119  uint8_t *d = dst[plane ] + dstStride[plane] * y;
120  for (x = 0; x < w; x++) {
121  unsigned u = s[x]*a[x] + target_table[((x^y)>>5)&1][plane]*(255-a[x]) + 128;
122  d[x] = (257*u) >> 16;
123  }
124  }
125  }
126  }
127  }
128  } else {
129  int alpha_pos = desc->comp[plane_count].offset;
130  int w = c->srcW;
131  for (ysrc = 0; ysrc < srcSliceH; ysrc++) {
132  int y = ysrc + srcSliceY;
133  if (sixteen_bits) {
134  const uint16_t *s = (const uint16_t *)(src[0] + srcStride[0] * ysrc + 2*!alpha_pos);
135  const uint16_t *a = (const uint16_t *)(src[0] + srcStride[0] * ysrc + alpha_pos);
136  uint16_t *d = ( uint16_t *)(dst[0] + dstStride[0] * y);
137  if ((!isBE(c->srcFormat)) == !HAVE_BIGENDIAN) {
138  for (x = 0; x < w; x++) {
139  for (plane = 0; plane < plane_count; plane++) {
140  int x_index = (plane_count + 1) * x;
141  unsigned u = s[x_index + plane]*a[x_index] + target_table[((x^y)>>5)&1][plane]*(max-a[x_index]) + off;
142  d[plane_count*x + plane] = av_clip((u + (u >> shift)) >> shift, 0, max);
143  }
144  }
145  } else {
146  for (x = 0; x < w; x++) {
147  for (plane = 0; plane < plane_count; plane++) {
148  int x_index = (plane_count + 1) * x;
149  unsigned aswap =av_bswap16(a[x_index]);
150  unsigned u = av_bswap16(s[x_index + plane])*aswap + target_table[((x^y)>>5)&1][plane]*(max-aswap) + off;
151  d[plane_count*x + plane] = av_clip((u + (u >> shift)) >> shift, 0, max);
152  }
153  }
154  }
155  } else {
156  const uint8_t *s = src[0] + srcStride[0] * ysrc + !alpha_pos;
157  const uint8_t *a = src[0] + srcStride[0] * ysrc + alpha_pos;
158  uint8_t *d = dst[0] + dstStride[0] * y;
159  for (x = 0; x < w; x++) {
160  for (plane = 0; plane < plane_count; plane++) {
161  int x_index = (plane_count + 1) * x;
162  unsigned u = s[x_index + plane]*a[x_index] + target_table[((x^y)>>5)&1][plane]*(255-a[x_index]) + 128;
163  d[plane_count*x + plane] = (257*u) >> 16;
164  }
165  }
166  }
167  }
168  }
169 
170  return 0;
171 }
av_clip
#define av_clip
Definition: common.h:122
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
w
uint8_t w
Definition: llviddspenc.c:39
b
#define b
Definition: input.c:41
isGray
#define isGray(x)
Definition: swscale.c:40
max
#define max(a, b)
Definition: cuda_runtime.h:33
ff_sws_alphablendaway
int ff_sws_alphablendaway(SwsContext *c, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Definition: alphablend.c:23
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
src
#define src
Definition: vp8dsp.c:255
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:667
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:148
srcSliceH
return srcSliceH
Definition: yuv2rgb_template.c: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
av_bswap16
#define av_bswap16
Definition: bswap.h:31
swscale_internal.h
uint8_t
uint8_t
Definition: audio_convert.c:194
SWS_ALPHA_BLEND_CHECKERBOARD
@ SWS_ALPHA_BLEND_CHECKERBOARD
Definition: swscale_internal.h:79
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:144
shift
static int shift(int a, int b)
Definition: sonic.c:82
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:81
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
SwsContext
Definition: swscale_internal.h:283
Generated on Wed Aug 24 2022 21:34:52 for FFmpeg by   doxygen 1.8.17