#include <ft2build.h>

#include FT_INTERNAL_DEBUG_H

#include FT_BBOX_H

#include FT_IMAGE_H

#include FT_OUTLINE_H

#include FT_INTERNAL_CALC_H

#include FT_INTERNAL_OBJECTS_H

  typedef struct  TBBox_Rec_

  {

    FT_Vector  last;

    FT_BBox    bbox;

  } TBBox_Rec;

#define FT_UPDATE_BBOX( p, bbox ) \

  FT_BEGIN_STMNT                  \

    if ( p->x < bbox.xMin )       \

      bbox.xMin = p->x;           \

    if ( p->x > bbox.xMax )       \

      bbox.xMax = p->x;           \

    if ( p->y < bbox.yMin )       \

      bbox.yMin = p->y;           \

    if ( p->y > bbox.yMax )       \

      bbox.yMax = p->y;           \

  FT_END_STMNT

#define CHECK_X( p, bbox )                         \

          ( p->x < bbox.xMin || p->x > bbox.xMax )

#define CHECK_Y( p, bbox )                         \

          ( p->y < bbox.yMin || p->y > bbox.yMax )

  static int

  BBox_Move_To( FT_Vector*  to,

                TBBox_Rec*  user )

  {

    FT_UPDATE_BBOX( to, user->bbox );

    user->last = *to;

    return 0;

  }

  static int

  BBox_Line_To( FT_Vector*  to,

                TBBox_Rec*  user )

  {

    user->last = *to;

    return 0;

  }

  static void

  BBox_Conic_Check( FT_Pos   y1,

                    FT_Pos   y2,

                    FT_Pos   y3,

                    FT_Pos*  min,

                    FT_Pos*  max )

  {

    /* This function is only called when a control off-point is outside */

    /* the bbox that contains all on-points.  It finds a local extremum */

    /* within the segment, equal to (y1*y3 - y2*y2)/(y1 - 2*y2 + y3).   */

    /* Or, offsetting from y2, we get                                   */

    y1 -= y2;

    y3 -= y2;

    y2 += FT_MulDiv( y1, y3, y1 + y3 );

    if ( y2 < *min )

      *min = y2;

    if ( y2 > *max )

      *max = y2;

  }

  static int

  BBox_Conic_To( FT_Vector*  control,

                 FT_Vector*  to,

                 TBBox_Rec*  user )

  {

    /* in case `to' is implicit and not included in bbox yet */

    FT_UPDATE_BBOX( to, user->bbox );

    if ( CHECK_X( control, user->bbox ) )

      BBox_Conic_Check( user->last.x,

                        control->x,

                        to->x,

                        &user->bbox.xMin,

                        &user->bbox.xMax );

    if ( CHECK_Y( control, user->bbox ) )

      BBox_Conic_Check( user->last.y,

                        control->y,

                        to->y,

                        &user->bbox.yMin,

                        &user->bbox.yMax );

    user->last = *to;

    return 0;

  }

  static FT_Pos

  cubic_peak( FT_Pos  q1,

              FT_Pos  q2,

              FT_Pos  q3,

              FT_Pos  q4 )

  {

    FT_Pos  peak = 0;

    FT_Int  shift;

    /* This function finds a peak of a cubic segment if it is above 0    */

    /* using iterative bisection of the segment, or returns 0.           */

    /* The fixed-point arithmetic of bisection is inherently stable      */

    /* but may loose accuracy in the two lowest bits.  To compensate,    */

    /* we upscale the segment if there is room.  Large values may need   */

    /* to be downscaled to avoid overflows during bisection.             */

    /* It is called with either q2 or q3 positive, which is necessary    */

    /* for the peak to exist and avoids undefined FT_MSB.                */

    shift = 27 - FT_MSB( (FT_UInt32)( FT_ABS( q1 ) |

                                      FT_ABS( q2 ) |

                                      FT_ABS( q3 ) |

                                      FT_ABS( q4 ) ) );

    if ( shift > 0 )

    {

      /* upscaling too much just wastes time */

      if ( shift > 2 )

        shift = 2;

      q1 <<=  shift;

      q2 <<=  shift;

      q3 <<=  shift;

      q4 <<=  shift;

    }

    else

    {

      q1 >>= -shift;

      q2 >>= -shift;

      q3 >>= -shift;

      q4 >>= -shift;

    }

    /* for a peak to exist above 0, the cubic segment must have */

    /* at least one of its control off-points above 0.          */

    while ( q2 > 0 || q3 > 0 )

    {

      /* determine which half contains the maximum and split */

      if ( q1 + q2 > q3 + q4 ) /* first half */

      {

        q4 = q4 + q3;

        q3 = q3 + q2;

        q2 = q2 + q1;

        q4 = q4 + q3;

        q3 = q3 + q2;

        q4 = ( q4 + q3 ) / 8;

        q3 = q3 / 4;

        q2 = q2 / 2;

      }

      else                     /* second half */

      {

        q1 = q1 + q2;

        q2 = q2 + q3;

        q3 = q3 + q4;

        q1 = q1 + q2;

        q2 = q2 + q3;

        q1 = ( q1 + q2 ) / 8;

        q2 = q2 / 4;

        q3 = q3 / 2;

      }

      /* check whether either end reached the maximum */

      if ( q1 == q2 && q1 >= q3 )

      {

        peak = q1;

        break;

      }

      if ( q3 == q4 && q2 <= q4 )

      {

        peak = q4;

        break;

      }

    }

    if ( shift > 0 )

      peak >>=  shift;

    else

      peak <<= -shift;

    return peak;

  }

  static void

  BBox_Cubic_Check( FT_Pos   p1,

                    FT_Pos   p2,

                    FT_Pos   p3,

                    FT_Pos   p4,

                    FT_Pos*  min,

                    FT_Pos*  max )

  {

    /* This function is only called when a control off-point is outside  */

    /* the bbox that contains all on-points.  So at least one of the     */

    /* conditions below holds and cubic_peak is called with at least one */

    /* non-zero argument.                                                */

    if ( p2 > *max || p3 > *max )

      *max += cubic_peak( p1 - *max, p2 - *max, p3 - *max, p4 - *max );

    /* now flip the signs to update the minimum */

    if ( p2 < *min || p3 < *min )

      *min -= cubic_peak( *min - p1, *min - p2, *min - p3, *min - p4 );

  }

  static int

  BBox_Cubic_To( FT_Vector*  control1,

                 FT_Vector*  control2,

                 FT_Vector*  to,

                 TBBox_Rec*  user )

  {

    /* We don't need to check `to' since it is always an on-point,    */

    /* thus within the bbox.  Only segments with an off-point outside */

    /* the bbox can possibly reach new extreme values.                */

    if ( CHECK_X( control1, user->bbox ) ||

         CHECK_X( control2, user->bbox ) )

      BBox_Cubic_Check( user->last.x,

                        control1->x,

                        control2->x,

                        to->x,

                        &user->bbox.xMin,

                        &user->bbox.xMax );

    if ( CHECK_Y( control1, user->bbox ) ||

         CHECK_Y( control2, user->bbox ) )

      BBox_Cubic_Check( user->last.y,

                        control1->y,

                        control2->y,

                        to->y,

                        &user->bbox.yMin,

                        &user->bbox.yMax );

    user->last = *to;

    return 0;

  }

  FT_DEFINE_OUTLINE_FUNCS(

    bbox_interface,

    (FT_Outline_MoveTo_Func) BBox_Move_To,   /* move_to  */

    (FT_Outline_LineTo_Func) BBox_Line_To,   /* line_to  */

    (FT_Outline_ConicTo_Func)BBox_Conic_To,  /* conic_to */

    (FT_Outline_CubicTo_Func)BBox_Cubic_To,  /* cubic_to */

    0,                                       /* shift    */

    0                                        /* delta    */

  )

  /* documentation is in ftbbox.h */

  FT_EXPORT_DEF( FT_Error )

  FT_Outline_Get_BBox( FT_Outline*  outline,

                       FT_BBox     *abbox )

  {

    FT_BBox     cbox = {  0x7FFFFFFFL,  0x7FFFFFFFL,

                         -0x7FFFFFFFL, -0x7FFFFFFFL };

    FT_BBox     bbox = {  0x7FFFFFFFL,  0x7FFFFFFFL,

                         -0x7FFFFFFFL, -0x7FFFFFFFL };

    FT_Vector*  vec;

    FT_UShort   n;

    if ( !abbox )

      return FT_THROW( Invalid_Argument );

    if ( !outline )

      return FT_THROW( Invalid_Outline );

    /* if outline is empty, return (0,0,0,0) */

    if ( outline->n_points == 0 || outline->n_contours <= 0 )

    {

      abbox->xMin = abbox->xMax = 0;

      abbox->yMin = abbox->yMax = 0;

      return 0;

    }

    /* We compute the control box as well as the bounding box of  */

    /* all `on' points in the outline.  Then, if the two boxes    */

    /* coincide, we exit immediately.                             */

    vec = outline->points;

    for ( n = 0; n < outline->n_points; n++ )

    {

      FT_UPDATE_BBOX( vec, cbox );

      if ( FT_CURVE_TAG( outline->tags[n] ) == FT_CURVE_TAG_ON )

        FT_UPDATE_BBOX( vec, bbox );

      vec++;

    }

    /* test two boxes for equality */

    if ( cbox.xMin < bbox.xMin || cbox.xMax > bbox.xMax ||

         cbox.yMin < bbox.yMin || cbox.yMax > bbox.yMax )

    {

      /* the two boxes are different, now walk over the outline to */

      /* get the Bezier arc extrema.                               */

      FT_Error   error;

      TBBox_Rec  user;