sitetran.cpp

linux下的一款播放器

/* ***** BEGIN LICENSE BLOCK *****
 * Source last modified: $Id: sitetran.cpp,v 1.2.40.1 2004/07/09 01:59:28 hubbe Exp $
 * 
 * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
 * 
 * The contents of this file, and the files included with this file,
 * are subject to the current version of the RealNetworks Public
 * Source License (the "RPSL") available at
 * http://www.helixcommunity.org/content/rpsl unless you have licensed
 * the file under the current version of the RealNetworks Community
 * Source License (the "RCSL") available at
 * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
 * will apply. You may also obtain the license terms directly from
 * RealNetworks.  You may not use this file except in compliance with
 * the RPSL or, if you have a valid RCSL with RealNetworks applicable
 * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
 * the rights, obligations and limitations governing use of the
 * contents of the file.
 * 
 * Alternatively, the contents of this file may be used under the
 * terms of the GNU General Public License Version 2 or later (the
 * "GPL") in which case the provisions of the GPL are applicable
 * instead of those above. If you wish to allow use of your version of
 * this file only under the terms of the GPL, and not to allow others
 * to use your version of this file under the terms of either the RPSL
 * or RCSL, indicate your decision by deleting the provisions above
 * and replace them with the notice and other provisions required by
 * the GPL. If you do not delete the provisions above, a recipient may
 * use your version of this file under the terms of any one of the
 * RPSL, the RCSL or the GPL.
 * 
 * This file is part of the Helix DNA Technology. RealNetworks is the
 * developer of the Original Code and owns the copyrights in the
 * portions it created.
 * 
 * This file, and the files included with this file, is distributed
 * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
 * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
 * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
 * ENJOYMENT OR NON-INFRINGEMENT.
 * 
 * Technology Compatibility Kit Test Suite(s) Location:
 *    http://www.helixcommunity.org/content/tck
 * 
 * Contributor(s):
 * 
 * ***** END LICENSE BLOCK ***** */

#define _TRANSITIONS_ON_
//#define _TESTING_TRANITIONS_   

#ifdef _TESTING_TRANITIONS_
#define INITGUID    // this must be befor pntypes
#endif

#include "hxtypes.h" // this must be before windows.h

#ifdef _WIN32
#include "windows.h"
#endif

#define PI 3.14159265358979323846
#define Root2 1.414213562

#include <math.h>
#include <stdio.h>
#include <stdlib.h>

//#define NO_GRAPHICS

#include "hxcom.h"
#include "hxbuffer.h"
#include "hxassert.h"
#include "sitetran.h"
#include "region.h"
#include "poly.h"
#include "tranmat.h"
#include "hxstrutl.h"




//=======================================================================
//=======================================================================
//               All Transistion effects
//=======================================================================
//=======================================================================

void CopyRegion(HXREGION* dstrgn, HXREGION* rgn)
{
   if (dstrgn != rgn) /*  don't want to copy to itself */
   {  
      if (dstrgn->size < rgn->numRects)
      {
         if (dstrgn->rects)
         {
            HXBOX *prevRects = dstrgn->rects;
                
            if (! (dstrgn->rects = (HXBOX *)
                   realloc((char *) dstrgn->rects,
                           (unsigned) rgn->numRects * (sizeof(HXBOX))))) {
               free(prevRects);
               return;
            }
         }
         dstrgn->size = rgn->numRects;
      }
      dstrgn->numRects = rgn->numRects;
      dstrgn->extents.x1 = rgn->extents.x1;
      dstrgn->extents.y1 = rgn->extents.y1;
      dstrgn->extents.x2 = rgn->extents.x2;
      dstrgn->extents.y2 = rgn->extents.y2;

      memcpy((char *) dstrgn->rects, (char *) rgn->rects, /* Flawfinder: ignore */
             (int) (rgn->numRects * sizeof(HXBOX)));
   }
}


HXREGION* InvertRGN(HXREGION* in, int x, int y, int x1, int y1)
{
   HXREGION* retRGN = HXCreateRectRegion(x,y,x1 - x,y1 - y);
   HXCombineRgn(retRGN, retRGN, in, HX_RGN_DIFF);
   HXDestroyRegion(in);
   return retRGN;
}

int CompareRects(const void *arg1, const void *arg2)
{
   HXBOX* b1 = (HXBOX*)arg1;
   HXBOX* b2 = (HXBOX*)arg2;

   if (b1->y1 < b2->y1) 
      return -1;

   if (b1->y1 != b2->y1)
      return 1;

   if (b1->x1 < b2->x1)
      return -1;

   if (b1->x1 != b2->x1)
      return 1;

   return 0;
}

HXREGION* MirrorHorizontal(HXREGION* in, int y)
{
   int tmpY;

   for (int i = 0; i < in->numRects; ++i)
   {
      in->rects[i].y1 = 2 * y - in->rects[i].y1;
      in->rects[i].y2 = 2 * y - in->rects[i].y2;
        
      if (in->rects[i].y2 < in->rects[i].y1)
      {
         tmpY = in->rects[i].y1;
         in->rects[i].y1 = in->rects[i].y2;
         in->rects[i].y2 = tmpY;
      }
   }

   qsort((void*)in->rects, in->numRects, sizeof(HXBOX), CompareRects);

   return in;
}

