/*
 * Copyright 2008, Andrej Spielmann <andrej.spielmann@seh.ox.ac.uk>.
 * Copyright 2008, Stephan Aßmus <superstippi@gmx.de>.
 * All rights reserved. Distributed under the terms of the MIT License.
 *
 * Copyright 2002-2004 Maxim Shemanarev (http://www.antigrain.com)
 *
 *
 * Class scanline_p8_subpix_avrg_filtering, a slightly modified version of
 * scanline_p8 customized to store 3 covers per pixel and to implement
 * average-based color filtering
 *
 */

#ifndef AGG_SCANLINE_P_SUBPIX_AVRG_FILTERING_INCLUDED
#define AGG_SCANLINE_P_SUBPIX_AVRG_FILTERING_INCLUDED

#include "GlobalSubpixelSettings.h"

namespace agg
{       
        //========================================scanline_p8_subpix_avrg_filtering
        // 
        // This is a general purpose scaline container which supports the interface 
        // used in the rasterizer::render(). See description of scanline_u8
        // for details.
        // 
        //------------------------------------------------------------------------
        class scanline_p8_subpix_avrg_filtering
        {
        public:
                typedef scanline_p8_subpix      self_type;
                typedef int8u                           cover_type;
                typedef int16                           coord_type;

                //--------------------------------------------------------------------
                struct span
                {
                        coord_type                x;
                        coord_type                len; // If negative, it's a solid span, covers is valid
                        const cover_type* covers;
                };

                typedef span* iterator;
                typedef const span* const_iterator;

                scanline_p8_subpix_avrg_filtering() :
                        m_last_x(0x7FFFFFF0),
                        m_covers(),
                        m_cover_ptr(0),
                        m_spans(),
                        m_cur_span(0)
                {
                }

                //--------------------------------------------------------------------
                void reset(int min_x, int max_x)
                {
                        unsigned max_len = 3*(max_x - min_x + 3);
                        if(max_len > m_spans.size())
                        {
                                m_spans.resize(max_len);
                                m_covers.resize(max_len);
                        }
                        m_last_x        = 0x7FFFFFF0;
                        m_cover_ptr = &m_covers[0];
                        m_cur_span      = &m_spans[0];
                        m_cur_span->len = 0;
                }

                //--------------------------------------------------------------------
                void add_cell(int x, unsigned cover1, unsigned cover2, unsigned cover3)
                {
                
                // NOTE stippi: My basic idea is that filtering tries to minimize colored
                // edges, but it does so by blurring the coverage values. This will also
                // affect neighboring pixels and add blur where there were perfectly sharp
                // edges. Andrej's method of filtering adds a special case for perfectly
                // sharp edges, but the drawback here is that there will be a visible
                // transition between blurred and non-blurred subpixels. I had the idea that
                // when simply fading the subpixels towards the plain gray-scale-aa values,
                // there must be a sweet spot for when colored edges become non-disturbing
                // and there is still a benefit of sharpness compared to straight gray-scale-
                // aa. The define above enables this method against the colored edges. My
                // method still has a drawback, since jaggies in diagonal lines will be more
                // visible again than with the filter method.

                        unsigned char averageWeight = gSubpixelAverageWeight;
                        unsigned char subpixelWeight = 255 - averageWeight;

                        unsigned int coverR;
                        unsigned int coverG;
                        unsigned int coverB;
                        
                        unsigned int average = (cover1 + cover2 + cover3 + 2) / 3;
                        
                        coverR = (cover1 * subpixelWeight + average * averageWeight) >> 8;
                        coverG = (cover2 * subpixelWeight + average * averageWeight) >> 8;
                        coverB = (cover3 * subpixelWeight + average * averageWeight) >> 8;
                
                        m_cover_ptr[0] = (cover_type)coverR;
                        m_cover_ptr[1] = (cover_type)coverG;
                        m_cover_ptr[2] = (cover_type)coverB;
                        if(x == m_last_x+1 && m_cur_span->len > 0)
                        {
                                m_cur_span->len += 3;
                        }
                        else
                        {
                                m_cur_span++;
                                m_cur_span->covers = m_cover_ptr;
                                m_cur_span->x = (int16)x;
                                m_cur_span->len = 3;
                        }
                        m_last_x = x;
                        m_cover_ptr += 3;
                }

                //--------------------------------------------------------------------
                void add_cells(int x, unsigned len, const cover_type* covers)
                {
                        memcpy(m_cover_ptr, covers, 3 * len * sizeof(cover_type));
                        if(x == m_last_x+1 && m_cur_span->len > 0)
                        {
                                m_cur_span->len += 3 * (int16)len;
                        }
                        else
                        {
                                m_cur_span++;
                                m_cur_span->covers = m_cover_ptr;
                                m_cur_span->x = (int16)x;
                                m_cur_span->len = 3 * (int16)len;
                        }
                        m_cover_ptr += 3 * len;
                        m_last_x = x + len - 1;
                }

                //--------------------------------------------------------------------
                void add_span(int x, unsigned len, unsigned cover)
                {
                        if(x == m_last_x+1 && 
                           m_cur_span->len < 0 && 
                           cover == *m_cur_span->covers)
                        {
                                m_cur_span->len -= 3 * (int16)len;
                        }
                        else
                        {
                                *m_cover_ptr = (cover_type)cover;
                                m_cur_span++;
                                m_cur_span->covers = m_cover_ptr;
                                m_cover_ptr += 3;
                                m_cur_span->x      = (int16)x;
                                m_cur_span->len    = 3 * (int16)(-int(len));
                        }
                        m_last_x = x + len - 1;
                }

                //--------------------------------------------------------------------
                void finalize(int y) 
                { 
                        m_y = y; 
                }

                //--------------------------------------------------------------------
                void reset_spans()
                {
                        m_last_x        = 0x7FFFFFF0;
                        m_cover_ptr = &m_covers[0];
                        m_cur_span      = &m_spans[0];
                        m_cur_span->len = 0;
                }

                //--------------------------------------------------------------------
                int                        y()             const { return m_y; }
                unsigned           num_spans() const { return unsigned(m_cur_span - &m_spans[0]); }
                const_iterator begin()     const { return &m_spans[1]; }

        private:
                scanline_p8_subpix_avrg_filtering(const self_type&);
                const self_type& operator = (const self_type&);

                int                                       m_last_x;
                int                                       m_y;
                pod_array<cover_type> m_covers;
                cover_type*                       m_cover_ptr;
                pod_array<span>           m_spans;
                span*                             m_cur_span;
        };

}


#endif