tresizeaspectsettings.cpp

从FFMPEG转换而来的H264解码程序,VC下编译..

    }
   strcat(tipS,_l(" "));
   switch (mode)
    {
     case 0:
      strcatf(tipS,_l("to size %ix%i"),dx,dy);
      break;
     case 1:
      strcatf(tipS,_l("to aspect ratio %i:%i"),a1,a2);
      break;
     case 2:
      strcatf(tipS,_l("to next multiply of %i"),multOf);
      break;
     case 3:
      strcatf(tipS,_l("by %g"),mult1000/1000.0f);
      break;
     case 4:
      strcatf(tipS,_l("to horizontal size %i,vertical size=auto"),dx);
      break;
    }
   strcat(tipS,_l("\nAspect ratio: "));
   switch (isAspect)
    {
     case 0:
      strcat(tipS,_l("no change"));
      break;
     case 1:
      strcat(tipS,_l("keeping original aspect ratio"));
      break;
     case 2:
      strcatf(tipS,_l("set to %3.2f:1"),aspectRatio/65536.0f);
      break;
    }
   strncpy(buf,tipS,len);
   buf[len-1]='\0';
  }
 else if (pageId==2)
  {
   if (areBorders())
    tsnprintf(buf,len,_l("%s borders %i%s,%i%s"),bordersInside?_l("Inside"):_l("Outside"),bordersUnits==0?bordersPercentX:bordersPixelsX,bordersUnits==0?_l("%"):_l(" pixels"),bordersUnits==0?bordersPercentY:bordersPixelsY,bordersUnits==0?_l("%"):_l(" pixels"));
   else
    tsnprintf(buf,len,_l("No borders"));
   buf[len-1]='\0';
  }
 else if (pageId==3)
  {
   if (methodsProps[methodLuma].library==LIB_SWSCALER)
    {
     if (methodLuma==methodChroma || methodsLocked)
      {
       char_t algParam[256];
       tsnprintf(buf,len,_l("Method: %s%s\n"),methodsProps[methodLuma].name,printSwsParams(algParam,methodLuma,bicubicLumaParam,gaussLumaParam,lanczosLumaParam));
      }
     else
      {
       char_t algParam[256];
       tsnprintf(buf,len,_l("Luma method: %s%s\n"),methodsProps[methodLuma].name,printSwsParams(algParam,methodLuma,bicubicLumaParam,gaussLumaParam,lanczosLumaParam));
       strncatf(buf,len,_l("Chroma method: %s%s\n"),methodsProps[methodChroma].name,printSwsParams(algParam,methodChroma,bicubicChromaParam,gaussChromaParam,lanczosChromaParam));
      }
     strncatf(buf,len,_l("Luma gaussian blur:%3.2f, luma sharpen:%3.2f\nChroma gaussian blur:%3.2f, chroma sharpen:%3.2f"),GblurLum/100.0f,sharpenLum/100.0f,GblurChrom/100.0f,sharpenChrom/100.0f);
    }
   else if (methodsProps[methodLuma].library==LIB_SIMPLE)
    {
     tsnprintf(buf,len,_l("Method: %s"),methodsProps[methodLuma].name);
     if (methodLuma==METHOD_WARPED)
      strncatf(buf,len,_l(", horizontal warp: %-5.3f, vertical warp: %-5.3f"),simpleWarpXparam/1000.0f,simpleWarpYparam/1000.0f);
    }
   else
    tsnprintf(buf,len,_l("Method: %s"),methodsProps[methodLuma].name);
   buf[len-1]='\0';
  }
 return true;
}
const char_t* TresizeAspectSettings::getXcondStr(int cond)
{
 switch (cond)
  {
   case -1:return _l("<");
   case  1:return _l(">");
   default:return _l("=");
  }
}
const char_t* TresizeAspectSettings::getXYcondStr(int cond)
{
 switch (cond)
  {
   case 0 :return _l("and");
   case 1 :return _l("or");
   default:return _l("");
  }
}
const char_t* TresizeAspectSettings::getPixCondStr(int cond)
{
 switch (cond)
  {
   case -1:return _l("less than");
   case  1:return _l("greater than");
   default:return _l("");
  }
}

