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