/*
  * Copyright (C) 2015 Pedro Arthur <bygrandao@gmail.com>
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * FFmpeg is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 

 #include "swscale_internal.h"
 

 /// Scaler instance data
 typedef struct FilterContext
 {
     uint16_t *filter;
     int *filter_pos;
     int filter_size;
     int xInc;
 } FilterContext;
 
 /// Color conversion instance data
 typedef struct ColorContext
 {
     uint32_t *pal;
 } ColorContext;
 

 static int lum_h_scale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
 {
     FilterContext *instance = desc->instance;
     int srcW = desc->src->width;
     int dstW = desc->dst->width;
     int xInc = instance->xInc;
 
     int i;
     for (i = 0; i < sliceH; ++i) {
         uint8_t ** src = desc->src->plane[0].line;
         uint8_t ** dst = desc->dst->plane[0].line;
         int src_pos = sliceY+i - desc->src->plane[0].sliceY;
         int dst_pos = sliceY+i - desc->dst->plane[0].sliceY;
 
 
         if (c->hyscale_fast) {
             c->hyscale_fast(c, (int16_t*)dst[dst_pos], dstW, src[src_pos], srcW, xInc);
         } else {
             c->hyScale(c, (int16_t*)dst[dst_pos], dstW, (const uint8_t *)src[src_pos], instance->filter,
                        instance->filter_pos, instance->filter_size);
         }
 
         if (c->lumConvertRange)
             c->lumConvertRange((int16_t*)dst[dst_pos], dstW);
 
         desc->dst->plane[0].sliceH += 1;
 
         if (desc->alpha) {
             src = desc->src->plane[3].line;
             dst = desc->dst->plane[3].line;
 
             src_pos = sliceY+i - desc->src->plane[3].sliceY;
             dst_pos = sliceY+i - desc->dst->plane[3].sliceY;
 
             desc->dst->plane[3].sliceH += 1;
 
             if (c->hyscale_fast) {
                 c->hyscale_fast(c, (int16_t*)dst[dst_pos], dstW, src[src_pos], srcW, xInc);
             } else {
                 c->hyScale(c, (int16_t*)dst[dst_pos], dstW, (const uint8_t *)src[src_pos], instance->filter,
                             instance->filter_pos, instance->filter_size);
             }
         }
     }
 
     return sliceH;
 }
 
 static int lum_convert(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
 {
     int srcW = desc->src->width;
     ColorContext * instance = desc->instance;
     uint32_t * pal = instance->pal;
     int i;
 
     desc->dst->plane[0].sliceY = sliceY;
     desc->dst->plane[0].sliceH = sliceH;
     desc->dst->plane[3].sliceY = sliceY;
     desc->dst->plane[3].sliceH = sliceH;
 
     for (i = 0; i < sliceH; ++i) {
         int sp0 = sliceY+i - desc->src->plane[0].sliceY;
         int sp1 = ((sliceY+i) >> desc->src->v_chr_sub_sample) - desc->src->plane[1].sliceY;
         const uint8_t * src[4] = { desc->src->plane[0].line[sp0],
                         desc->src->plane[1].line[sp1],
                         desc->src->plane[2].line[sp1],
                         desc->src->plane[3].line[sp0]};
         uint8_t * dst = desc->dst->plane[0].line[i];
 
         if (c->lumToYV12) {
             c->lumToYV12(dst, src[0], src[1], src[2], srcW, pal);
         } else if (c->readLumPlanar) {
             c->readLumPlanar(dst, src, srcW, c->input_rgb2yuv_table);
         }
 
 
         if (desc->alpha) {
             dst = desc->dst->plane[3].line[i];
             if (c->alpToYV12) {
                 c->alpToYV12(dst, src[3], src[1], src[2], srcW, pal);
             } else if (c->readAlpPlanar) {
                 c->readAlpPlanar(dst, src, srcW, NULL);
             }
         }
     }
 
     return sliceH;
 }
 
 int ff_init_desc_fmt_convert(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst, uint32_t *pal)
 {
     ColorContext * li = av_malloc(sizeof(ColorContext));
     if (!li)
         return AVERROR(ENOMEM);
     li->pal = pal;
     desc->instance = li;
 
     desc->alpha = isALPHA(src->fmt) && isALPHA(dst->fmt);
     desc->src =src;
     desc->dst = dst;
     desc->process = &lum_convert;
 
     return 0;
 }
 
 
 int ff_init_desc_hscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc)
 {
     FilterContext *li = av_malloc(sizeof(FilterContext));
     if (!li)
         return AVERROR(ENOMEM);
 
     li->filter = filter;
     li->filter_pos = filter_pos;
     li->filter_size = filter_size;
     li->xInc = xInc;
 
     desc->instance = li;
 
     desc->alpha = isALPHA(src->fmt) && isALPHA(dst->fmt);
     desc->src = src;
     desc->dst = dst;
 
     desc->process = &lum_h_scale;
 
     return 0;
 }
 
 static int chr_h_scale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
 {
     FilterContext *instance = desc->instance;

     int srcW = AV_CEIL_RSHIFT(desc->src->width, desc->src->h_chr_sub_sample);
     int dstW = AV_CEIL_RSHIFT(desc->dst->width, desc->dst->h_chr_sub_sample);

     int xInc = instance->xInc;
 
     uint8_t ** src1 = desc->src->plane[1].line;
     uint8_t ** dst1 = desc->dst->plane[1].line;
     uint8_t ** src2 = desc->src->plane[2].line;
     uint8_t ** dst2 = desc->dst->plane[2].line;
 
     int src_pos1 = sliceY - desc->src->plane[1].sliceY;
     int dst_pos1 = sliceY - desc->dst->plane[1].sliceY;
 
     int src_pos2 = sliceY - desc->src->plane[2].sliceY;
     int dst_pos2 = sliceY - desc->dst->plane[2].sliceY;
 
     int i;
     for (i = 0; i < sliceH; ++i) {
         if (c->hcscale_fast) {
             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);
         } else {
             c->hcScale(c, (uint16_t*)dst1[dst_pos1+i], dstW, src1[src_pos1+i], instance->filter, instance->filter_pos, instance->filter_size);
             c->hcScale(c, (uint16_t*)dst2[dst_pos2+i], dstW, src2[src_pos2+i], instance->filter, instance->filter_pos, instance->filter_size);
         }
 
         if (c->chrConvertRange)
             c->chrConvertRange((uint16_t*)dst1[dst_pos1+i], (uint16_t*)dst2[dst_pos2+i], dstW);
 
         desc->dst->plane[1].sliceH += 1;
         desc->dst->plane[2].sliceH += 1;
     }
     return sliceH;
 }
 
 static int chr_convert(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
 {

     int srcW = AV_CEIL_RSHIFT(desc->src->width, desc->src->h_chr_sub_sample);

     ColorContext * instance = desc->instance;
     uint32_t * pal = instance->pal;
 
     int sp0 = (sliceY - (desc->src->plane[0].sliceY >> desc->src->v_chr_sub_sample)) << desc->src->v_chr_sub_sample;
     int sp1 = sliceY - desc->src->plane[1].sliceY;
 
     int i;
 
     desc->dst->plane[1].sliceY = sliceY;
     desc->dst->plane[1].sliceH = sliceH;
     desc->dst->plane[2].sliceY = sliceY;
     desc->dst->plane[2].sliceH = sliceH;
 
     for (i = 0; i < sliceH; ++i) {
         const uint8_t * src[4] = { desc->src->plane[0].line[sp0+i],
                         desc->src->plane[1].line[sp1+i],
                         desc->src->plane[2].line[sp1+i],
                         desc->src->plane[3].line[sp0+i]};
 
         uint8_t * dst1 = desc->dst->plane[1].line[i];
         uint8_t * dst2 = desc->dst->plane[2].line[i];
         if (c->chrToYV12) {
             c->chrToYV12(dst1, dst2, src[0], src[1], src[2], srcW, pal);
         } else if (c->readChrPlanar) {
             c->readChrPlanar(dst1, dst2, src, srcW, c->input_rgb2yuv_table);
         }
     }
     return sliceH;
 }
 
 int ff_init_desc_cfmt_convert(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst, uint32_t *pal)
 {
     ColorContext * li = av_malloc(sizeof(ColorContext));
     if (!li)
         return AVERROR(ENOMEM);
     li->pal = pal;
     desc->instance = li;
 
     desc->src =src;
     desc->dst = dst;
     desc->process = &chr_convert;
 
     return 0;
 }
 
 int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc)
 {
     FilterContext *li = av_malloc(sizeof(FilterContext));
     if (!li)
         return AVERROR(ENOMEM);
 
     li->filter = filter;
     li->filter_pos = filter_pos;
     li->filter_size = filter_size;
     li->xInc = xInc;
 
     desc->instance = li;
 
     desc->alpha = isALPHA(src->fmt) && isALPHA(dst->fmt);
     desc->src = src;
     desc->dst = dst;
 
     desc->process = &chr_h_scale;
 
     return 0;
 }
 
 static int no_chr_scale(SwsContext *c, SwsFilterDescriptor *desc, int sliceY, int sliceH)
 {
     desc->dst->plane[1].sliceY = sliceY + sliceH - desc->dst->plane[1].available_lines;
     desc->dst->plane[1].sliceH = desc->dst->plane[1].available_lines;
     desc->dst->plane[2].sliceY = sliceY + sliceH - desc->dst->plane[2].available_lines;
     desc->dst->plane[2].sliceH = desc->dst->plane[2].available_lines;
     return 0;
 }
 
 int ff_init_desc_no_chr(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst)
 {
     desc->src = src;
     desc->dst = dst;
     desc->alpha = 0;
     desc->instance = NULL;
     desc->process = &no_chr_scale;
     return 0;
 }