Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * Copyright (C) 2015 Pedro Arthur <bygrandao@gmail.com> | ||
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 "libavutil/mem.h" | ||
22 | #include "swscale_internal.h" | ||
23 | |||
24 | /// Scaler instance data | ||
25 | typedef struct FilterContext | ||
26 | { | ||
27 | uint16_t *filter; | ||
28 | int *filter_pos; | ||
29 | int filter_size; | ||
30 | int xInc; | ||
31 | } FilterContext; | ||
32 | |||
33 | /// Color conversion instance data | ||
34 | typedef struct ColorContext | ||
35 | { | ||
36 | uint32_t *pal; | ||
37 | } ColorContext; | ||
38 | |||
39 | 1862034 | static int lum_h_scale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH) | |
40 | { | ||
41 | 1862034 | FilterContext *instance = desc->instance; | |
42 | 1862034 | int srcW = desc->src->width; | |
43 | 1862034 | int dstW = desc->dst->width; | |
44 | 1862034 | int xInc = instance->xInc; | |
45 | |||
46 | int i; | ||
47 |
2/2✓ Branch 0 taken 8986538 times.
✓ Branch 1 taken 1862034 times.
|
10848572 | for (i = 0; i < sliceH; ++i) { |
48 | 8986538 | uint8_t ** src = desc->src->plane[0].line; | |
49 | 8986538 | uint8_t ** dst = desc->dst->plane[0].line; | |
50 | 8986538 | int src_pos = sliceY+i - desc->src->plane[0].sliceY; | |
51 | 8986538 | int dst_pos = sliceY+i - desc->dst->plane[0].sliceY; | |
52 | |||
53 | |||
54 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8986538 times.
|
8986538 | if (c->hyscale_fast) { |
55 | ✗ | c->hyscale_fast(c, (int16_t*)dst[dst_pos], dstW, src[src_pos], srcW, xInc); | |
56 | } else { | ||
57 | 8986538 | c->hyScale(c, (int16_t*)dst[dst_pos], dstW, (const uint8_t *)src[src_pos], instance->filter, | |
58 | 8986538 | instance->filter_pos, instance->filter_size); | |
59 | } | ||
60 | |||
61 |
2/2✓ Branch 0 taken 999177 times.
✓ Branch 1 taken 7987361 times.
|
8986538 | if (c->lumConvertRange) |
62 | 999177 | c->lumConvertRange((int16_t*)dst[dst_pos], dstW); | |
63 | |||
64 | 8986538 | desc->dst->plane[0].sliceH += 1; | |
65 | |||
66 |
2/2✓ Branch 0 taken 112607 times.
✓ Branch 1 taken 8873931 times.
|
8986538 | if (desc->alpha) { |
67 | 112607 | src = desc->src->plane[3].line; | |
68 | 112607 | dst = desc->dst->plane[3].line; | |
69 | |||
70 | 112607 | src_pos = sliceY+i - desc->src->plane[3].sliceY; | |
71 | 112607 | dst_pos = sliceY+i - desc->dst->plane[3].sliceY; | |
72 | |||
73 | 112607 | desc->dst->plane[3].sliceH += 1; | |
74 | |||
75 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 112607 times.
|
112607 | if (c->hyscale_fast) { |
76 | ✗ | c->hyscale_fast(c, (int16_t*)dst[dst_pos], dstW, src[src_pos], srcW, xInc); | |
77 | } else { | ||
78 | 112607 | c->hyScale(c, (int16_t*)dst[dst_pos], dstW, (const uint8_t *)src[src_pos], instance->filter, | |
79 | 112607 | instance->filter_pos, instance->filter_size); | |
80 | } | ||
81 | } | ||
82 | } | ||
83 | |||
84 | 1862034 | return sliceH; | |
85 | } | ||
86 | |||
87 | 275819 | static int lum_convert(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH) | |
88 | { | ||
89 | 275819 | int srcW = desc->src->width; | |
90 | 275819 | ColorContext * instance = desc->instance; | |
91 | 275819 | uint32_t * pal = instance->pal; | |
92 | int i; | ||
93 | |||
94 | 275819 | desc->dst->plane[0].sliceY = sliceY; | |
95 | 275819 | desc->dst->plane[0].sliceH = sliceH; | |
96 | 275819 | desc->dst->plane[3].sliceY = sliceY; | |
97 | 275819 | desc->dst->plane[3].sliceH = sliceH; | |
98 | |||
99 |
2/2✓ Branch 0 taken 1598800 times.
✓ Branch 1 taken 275819 times.
|
1874619 | for (i = 0; i < sliceH; ++i) { |
100 | 1598800 | int sp0 = sliceY+i - desc->src->plane[0].sliceY; | |
101 | 1598800 | int sp1 = ((sliceY+i) >> desc->src->v_chr_sub_sample) - desc->src->plane[1].sliceY; | |
102 | 1598800 | const uint8_t * src[4] = { desc->src->plane[0].line[sp0], | |
103 | 1598800 | desc->src->plane[1].line[sp1], | |
104 | 1598800 | desc->src->plane[2].line[sp1], | |
105 | 1598800 | desc->src->plane[3].line[sp0]}; | |
106 | 1598800 | uint8_t * dst = desc->dst->plane[0].line[i]; | |
107 | |||
108 |
2/2✓ Branch 0 taken 1496958 times.
✓ Branch 1 taken 101842 times.
|
1598800 | if (c->lumToYV12) { |
109 | 1496958 | c->lumToYV12(dst, src[0], src[1], src[2], srcW, pal, c->input_opaque); | |
110 |
1/2✓ Branch 0 taken 101842 times.
✗ Branch 1 not taken.
|
101842 | } else if (c->readLumPlanar) { |
111 | 101842 | c->readLumPlanar(dst, src, srcW, c->input_rgb2yuv_table, c->input_opaque); | |
112 | } | ||
113 | |||
114 | |||
115 |
2/2✓ Branch 0 taken 108575 times.
✓ Branch 1 taken 1490225 times.
|
1598800 | if (desc->alpha) { |
116 | 108575 | dst = desc->dst->plane[3].line[i]; | |
117 |
2/2✓ Branch 0 taken 105152 times.
✓ Branch 1 taken 3423 times.
|
108575 | if (c->alpToYV12) { |
118 | 105152 | c->alpToYV12(dst, src[3], src[1], src[2], srcW, pal, c->input_opaque); | |
119 |
1/2✓ Branch 0 taken 3423 times.
✗ Branch 1 not taken.
|
3423 | } else if (c->readAlpPlanar) { |
120 | 3423 | c->readAlpPlanar(dst, src, srcW, NULL, c->input_opaque); | |
121 | } | ||
122 | } | ||
123 | } | ||
124 | |||
125 | 275819 | return sliceH; | |
126 | } | ||
127 | |||
128 | 866 | int ff_init_desc_fmt_convert(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst, uint32_t *pal) | |
129 | { | ||
130 | 866 | ColorContext * li = av_malloc(sizeof(ColorContext)); | |
131 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 866 times.
|
866 | if (!li) |
132 | ✗ | return AVERROR(ENOMEM); | |
133 | 866 | li->pal = pal; | |
134 | 866 | desc->instance = li; | |
135 | |||
136 |
3/4✓ Branch 1 taken 494 times.
✓ Branch 2 taken 372 times.
✓ Branch 4 taken 494 times.
✗ Branch 5 not taken.
|
866 | desc->alpha = isALPHA(src->fmt) && isALPHA(dst->fmt); |
137 | 866 | desc->src =src; | |
138 | 866 | desc->dst = dst; | |
139 | 866 | desc->process = &lum_convert; | |
140 | |||
141 | 866 | return 0; | |
142 | } | ||
143 | |||
144 | |||
145 | 4745 | int ff_init_desc_hscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc) | |
146 | { | ||
147 | 4745 | FilterContext *li = av_malloc(sizeof(FilterContext)); | |
148 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4745 times.
|
4745 | if (!li) |
149 | ✗ | return AVERROR(ENOMEM); | |
150 | |||
151 | 4745 | li->filter = filter; | |
152 | 4745 | li->filter_pos = filter_pos; | |
153 | 4745 | li->filter_size = filter_size; | |
154 | 4745 | li->xInc = xInc; | |
155 | |||
156 | 4745 | desc->instance = li; | |
157 | |||
158 |
3/4✓ Branch 1 taken 519 times.
✓ Branch 2 taken 4226 times.
✓ Branch 4 taken 519 times.
✗ Branch 5 not taken.
|
4745 | desc->alpha = isALPHA(src->fmt) && isALPHA(dst->fmt); |
159 | 4745 | desc->src = src; | |
160 | 4745 | desc->dst = dst; | |
161 | |||
162 | 4745 | desc->process = &lum_h_scale; | |
163 | |||
164 | 4745 | return 0; | |
165 | } | ||
166 | |||
167 | 1552228 | static int chr_h_scale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH) | |
168 | { | ||
169 | 1552228 | FilterContext *instance = desc->instance; | |
170 | 1552228 | int srcW = AV_CEIL_RSHIFT(desc->src->width, desc->src->h_chr_sub_sample); | |
171 | 1552228 | int dstW = AV_CEIL_RSHIFT(desc->dst->width, desc->dst->h_chr_sub_sample); | |
172 | 1552228 | int xInc = instance->xInc; | |
173 | |||
174 | 1552228 | uint8_t ** src1 = desc->src->plane[1].line; | |
175 | 1552228 | uint8_t ** dst1 = desc->dst->plane[1].line; | |
176 | 1552228 | uint8_t ** src2 = desc->src->plane[2].line; | |
177 | 1552228 | uint8_t ** dst2 = desc->dst->plane[2].line; | |
178 | |||
179 | 1552228 | int src_pos1 = sliceY - desc->src->plane[1].sliceY; | |
180 | 1552228 | int dst_pos1 = sliceY - desc->dst->plane[1].sliceY; | |
181 | |||
182 | 1552228 | int src_pos2 = sliceY - desc->src->plane[2].sliceY; | |
183 | 1552228 | int dst_pos2 = sliceY - desc->dst->plane[2].sliceY; | |
184 | |||
185 | int i; | ||
186 |
2/2✓ Branch 0 taken 5778936 times.
✓ Branch 1 taken 1552228 times.
|
7331164 | for (i = 0; i < sliceH; ++i) { |
187 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5778936 times.
|
5778936 | if (c->hcscale_fast) { |
188 | ✗ | c->hcscale_fast(c, (uint16_t*)dst1[dst_pos1+i], (uint16_t*)dst2[dst_pos2+i], dstW, src1[src_pos1+i], src2[src_pos2+i], srcW, xInc); | |
189 | } else { | ||
190 | 5778936 | c->hcScale(c, (uint16_t*)dst1[dst_pos1+i], dstW, src1[src_pos1+i], instance->filter, instance->filter_pos, instance->filter_size); | |
191 | 5778936 | c->hcScale(c, (uint16_t*)dst2[dst_pos2+i], dstW, src2[src_pos2+i], instance->filter, instance->filter_pos, instance->filter_size); | |
192 | } | ||
193 | |||
194 |
2/2✓ Branch 0 taken 417073 times.
✓ Branch 1 taken 5361863 times.
|
5778936 | if (c->chrConvertRange) |
195 | 417073 | c->chrConvertRange((uint16_t*)dst1[dst_pos1+i], (uint16_t*)dst2[dst_pos2+i], dstW); | |
196 | |||
197 | 5778936 | desc->dst->plane[1].sliceH += 1; | |
198 | 5778936 | desc->dst->plane[2].sliceH += 1; | |
199 | } | ||
200 | 1552228 | return sliceH; | |
201 | } | ||
202 | |||
203 | 368606 | static int chr_convert(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH) | |
204 | { | ||
205 | 368606 | int srcW = AV_CEIL_RSHIFT(desc->src->width, desc->src->h_chr_sub_sample); | |
206 | 368606 | ColorContext * instance = desc->instance; | |
207 | 368606 | uint32_t * pal = instance->pal; | |
208 | |||
209 | 368606 | int sp0 = (sliceY - (desc->src->plane[0].sliceY >> desc->src->v_chr_sub_sample)) << desc->src->v_chr_sub_sample; | |
210 | 368606 | int sp1 = sliceY - desc->src->plane[1].sliceY; | |
211 | |||
212 | int i; | ||
213 | |||
214 | 368606 | desc->dst->plane[1].sliceY = sliceY; | |
215 | 368606 | desc->dst->plane[1].sliceH = sliceH; | |
216 | 368606 | desc->dst->plane[2].sliceY = sliceY; | |
217 | 368606 | desc->dst->plane[2].sliceH = sliceH; | |
218 | |||
219 |
2/2✓ Branch 0 taken 1501932 times.
✓ Branch 1 taken 368606 times.
|
1870538 | for (i = 0; i < sliceH; ++i) { |
220 | 1501932 | const uint8_t * src[4] = { desc->src->plane[0].line[sp0+i], | |
221 | 1501932 | desc->src->plane[1].line[sp1+i], | |
222 | 1501932 | desc->src->plane[2].line[sp1+i], | |
223 | 1501932 | desc->src->plane[3].line[sp0+i]}; | |
224 | |||
225 | 1501932 | uint8_t * dst1 = desc->dst->plane[1].line[i]; | |
226 | 1501932 | uint8_t * dst2 = desc->dst->plane[2].line[i]; | |
227 |
2/2✓ Branch 0 taken 1422540 times.
✓ Branch 1 taken 79392 times.
|
1501932 | if (c->chrToYV12) { |
228 | 1422540 | c->chrToYV12(dst1, dst2, src[0], src[1], src[2], srcW, pal, c->input_opaque); | |
229 |
1/2✓ Branch 0 taken 79392 times.
✗ Branch 1 not taken.
|
79392 | } else if (c->readChrPlanar) { |
230 | 79392 | c->readChrPlanar(dst1, dst2, src, srcW, c->input_rgb2yuv_table, c->input_opaque); | |
231 | } | ||
232 | } | ||
233 | 368606 | return sliceH; | |
234 | } | ||
235 | |||
236 | 721 | int ff_init_desc_cfmt_convert(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst, uint32_t *pal) | |
237 | { | ||
238 | 721 | ColorContext * li = av_malloc(sizeof(ColorContext)); | |
239 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 721 times.
|
721 | if (!li) |
240 | ✗ | return AVERROR(ENOMEM); | |
241 | 721 | li->pal = pal; | |
242 | 721 | desc->instance = li; | |
243 | |||
244 | 721 | desc->src =src; | |
245 | 721 | desc->dst = dst; | |
246 | 721 | desc->process = &chr_convert; | |
247 | |||
248 | 721 | return 0; | |
249 | } | ||
250 | |||
251 | 4280 | int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc) | |
252 | { | ||
253 | 4280 | FilterContext *li = av_malloc(sizeof(FilterContext)); | |
254 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4280 times.
|
4280 | if (!li) |
255 | ✗ | return AVERROR(ENOMEM); | |
256 | |||
257 | 4280 | li->filter = filter; | |
258 | 4280 | li->filter_pos = filter_pos; | |
259 | 4280 | li->filter_size = filter_size; | |
260 | 4280 | li->xInc = xInc; | |
261 | |||
262 | 4280 | desc->instance = li; | |
263 | |||
264 |
3/4✓ Branch 1 taken 381 times.
✓ Branch 2 taken 3899 times.
✓ Branch 4 taken 381 times.
✗ Branch 5 not taken.
|
4280 | desc->alpha = isALPHA(src->fmt) && isALPHA(dst->fmt); |
265 | 4280 | desc->src = src; | |
266 | 4280 | desc->dst = dst; | |
267 | |||
268 | 4280 | desc->process = &chr_h_scale; | |
269 | |||
270 | 4280 | return 0; | |
271 | } | ||
272 | |||
273 | 51399 | static int no_chr_scale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH) | |
274 | { | ||
275 | 51399 | desc->dst->plane[1].sliceY = sliceY + sliceH - desc->dst->plane[1].available_lines; | |
276 | 51399 | desc->dst->plane[1].sliceH = desc->dst->plane[1].available_lines; | |
277 | 51399 | desc->dst->plane[2].sliceY = sliceY + sliceH - desc->dst->plane[2].available_lines; | |
278 | 51399 | desc->dst->plane[2].sliceH = desc->dst->plane[2].available_lines; | |
279 | 51399 | return 0; | |
280 | } | ||
281 | |||
282 | 465 | int ff_init_desc_no_chr(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst) | |
283 | { | ||
284 | 465 | desc->src = src; | |
285 | 465 | desc->dst = dst; | |
286 | 465 | desc->alpha = 0; | |
287 | 465 | desc->instance = NULL; | |
288 | 465 | desc->process = &no_chr_scale; | |
289 | 465 | return 0; | |
290 | } | ||
291 |