bool TresizeAspectSettings::ifResize(unsigned int AVIdx,unsigned int AVIdy) const
{
 switch (_if)
  {
   case 0:
    return true;
   case 1:
    {
     bool isX=(xcond==-1 && AVIdx<xval) || (xcond==1 && AVIdx>xval);
     bool isY=(ycond==-1 && AVIdy<yval) || (ycond==1 && AVIdy>yval);
     return (xycond==0 && (isX && isY)) || (xycond==1 && (isX || isY));
    }
   case 2:
    {
     unsigned int pixnum=AVIdx*AVIdy;
     return (pixcond==-1 && pixnum<pixval) || (pixcond==1 && pixnum>pixval);
    }
   default:return true;
  }
}

void TresizeAspectSettings::calcNewRects(Trect *rectFull,Trect *rectClip) const
{ //TODO: fix this mess!
 const Trect inRect=*(full?rectFull:rectClip);

/*****************  resize  *****************/
 if (is && ifResize(inRect.dx,inRect.dy))
  if (methodsProps[methodLuma].library==LIB_SAI)
   {
    rectFull->dx*=2;rectFull->dy*=2;
    rectClip->x *=2;rectClip->y *=2;
    rectClip->dx*=2;rectClip->dy*=2;
    //return;
   }
  else
   {
    if (SARinternally)
     {
      rectFull->sar.num=1;
      rectFull->sar.den=1;
     }
    switch (mode)
     {
      case 1: // Specify aspect ratio
       Trect::calcNewSizeAspect(inRect,a1,a2,*rectFull);
       break;
      case 2: // Expand to next multiply of
       rectFull->dx=(1+(inRect.dx-1)/multOf)*multOf;
       rectFull->dy=(1+(inRect.dy-1)/multOf)*multOf;
       break;
      case 3: // Multiply by
       rectFull->dx=mult1000*inRect.dx/1000;
       rectFull->dy=mult1000*inRect.dy/1000;
       break;
      case 4: // Specify horizontal size
       rectFull->dx=dx;
       if (SARinternally)
        rectFull->dy=dx*inRect.dy/inRect.dx*inRect.sar.den/inRect.sar.num;
       else
        rectFull->dy=dx*inRect.dy/inRect.dx;
       break;
      case 0: // Specify horizontal and vertical size
      default:
       rectFull->dx=dx;
       rectFull->dy=dy;
       break;
     }
    rectFull->dx&=~1;rectFull->dy&=~1;
   }

/*****************  aspect  *****************/
 int ax=1,ay=1;
 if (methodsProps[methodLuma].library==LIB_NONE)
  {
   rectClip->dx=std::min(inRect.dx,rectFull->dx);
   rectClip->x=std::max(0,int(rectFull->dx-rectClip->dx)/2)&~1;
   rectClip->dy=std::min(inRect.dy,rectFull->dy);
   rectClip->y=std::max(0,int(rectFull->dy-rectClip->dy)/2)&~1;
  }
 else
  if (isAspect==0 || methodsProps[methodLuma].library==LIB_SAI) // No aspect ratio correction
   *rectClip=*rectFull;
  else
   {
    if (isAspect==1) // keep original aspect ratio
     {
      if(SARinternally && is)
       {
        ax=inRect.dx;
        ay=inRect.dy*inRect.sar.den/inRect.sar.num;
        rectClip->sar.num=1;rectClip->sar.den=1;
       }
      else
       {
        ax=inRect.dx;
        ay=inRect.dy;
       }
     }
    else // Manual: x.xx:1
     {
      ax=aspectRatio;
      ay=1<<16;
     }
    if (ax==0) ax=1;if (ay==0) ay=1;
    rectClip->dx=rectFull->dx;
    rectClip->dy=rectFull->dx*ay/ax;
    if (mode==4) rectFull->dy=rectClip->dy;
    if (rectClip->dy>rectFull->dy) // have to shrink horizontally
     {
      rectClip->dx=rectFull->dy*ax/ay;
      rectClip->dy=rectFull->dy;
     }
    unsigned int mask=isAspect==1?_UI32_MAX:~1;
    rectClip->dx&=mask;
    rectClip->dy&=mask;
    rectClip->x=((rectFull->dx-rectClip->dx)/2)&mask;
    rectClip->y=((rectFull->dy-rectClip->dy)/2)&mask;
   }

/*****************  borders  *****************/
  unsigned int borderX=0,borderY=0;
  if (bordersUnits==0) // Percent
   {
    borderX=std::max(64U,(bordersInside?rectClip:rectFull)->dx*(100+(bordersInside?-1:1)*bordersPercentX)/100);
    borderY=std::max(24U,(bordersInside?rectClip:rectFull)->dy*(100+(bordersInside?-1:1)*bordersPercentY)/100);
   }
  else if (bordersUnits==1) // Pixels
   {
    borderX=std::max(64,int(rectClip->dx+(bordersInside?-2:2)*bordersPixelsX));
    borderY=std::max(24,int(rectClip->dy+(bordersInside?-2:2)*(bordersLocked?rectClip->dy*bordersPixelsY/rectClip->dx:bordersPixelsY)));
   }
  if (borderX || borderY)
   {
    if (bordersInside)
     {
      if (isAspect>=1)
       {
        unsigned int bdy=borderX*ay/ax;
        if (bdy<=borderY)
         {
          rectClip->dx=borderX&~1;
          rectClip->dy=bdy&~1;
         }
        else
         {
          rectClip->dx=borderY*ax/ay;
          rectClip->dy=borderY&~1;
         }
       }
      else
       {
        rectClip->dx=borderX&~1;
        rectClip->dy=borderY&~1;
       }
     }
    else
     {
      rectFull->dx=borderX&~1;
      rectFull->dy=borderY&~1;
     }
    if (rectClip->dx>rectFull->dx) rectClip->dx=rectFull->dx;
    if (rectClip->dy>rectFull->dy) rectClip->dy=rectFull->dy;
    rectClip->x=((rectFull->dx-rectClip->dx)/2)&~1;
    rectClip->y=((rectFull->dy-rectClip->dy)/2)&~1;
   }

/*****************  finish  *****************/
  if (rectClip->dx>rectFull->dx) rectClip->dx=rectFull->dx;
  if (rectClip->dy>rectFull->dy) rectClip->dy=rectFull->dy;
  if (rectClip->dx<64) rectClip->dx=64;
  if (rectClip->dy<24) rectClip->dy=24;
  if (rectFull->dx<64) rectFull->dx=64;
  if (rectFull->dy<24) rectFull->dy=24;
  rectClip->dx=rectClip->dx&~1;
  rectClip->dy=rectClip->dy&~1;
  rectFull->dx=rectFull->dx&~1;
  rectFull->dy=rectFull->dy&~1;
}

void TresizeAspectSettings::reg_op(TregOp &t)
{
 if (specifyHolizontalSizeOnly && mode==4) // for downgrade compatibility. (before save. This is executed before load too. No problem)
  mode=0;
 TfilterSettingsVideo::reg_op(t);
 dy=dyReg;
 if (specifyHolizontalSizeOnly && mode==0) // after load (Of course, this is executed after save. Can be igrored.)
  mode=4;
 else
  if (mode==4) mode=0;
 if (methodLuma==METHOD_SWS_BICUBLIN)
  {
   methodLuma=METHOD_SWS_BICUBIC,
   methodChroma=METHOD_SWS_BILINEAR;
   methodsLocked=0;
  }
 if (methodChroma==-1)
  {
   if (methodsProps[methodLuma].library==LIB_SWSCALER)
    methodChroma=methodLuma;
   else
    methodChroma=METHOD_SWS_BICUBIC;
   methodsLocked=1;
  }
 if (bicubicChromaParam==-1) bicubicChromaParam=bicubicLumaParam;
 if (gaussChromaParam==-1) gaussChromaParam=gaussLumaParam;
 if (lanczosChromaParam==-1) lanczosChromaParam=lanczosLumaParam;
}