avcodec/videotoolbox: fix kVTCouldNotFindVideoDecoderErr trying to decode HEVC on iOS
[ffmpeg.git] / libswscale / alphablend.c
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, y;
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 (y = srcSliceY >> y_subsample; y < AV_CEIL_RSHIFT(srcSliceH, y_subsample); y++) {
54                 if (x_subsample || y_subsample) {
55                     int alpha;
56                     unsigned u;
57                     if (sixteen_bits) {
58                         ptrdiff_t alpha_step = srcStride[plane_count] >> 1;
59                         const uint16_t *s = (const uint16_t *)(src[plane      ] +  srcStride[plane      ] * y);
60                         const uint16_t *a = (const uint16_t *)(src[plane_count] + (srcStride[plane_count] * y << y_subsample));
61                               uint16_t *d = (      uint16_t *)(dst[plane      ] +  dstStride[plane      ] * y);
62                         if ((!isBE(c->srcFormat)) == !HAVE_BIGENDIAN) {
63                             for (x = 0; x < w; x++) {
64                                 if (y_subsample) {
65                                     alpha = (a[2*x]              + a[2*x + 1] + 2 +
66                                              a[2*x + alpha_step] + a[2*x + alpha_step + 1]) >> 2;
67                                 } else
68                                     alpha = (a[2*x] + a[2*x + 1]) >> 1;
69                                 u = s[x]*alpha + target_table[((x^y)>>5)&1][plane]*(max-alpha) + off;
70                                 d[x] = av_clip((u + (u >> shift)) >> shift, 0, max);
71                             }
72                         } else {
73                             for (x = 0; x < w; x++) {
74                                 if (y_subsample) {
75                                     alpha = (av_bswap16(a[2*x])              + av_bswap16(a[2*x + 1]) + 2 +
76                                              av_bswap16(a[2*x + alpha_step]) + av_bswap16(a[2*x + alpha_step + 1])) >> 2;
77                                 } else
78                                     alpha = (av_bswap16(a[2*x]) + av_bswap16(a[2*x + 1])) >> 1;
79                                 u = av_bswap16(s[x])*alpha + target_table[((x^y)>>5)&1][plane]*(max-alpha) + off;
80                                 d[x] = av_clip((u + (u >> shift)) >> shift, 0, max);
81                             }
82                         }
83                     } else {
84                         ptrdiff_t alpha_step = srcStride[plane_count];
85                         const uint8_t *s = src[plane      ] + srcStride[plane] * y;
86                         const uint8_t *a = src[plane_count] + (srcStride[plane_count] * y << y_subsample);
87                               uint8_t *d = dst[plane      ] + dstStride[plane] * y;
88                         for (x = 0; x < w; x++) {
89                             if (y_subsample) {
90                                 alpha = (a[2*x]              + a[2*x + 1] + 2 +
91                                          a[2*x + alpha_step] + a[2*x + alpha_step + 1]) >> 2;
92                             } else
93                                 alpha = (a[2*x] + a[2*x + 1]) >> 1;
94                             u = s[x]*alpha + target_table[((x^y)>>5)&1][plane]*(255-alpha) + 128;
95                             d[x] = (257*u) >> 16;
96                         }
97                     }
98                 } else {
99                 if (sixteen_bits) {
100                     const uint16_t *s = (const uint16_t *)(src[plane      ] + srcStride[plane      ] * y);
101                     const uint16_t *a = (const uint16_t *)(src[plane_count] + srcStride[plane_count] * y);
102                           uint16_t *d = (      uint16_t *)(dst[plane      ] + dstStride[plane      ] * y);
103                     if ((!isBE(c->srcFormat)) == !HAVE_BIGENDIAN) {
104                         for (x = 0; x < w; x++) {
105                             unsigned u = s[x]*a[x] + target_table[((x^y)>>5)&1][plane]*(max-a[x]) + off;
106                             d[x] = av_clip((u + (u >> shift)) >> shift, 0, max);
107                         }
108                     } else {
109                         for (x = 0; x < w; x++) {
110                             unsigned aswap =av_bswap16(a[x]);
111                             unsigned u = av_bswap16(s[x])*aswap + target_table[((x^y)>>5)&1][plane]*(max-aswap) + off;
112                             d[x] = av_clip((u + (u >> shift)) >> shift, 0, max);
113                         }
114                     }
115                 } else {
116                     const uint8_t *s = src[plane      ] + srcStride[plane] * y;
117                     const uint8_t *a = src[plane_count] + srcStride[plane_count] * y;
118                           uint8_t *d = dst[plane      ] + dstStride[plane] * y;
119                     for (x = 0; x < w; x++) {
120                         unsigned u = s[x]*a[x] + target_table[((x^y)>>5)&1][plane]*(255-a[x]) + 128;
121                         d[x] = (257*u) >> 16;
122                     }
123                 }
124                 }
125             }
126         }
127     } else {
128         int alpha_pos = desc->comp[plane_count].offset;
129         int w = c->srcW;
130         for (y = srcSliceY; y < srcSliceH; y++) {
131             if (sixteen_bits) {
132                 const uint16_t *s = (const uint16_t *)(src[0] + srcStride[0] * y + 2*!alpha_pos);
133                 const uint16_t *a = (const uint16_t *)(src[0] + srcStride[0] * y +    alpha_pos);
134                       uint16_t *d = (      uint16_t *)(dst[0] + dstStride[0] * y);
135                 if ((!isBE(c->srcFormat)) == !HAVE_BIGENDIAN) {
136                     for (x = 0; x < w; x++) {
137                         for (plane = 0; plane < plane_count; plane++) {
138                             int x_index = (plane_count + 1) * x;
139                             unsigned u = s[x_index + plane]*a[x_index] + target_table[((x^y)>>5)&1][plane]*(max-a[x_index]) + off;
140                             d[plane_count*x + plane] = av_clip((u + (u >> shift)) >> shift, 0, max);
141                         }
142                     }
143                 } else {
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 aswap =av_bswap16(a[x_index]);
148                             unsigned u = av_bswap16(s[x_index + plane])*aswap + target_table[((x^y)>>5)&1][plane]*(max-aswap) + off;
149                             d[plane_count*x + plane] = av_clip((u + (u >> shift)) >> shift, 0, max);
150                         }
151                     }
152                 }
153             } else {
154                 const uint8_t *s = src[0] + srcStride[0] * y + !alpha_pos;
155                 const uint8_t *a = src[0] + srcStride[0] * y + alpha_pos;
156                       uint8_t *d = dst[0] + dstStride[0] * y;
157                 for (x = 0; x < w; x++) {
158                     for (plane = 0; plane < plane_count; plane++) {
159                         int x_index = (plane_count + 1) * x;
160                         unsigned u = s[x_index + plane]*a[x_index] + target_table[((x^y)>>5)&1][plane]*(255-a[x_index]) + 128;
161                         d[plane_count*x + plane] = (257*u) >> 16;
162                     }
163                 }
164             }
165         }
166     }
167
168     return 0;
169 }