git.sesse.net Git - ffmpeg/blob - 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 }