swscale: refactor horizontal scaling
[ffmpeg.git] / libswscale / hscale.c
1 #include "swscale_internal.h"
2
3 static int lum_h_scale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
4 {
5     FilterContext *instance = desc->instance;
6     int srcW = desc->src->width;
7     int dstW = desc->dst->width;
8     int xInc = instance->xInc;
9
10     int i;
11     for (i = 0; i < sliceH; ++i) {
12         uint8_t ** src = desc->src->plane[0].line;
13         uint8_t ** dst = desc->dst->plane[0].line;
14         int src_pos = sliceY+i - desc->src->plane[0].sliceY;
15         int dst_pos = sliceY+i - desc->dst->plane[0].sliceY;
16
17
18         if (c->hyscale_fast) {
19             c->hyscale_fast(c, (int16_t*)dst[dst_pos], dstW, src[src_pos], srcW, xInc);
20         } else {
21             c->hyScale(c, (int16_t*)dst[dst_pos], dstW, (const uint8_t *)src[src_pos], instance->filter,
22                        instance->filter_pos, instance->filter_size);
23         }
24
25         if (c->lumConvertRange)
26             c->lumConvertRange((int16_t*)dst[dst_pos], dstW);
27
28         desc->dst->plane[0].sliceH += 1;
29
30         if (desc->alpha) {
31             src = desc->src->plane[3].line;
32             dst = desc->dst->plane[3].line;
33
34             src_pos = sliceY+i - desc->src->plane[3].sliceY;
35             dst_pos = sliceY+i - desc->dst->plane[3].sliceY;
36
37             desc->dst->plane[3].sliceH += 1;
38
39             if (c->hyscale_fast) {
40                 c->hyscale_fast(c, (int16_t*)dst[dst_pos], dstW, src[src_pos], srcW, xInc);
41             } else {
42                 c->hyScale(c, (int16_t*)dst[dst_pos], dstW, (const uint8_t *)src[src_pos], instance->filter,
43                             instance->filter_pos, instance->filter_size);
44             }
45         }
46     }
47
48     return sliceH;
49 }
50
51 static int lum_convert(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
52 {
53     int srcW = desc->src->width;
54     ColorContext * instance = desc->instance;
55     uint32_t * pal = instance->pal;
56     int i;
57
58     desc->dst->plane[0].sliceY = sliceY;
59     desc->dst->plane[0].sliceH = sliceH;
60     desc->dst->plane[3].sliceY = sliceY;
61     desc->dst->plane[3].sliceH = sliceH;
62
63     for (i = 0; i < sliceH; ++i) {
64         int sp0 = sliceY+i - desc->src->plane[0].sliceY;
65         int sp1 = ((sliceY+i) >> desc->src->v_chr_sub_sample) - desc->src->plane[1].sliceY;
66         const uint8_t * src[4] = { desc->src->plane[0].line[sp0],
67                         desc->src->plane[1].line[sp1],
68                         desc->src->plane[2].line[sp1],
69                         desc->src->plane[3].line[sp0]};
70         uint8_t * dst = desc->dst->plane[0].line[i];
71
72         if (c->lumToYV12) {
73             c->lumToYV12(dst, src[0], src[1], src[2], srcW, pal);
74         } else if (c->readLumPlanar) {
75             c->readLumPlanar(dst, src, srcW, c->input_rgb2yuv_table);
76         }
77
78
79         if (desc->alpha) {
80             dst = desc->dst->plane[3].line[i];
81             if (c->alpToYV12) {
82                 c->alpToYV12(dst, src[3], src[1], src[2], srcW, pal);
83             } else if (c->readAlpPlanar) {
84                 c->readAlpPlanar(dst, src, srcW, NULL);
85             }
86         }
87     }
88
89     return sliceH;
90 }
91
92 int ff_init_desc_fmt_convert(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst, uint32_t *pal)
93 {
94     ColorContext * li = av_malloc(sizeof(ColorContext));
95     if (!li)
96         return AVERROR(ENOMEM);
97     li->pal = pal;
98     desc->instance = li;
99
100     desc->alpha = isALPHA(src->fmt) && isALPHA(dst->fmt);
101     desc->src =src;
102     desc->dst = dst;
103     desc->process = &lum_convert;
104
105     return 0;
106 }
107
108
109 int ff_init_desc_hscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc)
110 {
111     FilterContext *li = av_malloc(sizeof(FilterContext));
112     if (!li)
113         return AVERROR(ENOMEM);
114
115     li->filter = filter;
116     li->filter_pos = filter_pos;
117     li->filter_size = filter_size;
118     li->xInc = xInc;
119
120     desc->instance = li;
121
122     desc->alpha = isALPHA(src->fmt) && isALPHA(dst->fmt);
123     desc->src = src;
124     desc->dst = dst;
125
126     desc->process = &lum_h_scale;
127
128     return 0;
129 }
130
131 static int chr_h_scale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
132 {
133     FilterContext *instance = desc->instance;
134     int srcW = FF_CEIL_RSHIFT(desc->src->width, desc->src->h_chr_sub_sample);
135     int dstW = FF_CEIL_RSHIFT(desc->dst->width, desc->dst->h_chr_sub_sample);
136     int xInc = instance->xInc;
137
138     uint8_t ** src1 = desc->src->plane[1].line;
139     uint8_t ** dst1 = desc->dst->plane[1].line;
140     uint8_t ** src2 = desc->src->plane[2].line;
141     uint8_t ** dst2 = desc->dst->plane[2].line;
142
143     int src_pos1 = sliceY - desc->src->plane[1].sliceY;
144     int dst_pos1 = sliceY - desc->dst->plane[1].sliceY;
145
146     int src_pos2 = sliceY - desc->src->plane[2].sliceY;
147     int dst_pos2 = sliceY - desc->dst->plane[2].sliceY;
148
149     int i;
150     for (i = 0; i < sliceH; ++i) {
151         if (c->hcscale_fast) {
152             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);
153         } else {
154             c->hcScale(c, (uint16_t*)dst1[dst_pos1+i], dstW, src1[src_pos1+i], instance->filter, instance->filter_pos, instance->filter_size);
155             c->hcScale(c, (uint16_t*)dst2[dst_pos2+i], dstW, src2[src_pos2+i], instance->filter, instance->filter_pos, instance->filter_size);
156         }
157
158         if (c->chrConvertRange)
159             c->chrConvertRange((uint16_t*)dst1[dst_pos1+i], (uint16_t*)dst2[dst_pos2+i], dstW);
160
161         desc->dst->plane[1].sliceH += 1;
162         desc->dst->plane[2].sliceH += 1;
163     }
164     return sliceH;
165 }
166
167 static int chr_convert(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
168 {
169     int srcW = FF_CEIL_RSHIFT(desc->src->width, desc->src->h_chr_sub_sample);
170     ColorContext * instance = desc->instance;
171     uint32_t * pal = instance->pal;
172
173     int sp0 = (sliceY - (desc->src->plane[0].sliceY >> desc->src->v_chr_sub_sample)) << desc->src->v_chr_sub_sample;
174     int sp1 = sliceY - desc->src->plane[1].sliceY;
175
176     int i;
177
178     desc->dst->plane[1].sliceY = sliceY;
179     desc->dst->plane[1].sliceH = sliceH;
180     desc->dst->plane[2].sliceY = sliceY;
181     desc->dst->plane[2].sliceH = sliceH;
182
183     for (i = 0; i < sliceH; ++i) {
184         const uint8_t * src[4] = { desc->src->plane[0].line[sp0+i],
185                         desc->src->plane[1].line[sp1+i],
186                         desc->src->plane[2].line[sp1+i],
187                         desc->src->plane[3].line[sp0+i]};
188
189         uint8_t * dst1 = desc->dst->plane[1].line[i];
190         uint8_t * dst2 = desc->dst->plane[2].line[i];
191         if (c->chrToYV12) {
192             c->chrToYV12(dst1, dst2, src[0], src[1], src[2], srcW, pal);
193         } else if (c->readChrPlanar) {
194             c->readChrPlanar(dst1, dst2, src, srcW, c->input_rgb2yuv_table);
195         }
196     }
197     return sliceH;
198 }
199
200 int ff_init_desc_cfmt_convert(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst, uint32_t *pal)
201 {
202     ColorContext * li = av_malloc(sizeof(ColorContext));
203     if (!li)
204         return AVERROR(ENOMEM);
205     li->pal = pal;
206     desc->instance = li;
207
208     desc->src =src;
209     desc->dst = dst;
210     desc->process = &chr_convert;
211
212     return 0;
213 }
214
215 int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc)
216 {
217     FilterContext *li = av_malloc(sizeof(FilterContext));
218     if (!li)
219         return AVERROR(ENOMEM);
220
221     li->filter = filter;
222     li->filter_pos = filter_pos;
223     li->filter_size = filter_size;
224     li->xInc = xInc;
225
226     desc->instance = li;
227
228     desc->alpha = isALPHA(src->fmt) && isALPHA(dst->fmt);
229     desc->src = src;
230     desc->dst = dst;
231
232     desc->process = &chr_h_scale;
233
234     return 0;
235 }
236
237 static int no_chr_scale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
238 {
239     desc->dst->plane[1].sliceY = sliceY + sliceH - desc->dst->plane[1].available_lines;
240     desc->dst->plane[1].sliceH = desc->dst->plane[1].available_lines;
241     desc->dst->plane[2].sliceY = sliceY + sliceH - desc->dst->plane[2].available_lines;
242     desc->dst->plane[2].sliceH = desc->dst->plane[2].available_lines;
243     return 0;
244 }
245
246 int ff_init_desc_no_chr(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst)
247 {
248     desc->src = src;
249     desc->dst = dst;
250     desc->alpha = 0;
251     desc->instance = NULL;
252     desc->process = &no_chr_scale;
253     return 0;
254 }