Line data Source code
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 : #include "swscale_internal.h"
21 :
22 : typedef struct VScalerContext
23 : {
24 : uint16_t *filter[2];
25 : int32_t *filter_pos;
26 : int filter_size;
27 : int isMMX;
28 : void *pfn;
29 : yuv2packedX_fn yuv2packedX;
30 : } VScalerContext;
31 :
32 :
33 7787449 : static int lum_planar_vscale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
34 : {
35 7787449 : VScalerContext *inst = desc->instance;
36 7787449 : int dstW = desc->dst->width;
37 :
38 7787449 : int first = FFMAX(1-inst->filter_size, inst->filter_pos[sliceY]);
39 7787449 : int sp = first - desc->src->plane[0].sliceY;
40 7787449 : int dp = sliceY - desc->dst->plane[0].sliceY;
41 7787449 : uint8_t **src = desc->src->plane[0].line + sp;
42 7787449 : uint8_t **dst = desc->dst->plane[0].line + dp;
43 7787449 : uint16_t *filter = inst->filter[0] + (inst->isMMX ? 0 : sliceY * inst->filter_size);
44 :
45 7787449 : if (inst->filter_size == 1)
46 4418249 : ((yuv2planar1_fn)inst->pfn)((const int16_t*)src[0], dst[0], dstW, c->lumDither8, 0);
47 : else
48 3369200 : ((yuv2planarX_fn)inst->pfn)(filter, inst->filter_size, (const int16_t**)src, dst[0], dstW, c->lumDither8, 0);
49 :
50 7787449 : if (desc->alpha) {
51 163924 : int sp = first - desc->src->plane[3].sliceY;
52 163924 : int dp = sliceY - desc->dst->plane[3].sliceY;
53 163924 : uint8_t **src = desc->src->plane[3].line + sp;
54 163924 : uint8_t **dst = desc->dst->plane[3].line + dp;
55 163924 : uint16_t *filter = inst->filter[1] + (inst->isMMX ? 0 : sliceY * inst->filter_size);
56 :
57 163924 : if (inst->filter_size == 1)
58 161824 : ((yuv2planar1_fn)inst->pfn)((const int16_t*)src[0], dst[0], dstW, c->lumDither8, 0);
59 : else
60 2100 : ((yuv2planarX_fn)inst->pfn)(filter, inst->filter_size, (const int16_t**)src, dst[0], dstW, c->lumDither8, 0);
61 : }
62 :
63 7787449 : return 1;
64 : }
65 :
66 7547520 : static int chr_planar_vscale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
67 : {
68 7547520 : const int chrSkipMask = (1 << desc->dst->v_chr_sub_sample) - 1;
69 7547520 : if (sliceY & chrSkipMask)
70 2806609 : return 0;
71 : else {
72 4740911 : VScalerContext *inst = desc->instance;
73 4740911 : int dstW = AV_CEIL_RSHIFT(desc->dst->width, desc->dst->h_chr_sub_sample);
74 4740911 : int chrSliceY = sliceY >> desc->dst->v_chr_sub_sample;
75 :
76 4740911 : int first = FFMAX(1-inst->filter_size, inst->filter_pos[chrSliceY]);
77 4740911 : int sp1 = first - desc->src->plane[1].sliceY;
78 4740911 : int sp2 = first - desc->src->plane[2].sliceY;
79 4740911 : int dp1 = chrSliceY - desc->dst->plane[1].sliceY;
80 4740911 : int dp2 = chrSliceY - desc->dst->plane[2].sliceY;
81 4740911 : uint8_t **src1 = desc->src->plane[1].line + sp1;
82 4740911 : uint8_t **src2 = desc->src->plane[2].line + sp2;
83 4740911 : uint8_t **dst1 = desc->dst->plane[1].line + dp1;
84 4740911 : uint8_t **dst2 = desc->dst->plane[2].line + dp2;
85 4740911 : uint16_t *filter = inst->filter[0] + (inst->isMMX ? 0 : chrSliceY * inst->filter_size);
86 :
87 4740911 : if (c->yuv2nv12cX) {
88 4332 : ((yuv2interleavedX_fn)inst->pfn)(c, filter, inst->filter_size, (const int16_t**)src1, (const int16_t**)src2, dst1[0], dstW);
89 4736579 : } else if (inst->filter_size == 1) {
90 792870 : ((yuv2planar1_fn)inst->pfn)((const int16_t*)src1[0], dst1[0], dstW, c->chrDither8, 0);
91 792870 : ((yuv2planar1_fn)inst->pfn)((const int16_t*)src2[0], dst2[0], dstW, c->chrDither8, 3);
92 : } else {
93 3943709 : ((yuv2planarX_fn)inst->pfn)(filter, inst->filter_size, (const int16_t**)src1, dst1[0], dstW, c->chrDither8, 0);
94 3943709 : ((yuv2planarX_fn)inst->pfn)(filter, inst->filter_size, (const int16_t**)src2, dst2[0], dstW, c->chrDither8, inst->isMMX ? (c->uv_offx2 >> 1) : 3);
95 : }
96 : }
97 :
98 4740911 : return 1;
99 : }
100 :
101 2006829 : static int packed_vscale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
102 : {
103 2006829 : VScalerContext *inst = desc->instance;
104 2006829 : int dstW = desc->dst->width;
105 2006829 : int chrSliceY = sliceY >> desc->dst->v_chr_sub_sample;
106 :
107 2006829 : int lum_fsize = inst[0].filter_size;
108 2006829 : int chr_fsize = inst[1].filter_size;
109 2006829 : uint16_t *lum_filter = inst[0].filter[0];
110 2006829 : uint16_t *chr_filter = inst[1].filter[0];
111 :
112 2006829 : int firstLum = FFMAX(1-lum_fsize, inst[0].filter_pos[ sliceY]);
113 2006829 : int firstChr = FFMAX(1-chr_fsize, inst[1].filter_pos[chrSliceY]);
114 :
115 2006829 : int sp0 = firstLum - desc->src->plane[0].sliceY;
116 2006829 : int sp1 = firstChr - desc->src->plane[1].sliceY;
117 2006829 : int sp2 = firstChr - desc->src->plane[2].sliceY;
118 2006829 : int sp3 = firstLum - desc->src->plane[3].sliceY;
119 2006829 : int dp = sliceY - desc->dst->plane[0].sliceY;
120 2006829 : uint8_t **src0 = desc->src->plane[0].line + sp0;
121 2006829 : uint8_t **src1 = desc->src->plane[1].line + sp1;
122 2006829 : uint8_t **src2 = desc->src->plane[2].line + sp2;
123 2006829 : uint8_t **src3 = desc->alpha ? desc->src->plane[3].line + sp3 : NULL;
124 2006829 : uint8_t **dst = desc->dst->plane[0].line + dp;
125 :
126 :
127 2006829 : if (c->yuv2packed1 && lum_fsize == 1 && chr_fsize == 1) { // unscaled RGB
128 1326626 : ((yuv2packed1_fn)inst->pfn)(c, (const int16_t*)*src0, (const int16_t**)src1, (const int16_t**)src2,
129 663313 : (const int16_t*)(desc->alpha ? *src3 : NULL), *dst, dstW, 0, sliceY);
130 1343516 : } else if (c->yuv2packed1 && lum_fsize == 1 && chr_fsize == 2 &&
131 0 : chr_filter[2 * chrSliceY + 1] + chr_filter[2 * chrSliceY] == 4096 &&
132 0 : chr_filter[2 * chrSliceY + 1] <= 4096U) { // unscaled RGB
133 0 : int chrAlpha = chr_filter[2 * chrSliceY + 1];
134 0 : ((yuv2packed1_fn)inst->pfn)(c, (const int16_t*)*src0, (const int16_t**)src1, (const int16_t**)src2,
135 0 : (const int16_t*)(desc->alpha ? *src3 : NULL), *dst, dstW, chrAlpha, sliceY);
136 1343516 : } else if (c->yuv2packed2 && lum_fsize == 2 && chr_fsize == 2 &&
137 0 : lum_filter[2 * sliceY + 1] + lum_filter[2 * sliceY] == 4096 &&
138 0 : lum_filter[2 * sliceY + 1] <= 4096U &&
139 0 : chr_filter[2 * chrSliceY + 1] + chr_filter[2 * chrSliceY] == 4096 &&
140 0 : chr_filter[2 * chrSliceY + 1] <= 4096U
141 0 : ) { // bilinear upscale RGB
142 0 : int lumAlpha = lum_filter[2 * sliceY + 1];
143 0 : int chrAlpha = chr_filter[2 * chrSliceY + 1];
144 0 : c->lumMmxFilter[2] =
145 0 : c->lumMmxFilter[3] = lum_filter[2 * sliceY] * 0x10001;
146 0 : c->chrMmxFilter[2] =
147 0 : c->chrMmxFilter[3] = chr_filter[2 * chrSliceY] * 0x10001;
148 0 : ((yuv2packed2_fn)inst->pfn)(c, (const int16_t**)src0, (const int16_t**)src1, (const int16_t**)src2, (const int16_t**)src3,
149 : *dst, dstW, lumAlpha, chrAlpha, sliceY);
150 : } else { // general RGB
151 2687032 : if ((c->yuv2packed1 && lum_fsize == 1 && chr_fsize == 2) ||
152 2682612 : (c->yuv2packed2 && lum_fsize == 2 && chr_fsize == 2)) {
153 0 : if (!c->warned_unuseable_bilinear)
154 0 : av_log(c, AV_LOG_INFO, "Optimized 2 tap filter code cannot be used\n");
155 0 : c->warned_unuseable_bilinear = 1;
156 : }
157 :
158 2687032 : inst->yuv2packedX(c, lum_filter + sliceY * lum_fsize,
159 1343516 : (const int16_t**)src0, lum_fsize, chr_filter + chrSliceY * chr_fsize,
160 : (const int16_t**)src1, (const int16_t**)src2, chr_fsize, (const int16_t**)src3, *dst, dstW, sliceY);
161 : }
162 2006829 : return 1;
163 : }
164 :
165 243940 : static int any_vscale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
166 : {
167 243940 : VScalerContext *inst = desc->instance;
168 243940 : int dstW = desc->dst->width;
169 243940 : int chrSliceY = sliceY >> desc->dst->v_chr_sub_sample;
170 :
171 243940 : int lum_fsize = inst[0].filter_size;
172 243940 : int chr_fsize = inst[1].filter_size;
173 243940 : uint16_t *lum_filter = inst[0].filter[0];
174 243940 : uint16_t *chr_filter = inst[1].filter[0];
175 :
176 243940 : int firstLum = FFMAX(1-lum_fsize, inst[0].filter_pos[ sliceY]);
177 243940 : int firstChr = FFMAX(1-chr_fsize, inst[1].filter_pos[chrSliceY]);
178 :
179 243940 : int sp0 = firstLum - desc->src->plane[0].sliceY;
180 243940 : int sp1 = firstChr - desc->src->plane[1].sliceY;
181 243940 : int sp2 = firstChr - desc->src->plane[2].sliceY;
182 243940 : int sp3 = firstLum - desc->src->plane[3].sliceY;
183 243940 : int dp0 = sliceY - desc->dst->plane[0].sliceY;
184 243940 : int dp1 = chrSliceY - desc->dst->plane[1].sliceY;
185 243940 : int dp2 = chrSliceY - desc->dst->plane[2].sliceY;
186 243940 : int dp3 = sliceY - desc->dst->plane[3].sliceY;
187 :
188 243940 : uint8_t **src0 = desc->src->plane[0].line + sp0;
189 243940 : uint8_t **src1 = desc->src->plane[1].line + sp1;
190 243940 : uint8_t **src2 = desc->src->plane[2].line + sp2;
191 243940 : uint8_t **src3 = desc->alpha ? desc->src->plane[3].line + sp3 : NULL;
192 975760 : uint8_t *dst[4] = { desc->dst->plane[0].line[dp0],
193 243940 : desc->dst->plane[1].line[dp1],
194 243940 : desc->dst->plane[2].line[dp2],
195 243940 : desc->alpha ? desc->dst->plane[3].line[dp3] : NULL };
196 :
197 : av_assert1(!c->yuv2packed1 && !c->yuv2packed2);
198 487880 : ((yuv2anyX_fn)inst->pfn)(c, lum_filter + sliceY * lum_fsize,
199 243940 : (const int16_t**)src0, lum_fsize, chr_filter + sliceY * chr_fsize,
200 : (const int16_t**)src1, (const int16_t**)src2, chr_fsize, (const int16_t**)src3, dst, dstW, sliceY);
201 :
202 243940 : return 1;
203 :
204 : }
205 :
206 2538 : int ff_init_vscale(SwsContext *c, SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst)
207 : {
208 2538 : VScalerContext *lumCtx = NULL;
209 2538 : VScalerContext *chrCtx = NULL;
210 :
211 2538 : if (isPlanarYUV(c->dstFormat) || (isGray(c->dstFormat) && !isALPHA(c->dstFormat))) {
212 1541 : lumCtx = av_mallocz(sizeof(VScalerContext));
213 1541 : if (!lumCtx)
214 0 : return AVERROR(ENOMEM);
215 :
216 :
217 1541 : desc[0].process = lum_planar_vscale;
218 1541 : desc[0].instance = lumCtx;
219 1541 : desc[0].src = src;
220 1541 : desc[0].dst = dst;
221 1541 : desc[0].alpha = c->needAlpha;
222 :
223 3082 : if (!isGray(c->dstFormat)) {
224 1373 : chrCtx = av_mallocz(sizeof(VScalerContext));
225 1373 : if (!chrCtx)
226 0 : return AVERROR(ENOMEM);
227 1373 : desc[1].process = chr_planar_vscale;
228 1373 : desc[1].instance = chrCtx;
229 1373 : desc[1].src = src;
230 1373 : desc[1].dst = dst;
231 : }
232 : } else {
233 997 : lumCtx = av_mallocz_array(sizeof(VScalerContext), 2);
234 997 : if (!lumCtx)
235 0 : return AVERROR(ENOMEM);
236 997 : chrCtx = &lumCtx[1];
237 :
238 997 : desc[0].process = c->yuv2packedX ? packed_vscale : any_vscale;
239 997 : desc[0].instance = lumCtx;
240 997 : desc[0].src = src;
241 997 : desc[0].dst = dst;
242 997 : desc[0].alpha = c->needAlpha;
243 : }
244 :
245 2538 : ff_init_vscale_pfn(c, c->yuv2plane1, c->yuv2planeX, c->yuv2nv12cX,
246 : c->yuv2packed1, c->yuv2packed2, c->yuv2packedX, c->yuv2anyX, c->use_mmx_vfilter);
247 2538 : return 0;
248 : }
249 :
250 95844 : void ff_init_vscale_pfn(SwsContext *c,
251 : yuv2planar1_fn yuv2plane1,
252 : yuv2planarX_fn yuv2planeX,
253 : yuv2interleavedX_fn yuv2nv12cX,
254 : yuv2packed1_fn yuv2packed1,
255 : yuv2packed2_fn yuv2packed2,
256 : yuv2packedX_fn yuv2packedX,
257 : yuv2anyX_fn yuv2anyX, int use_mmx)
258 : {
259 95844 : VScalerContext *lumCtx = NULL;
260 95844 : VScalerContext *chrCtx = NULL;
261 95844 : int idx = c->numDesc - (c->is_internal_gamma ? 2 : 1); //FIXME avoid hardcoding indexes
262 :
263 95844 : if (isPlanarYUV(c->dstFormat) || (isGray(c->dstFormat) && !isALPHA(c->dstFormat))) {
264 66572 : if (!isGray(c->dstFormat)) {
265 63719 : chrCtx = c->desc[idx].instance;
266 :
267 63719 : chrCtx->filter[0] = use_mmx ? (int16_t*)c->chrMmxFilter : c->vChrFilter;
268 63719 : chrCtx->filter_size = c->vChrFilterSize;
269 63719 : chrCtx->filter_pos = c->vChrFilterPos;
270 63719 : chrCtx->isMMX = use_mmx;
271 :
272 63719 : --idx;
273 63719 : if (yuv2nv12cX) chrCtx->pfn = yuv2nv12cX;
274 63591 : else if (c->vChrFilterSize == 1) chrCtx->pfn = yuv2plane1;
275 47106 : else chrCtx->pfn = yuv2planeX;
276 : }
277 :
278 66572 : lumCtx = c->desc[idx].instance;
279 :
280 66572 : lumCtx->filter[0] = use_mmx ? (int16_t*)c->lumMmxFilter : c->vLumFilter;
281 66572 : lumCtx->filter[1] = use_mmx ? (int16_t*)c->alpMmxFilter : c->vLumFilter;
282 66572 : lumCtx->filter_size = c->vLumFilterSize;
283 66572 : lumCtx->filter_pos = c->vLumFilterPos;
284 66572 : lumCtx->isMMX = use_mmx;
285 :
286 133144 : if (c->vLumFilterSize == 1) lumCtx->pfn = yuv2plane1;
287 10913 : else lumCtx->pfn = yuv2planeX;
288 :
289 : } else {
290 29272 : lumCtx = c->desc[idx].instance;
291 29272 : chrCtx = &lumCtx[1];
292 :
293 29272 : lumCtx->filter[0] = c->vLumFilter;
294 29272 : lumCtx->filter_size = c->vLumFilterSize;
295 29272 : lumCtx->filter_pos = c->vLumFilterPos;
296 :
297 29272 : chrCtx->filter[0] = c->vChrFilter;
298 29272 : chrCtx->filter_size = c->vChrFilterSize;
299 29272 : chrCtx->filter_pos = c->vChrFilterPos;
300 :
301 29272 : lumCtx->isMMX = use_mmx;
302 29272 : chrCtx->isMMX = use_mmx;
303 :
304 29272 : if (yuv2packedX) {
305 26397 : if (c->yuv2packed1 && c->vLumFilterSize == 1 && c->vChrFilterSize <= 2)
306 8999 : lumCtx->pfn = yuv2packed1;
307 17398 : else if (c->yuv2packed2 && c->vLumFilterSize == 2 && c->vChrFilterSize == 2)
308 0 : lumCtx->pfn = yuv2packed2;
309 26397 : lumCtx->yuv2packedX = yuv2packedX;
310 : } else
311 2875 : lumCtx->pfn = yuv2anyX;
312 : }
313 95844 : }
314 :
315 :
|
