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