HXREGION* MirrorVertical(HXREGION* in, int x)
{
   int tmpX;

   for (int i = 0; i < in->numRects; ++i)
   {
      in->rects[i].x1 = 2 * x - in->rects[i].x1;
      in->rects[i].x2 = 2 * x - in->rects[i].x2;
        
      if (in->rects[i].x2 < in->rects[i].x1)
      {
         tmpX = in->rects[i].x1;
         in->rects[i].x1 = in->rects[i].x2;
         in->rects[i].x2 = tmpX;
      }
      if( in->rects[i].x1 != 0 )
          in->rects[i].x1 = in->rects[i].x1 -1;
   }

   qsort((void*)in->rects, in->numRects, sizeof(HXBOX), CompareRects);

   return in;
}

void MirrorHorizontal(tranLines* lines, int y)
{
   for (int i = 0; i < lines->m_nLines; ++i)
   {
      lines->m_pLines[i].start.x = lines->m_pLines[i].start.x;
      lines->m_pLines[i].start.y = 2 * y - lines->m_pLines[i].start.y;
      lines->m_pLines[i].finish.x = lines->m_pLines[i].finish.x;
      lines->m_pLines[i].finish.y = 2 * y - lines->m_pLines[i].finish.y;
   }
}

void MirrorVertical(tranLines* lines, int x)
{
   for (int i = 0; i < lines->m_nLines; ++i)
   {
      lines->m_pLines[i].start.x = 2 * x - lines->m_pLines[i].start.x;
      lines->m_pLines[i].start.y = lines->m_pLines[i].start.y;
      lines->m_pLines[i].finish.x = 2 * x - lines->m_pLines[i].finish.x;
      lines->m_pLines[i].finish.y = lines->m_pLines[i].finish.y;
   }
}

tranLines::tranLines()
{
   m_nLines = 0;
   m_pLines = NULL;
}

tranLines::~tranLines()
{
   Destroy();
}


LineSegment::LineSegment(const LineSegment& ls)
{
   *this = ls;
}

void LineSegment::operator=(const LineSegment& right)
{
   start.x = right.start.x;
   start.y = right.start.y;
   finish.x = right.finish.x;
   finish.y = right.finish.y;
}

// returns TRUE if the line is within the boundary, FALSE if it lies completely outside
BOOL LineSegment::Clip(int left, int top, int right, int bottom)
{
   BOOL retVal = TRUE;
   double slope;

   // make sure our start is left of finish
   if (start.x > finish.x)
   {
      int tmp = start.x;
      start.x = finish.x;
      finish.x = tmp;

      tmp = start.y;
      start.y = finish.y;
      finish.y = tmp;
   }

   if (start.x > right || finish.x < left ||
       (start.y < top && finish.y < top) ||
       (start.y > bottom && finish.y > bottom))
   {
      retVal = FALSE;
      goto LineSegment_Clip_End;
   }

   slope = ((double)(finish.y - start.y + 1) / (double)(finish.x - start.x + 1));

   if (start.x < left)
   {
      start.y += int((left - start.x) * slope);
      start.x = left;
   }
   if (start.y > bottom)
   {
      start.x -= int((start.y - bottom) / slope);
      start.y = bottom;
   }
   if(start.y < top)
   {
      start.x += int((top - start.y) / slope);
      start.y = top;
   }

   if (finish.x > right)
   {
      finish.y -= int((finish.x - right) * slope);
      finish.x = right;
   }
   if (finish.y > bottom)
   {
      finish.x -= int((finish.y - bottom) / slope);
      finish.y = bottom;
   }
   if(finish.y < top)
   {
      finish.x += int((top - finish.y) / slope);
      finish.y = top;
   }

   if (start.x < left || start.x > right ||
       start.y < top || start.y > bottom ||
       finish.x < left || finish.x > right || 
       finish.y < top || finish.y > bottom)
   {
      //XXXSMJ currently there's a case were the line can exist with only
      // an endpoint on border.  This means only one pixel of the line is
      // inside the clipping region.  For now, we'll say this sucker is
      // clipped.
      retVal = FALSE;
   }

  LineSegment_Clip_End:
   return retVal;
}

tranLines* operator+(const tranLines& left, const tranLines& right)
{
   tranLines* newLines = const_cast<tranLines*>(&left);
    
   if (right.m_nLines)
   {
      newLines = new tranLines;
    
      newLines->m_nLines = left.m_nLines + right.m_nLines;
      newLines->m_pLines = new LineSegment[newLines->m_nLines];
    
      if (!newLines->m_pLines)
      {
         newLines->m_nLines = 0;
      }
      else
      {
         int i,c;
         for (i = 0, c = 0; i < left.m_nLines; ++i, ++c)
         {
            newLines->m_pLines[c] = left.m_pLines[i];
         }
         for (i = 0; i < right.m_nLines; ++i, ++c)
         {
            newLines->m_pLines[c] = right.m_pLines[i];
         }
      }
   }
   return newLines;
}

void tranLines::operator=(const tranLines& right)
{
   Copy(right);
}

void tranLines::operator+=(const tranLines& right)
{
   if (right.m_nLines)
   {
      tranLines* newLines = *this + right;
      Copy(*newLines);
    
      delete newLines;
   }
}

void tranLines::operator+=(const LineSegment& right)
{
   tranLines newLines;
    
   newLines.m_nLines = 1;
   newLines.m_pLines = new LineSegment[1];
    
   if (!newLines.m_pLines)
   {
      newLines.m_nLines = 0;
   }
   else
   {
      *newLines.m_pLines = right;
   }

   *this += newLines;
}

tranLines::tranLines(const tranLines& tl)
{
   m_nLines = 0;
   m_pLines = NULL;

   Copy(tl);
}

void tranLines::Copy(const tranLines& tl)
{
   Destroy();

   m_nLines = tl.m_nLines;

   if (m_nLines)
   {
      m_pLines = new LineSegment[m_nLines];

      for (int i = 0; i < m_nLines; ++i)