//
// Writer
//
M4Err WriteOD(BitStream *bs, ObjectDescriptor *od)
{
M4Err e;
u32 size;
if (! od) return M4BadParam;
e = CalcSize((Descriptor *)od, &size);
if (e) return e;
e = writeBaseDescriptor(bs, od->tag, size);
if (e) return e;
BS_WriteInt(bs, od->objectDescriptorID, 10);
BS_WriteInt(bs, od->URLString != NULL ? 1 : 0, 1);
BS_WriteInt(bs, 31, 5); //reserved: 0b1111.1 == 31
if (od->URLString) {
OD_WriteString(bs, od->URLString, 1);
} else {
e = writeDescList(bs, od->ESDescriptors);
if (e) return e;
e = writeDescList(bs, od->OCIDescriptors);
if (e) return e;
e = writeDescList(bs, od->IPMPDescriptorPointers);
if (e) return e;
}
e = writeDescList(bs, od->extensionDescriptors);
return M4OK;
}
//
// Writer
//
M4Err WriteIOD(BitStream *bs, InitialObjectDescriptor *iod)
{
M4Err e;
u32 size;
if (! iod) return M4BadParam;
e = CalcSize((Descriptor *)iod, &size);
if (e) return e;
e = writeBaseDescriptor(bs, iod->tag, size);
if (e) return e;
BS_WriteInt(bs, iod->objectDescriptorID, 10);
BS_WriteInt(bs, iod->URLString != NULL ? 1 : 0, 1);
BS_WriteInt(bs, iod->inlineProfileFlag, 1);
BS_WriteInt(bs, 15, 4); //reserved: 0b1111 == 15
if (iod->URLString) {
OD_WriteString(bs, iod->URLString, 1);
} else {
BS_WriteInt(bs, iod->OD_profileAndLevel, 8);
BS_WriteInt(bs, iod->scene_profileAndLevel, 8);
BS_WriteInt(bs, iod->audio_profileAndLevel, 8);
BS_WriteInt(bs, iod->visual_profileAndLevel, 8);
BS_WriteInt(bs, iod->graphics_profileAndLevel, 8);
e = writeDescList(bs, iod->ESDescriptors);
if (e) return e;
e = writeDescList(bs, iod->OCIDescriptors);
if (e) return e;
e = writeDescList(bs, iod->IPMPDescriptorPointers);
if (e) return e;
}
e = writeDescList(bs, iod->extensionDescriptors);
return M4OK;
}
bool CDisAssm::GetInstructionInfo(const BYTE* pInstruction, InstrInfo& rInfo, int& riLen)
{
_ASSERTE(pInstruction);
_ASSERTE(m_aInstructions[*pInstruction].iOpCode == *pInstruction);
rInfo = m_aInstructions[*pInstruction];
// check the special ones
if (0xff == *pInstruction)
{
if (!GetInstructionInfoFF(rInfo, pInstruction))
return false;
}
/*else if (0x66 == *pInstruction)
{
m_b16BitOperand = true;
}
else if (0x67 == *pInstruction)
{
m_b16BitAddress = true;
}*/
_ASSERTE(rInfo.iOpSize); // undefined?
if (!rInfo.iOpSize)
return false;
riLen = CalcSize(rInfo, pInstruction);
return true;
}
void ToolTip::SetText(const char *text)
{
m_text = text;
if (m_layout) delete m_layout;
m_layout = new TextLayout(text);
CalcSize();
}
void Box::Layout()
{
if (m_children.size() == 0) return;
PreferredSize();
const Point boxSize = GetSize();
Point::Component vc, fc;
GetComponentsForOrient(m_orient == BOX_HORIZONTAL, vc, fc);
// fast path. we know the exact size that everything wants, so just
// loop and hand it out
if (m_numVariable == 0) {
Point childPos(0), childSize(0);
for (std::list<Child>::iterator i = m_children.begin(); i != m_children.end(); ++i) {
childSize[fc] = boxSize[fc];
childSize[vc] = (*i).contribSize[vc];
const Point actualSize(CalcSize((*i).widget, childSize));
SetWidgetDimensions((*i).widget, childPos, actualSize);
childPos[vc] += actualSize[vc] + m_spacing;
}
}
// we have one or more children that have requested the maximum size
// possible. each with a known size gets it, and any remaining space is
// distributed evenly among the max-sized children. if there is no
// remaining space, then we're already outside the bounds, so just give
// them something
else {
const int sizeAvail = boxSize[vc];
const int sizeMin = sizeAvail/10; // 10%, as good as anything
const int amount = m_minAllocation < sizeAvail ? std::max((sizeAvail-m_minAllocation-m_spacing*(int(m_children.size())-1))/m_numVariable, sizeMin) : sizeMin;
Point childPos(0), childSize(0);
for (std::list<Child>::iterator i = m_children.begin(); i != m_children.end(); ++i) {
childSize[fc] = boxSize[fc];
childSize[vc] = (*i).contribSize[vc] == SIZE_EXPAND ? amount : (*i).contribSize[vc];
const Point actualSize(CalcSize((*i).widget, childSize));
SetWidgetDimensions((*i).widget, childPos, actualSize);
childPos[vc] += actualSize[vc] + m_spacing;
}
}
LayoutChildren();
}
void ToolTip::SetText(const char *text)
{
if (m_text != text) {
m_text = text;
m_layout.reset(new TextLayout(text));
CalcSize();
}
}
///---------------------------------------------------------------------------------
/// fast
///---------------------------------------------------------------------------------
inline const Vector2 AABB2D::GetPointAtNormalizedPositionWithinBox( const Vector2& normalizedPosition ) const
{
Vector2 boxSize = CalcSize();
float xPos = m_mins.x + ( boxSize.x * normalizedPosition.x );
float yPos = m_mins.y + ( boxSize.y * normalizedPosition.y );
Vector2 positionAtNormalizedPoint( xPos, yPos );
return positionAtNormalizedPoint;
}
void CPDF_ImageCacheEntry::Reset(const CFX_DIBitmap* pBitmap) {
delete m_pCachedBitmap;
m_pCachedBitmap = nullptr;
if (pBitmap) {
m_pCachedBitmap = pBitmap->Clone();
}
CalcSize();
}
void CPDF_ImageCache::Reset(const CFX_DIBitmap* pBitmap) {
delete m_pCachedBitmap;
m_pCachedBitmap = NULL;
if (pBitmap) {
m_pCachedBitmap = pBitmap->Clone();
}
CalcSize();
}
CommonHeader::CommonHeader()
{
_elements.push_back(&_startByte);
_elements.push_back(&_payloadType);
_elements.push_back(&_sequenceNumber);
_elements.push_back(&_timeStamp);
CalcSize();
}
FX_BOOL CPDF_ImageCache::GetCachedBitmap(CFX_DIBSource*& pBitmap, CFX_DIBSource*& pMask, FX_DWORD& MatteColor, CPDF_Dictionary* pPageResources,
FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus,
FX_INT32 downsampleWidth, FX_INT32 downsampleHeight)
{
if (m_pCachedBitmap) {
pBitmap = m_pCachedBitmap;
pMask = m_pCachedMask;
MatteColor = m_MatteColor;
return TRUE;
}
if (!pRenderStatus) {
return FALSE;
}
CPDF_RenderContext*pContext = pRenderStatus->GetContext();
CPDF_PageRenderCache* pPageRenderCache = pContext->m_pPageCache;
m_dwTimeCount = pPageRenderCache->GetTimeCount();
CPDF_DIBSource* pSrc = FX_NEW CPDF_DIBSource;
CPDF_DIBSource* pMaskSrc = NULL;
if (!pSrc->Load(m_pDocument, m_pStream, &pMaskSrc, &MatteColor, pRenderStatus->m_pFormResource, pPageResources, bStdCS, GroupFamily, bLoadMask)) {
delete pSrc;
pBitmap = NULL;
return FALSE;
}
m_MatteColor = MatteColor;
#if !defined(_FPDFAPI_MINI_)
if (pSrc->GetPitch() * pSrc->GetHeight() < FPDF_HUGE_IMAGE_SIZE) {
m_pCachedBitmap = pSrc->Clone();
delete pSrc;
} else {
m_pCachedBitmap = pSrc;
}
if (pMaskSrc) {
m_pCachedMask = pMaskSrc->Clone();
delete pMaskSrc;
}
#else
if (pSrc->GetFormat() == FXDIB_8bppRgb && pSrc->GetPalette() &&
pSrc->GetHeight() * pSrc->GetWidth() * 3 < 1024) {
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
m_pCachedBitmap = pSrc->CloneConvert(FXDIB_Rgb32);
#else
m_pCachedBitmap = pSrc->CloneConvert(FXDIB_Rgb);
#endif
delete pSrc;
} else if (pSrc->GetPitch() * pSrc->GetHeight() < 102400) {
m_pCachedBitmap = pSrc->Clone();
delete pSrc;
} else {
m_pCachedBitmap = pSrc;
}
m_pCachedMask = pMaskSrc;
#endif
pBitmap = m_pCachedBitmap;
pMask = m_pCachedMask;
CalcSize();
return FALSE;
}
void CFDE_TextOut::CalcSize(const FX_WCHAR* pwsStr,
int32_t iLength,
CFX_SizeF& size) {
CFX_RectF rtText;
rtText.Set(0.0f, 0.0f, size.x, size.y);
CalcSize(pwsStr, iLength, rtText);
size.x = rtText.Width();
size.y = rtText.Height();
}
void CFDE_TextOut::CalcSize(const FX_WCHAR* pwsStr,
int32_t iLength,
CFX_Rect& rect) {
CFX_RectF rtText;
rtText.Set((FX_FLOAT)rect.left, (FX_FLOAT)rect.top, (FX_FLOAT)rect.Width(),
(FX_FLOAT)rect.Height());
CalcSize(pwsStr, iLength, rtText);
rect.Set((int32_t)rtText.left, (int32_t)rtText.top, (int32_t)rtText.Width(),
(int32_t)rtText.Height());
}
M4Err SizeIPMPDUpdate(IPMPDescriptorUpdate *ipmpUp, u32 *outSize)
{
u32 i, tmpSize;
if (!ipmpUp) return M4BadParam;
*outSize = 0;
for (i = 0; i < ChainGetCount(ipmpUp->IPMPDescList); i++) {
Descriptor *tmp = (Descriptor*)ChainGetEntry(ipmpUp->IPMPDescList, i);
CalcSize(tmp, &tmpSize);
*outSize += tmpSize + GetSizeFieldSize(tmpSize);
}
return M4OK;
}
M4Err SizeODUpdate(ObjectDescriptorUpdate *odUp, u32 *outSize)
{
Descriptor *tmp;
u32 i, tmpSize;
if (!odUp) return M4BadParam;
*outSize = 0;
for (i = 0; i < ChainGetCount(odUp->objectDescriptors); i++) {
tmp = (Descriptor*)ChainGetEntry(odUp->objectDescriptors, i);
CalcSize(tmp, &tmpSize);
*outSize += tmpSize + GetSizeFieldSize(tmpSize);
}
return M4OK;
}
bool CPDF_ImageCacheEntry::GetCachedBitmap(CFX_DIBSource*& pBitmap,
CFX_DIBSource*& pMask,
uint32_t& MatteColor,
CPDF_Dictionary* pPageResources,
bool bStdCS,
uint32_t GroupFamily,
bool bLoadMask,
CPDF_RenderStatus* pRenderStatus,
int32_t downsampleWidth,
int32_t downsampleHeight) {
if (m_pCachedBitmap) {
pBitmap = m_pCachedBitmap;
pMask = m_pCachedMask;
MatteColor = m_MatteColor;
return true;
}
if (!pRenderStatus) {
return false;
}
CPDF_RenderContext* pContext = pRenderStatus->GetContext();
CPDF_PageRenderCache* pPageRenderCache = pContext->GetPageCache();
m_dwTimeCount = pPageRenderCache->GetTimeCount();
CPDF_DIBSource* pSrc = new CPDF_DIBSource;
CPDF_DIBSource* pMaskSrc = nullptr;
if (!pSrc->Load(m_pDocument, m_pStream, &pMaskSrc, &MatteColor,
pRenderStatus->m_pFormResource, pPageResources, bStdCS,
GroupFamily, bLoadMask)) {
delete pSrc;
pBitmap = nullptr;
return false;
}
m_MatteColor = MatteColor;
if (pSrc->GetPitch() * pSrc->GetHeight() < FPDF_HUGE_IMAGE_SIZE) {
m_pCachedBitmap = pSrc->Clone();
delete pSrc;
} else {
m_pCachedBitmap = pSrc;
}
if (pMaskSrc) {
m_pCachedMask = pMaskSrc->Clone();
delete pMaskSrc;
}
pBitmap = m_pCachedBitmap;
pMask = m_pCachedMask;
CalcSize();
return false;
}
HexRowView(HexView *hexView,
wxWindowID winid = wxID_ANY,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize)
{
Create(hexView, winid, pos, size);
m_view = hexView;
Bind(wxEVT_LEFT_DOWN, &HexRowView::OnLeftDown, this);
Bind(wxEVT_LEFT_UP, &HexRowView::OnLeftUp, this);
SetBackgroundStyle(wxBG_STYLE_PAINT);
SetCursor(wxCURSOR_IBEAM);
CalcSize();
}
int Subgraph::CalcSize(const Node *n) const
{
if (n->GetType() != TREE || n->IsPreterminal()) {
return 0;
}
if (IsTrivial()) {
return 1;
}
int count = 1;
const std::vector<Node*> &children = n->GetChildren();
for (std::vector<Node *>::const_iterator p = children.begin();
p != children.end(); ++p) {
if (m_leaves.find(*p) == m_leaves.end()) {
count += CalcSize(*p);
}
}
return count;
}
M4Err SizeESDUpdate(ESDescriptorUpdate *esdUp, u32 *outSize)
{
u32 i, BitSize, tmpSize;
if (!esdUp) return M4BadParam;
*outSize = 0;
BitSize = 10;
for (i = 0; i < ChainGetCount(esdUp->ESDescriptors); i++) {
Descriptor *tmp = (Descriptor*)ChainGetEntry(esdUp->ESDescriptors, i);
CalcSize(tmp, &tmpSize);
BitSize += ( tmpSize + GetSizeFieldSize(tmpSize) ) * 8;
}
while ((s32) BitSize > 0) {
BitSize -= 8;
*outSize += 1;
}
return M4OK;
}
TextEdit::TextEdit(const QString & str, QWidget *parent) : QTextEdit(parent)
{
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
//setFrameShape(QFrame::NoFrame);
setFrameShadow(QFrame::Plain);
setLineWrapMode(QTextEdit::NoWrap);
setAcceptRichText(false);
setAutoFormatting(QTextEdit::AutoNone);
setTabChangesFocus(true);
setPlainText(str);
CalcSize();
connect( this, SIGNAL( textChanged() ), this, SLOT( sltTextChanged() ) );
QTextCursor cursor = this->textCursor();
cursor.select(QTextCursor::LineUnderCursor);
setTextCursor( cursor );
}
int CPDF_ImageCache::ContinueGetCachedBitmap()
{
m_MatteColor = ((CPDF_DIBSource*)m_pCurBitmap)->m_MatteColor;
m_pCurMask = ((CPDF_DIBSource*)m_pCurBitmap)->DetachMask();
CPDF_RenderContext*pContext = m_pRenderStatus->GetContext();
CPDF_PageRenderCache* pPageRenderCache = pContext->m_pPageCache;
m_dwTimeCount = pPageRenderCache->GetTimeCount();
#if !defined(_FPDFAPI_MINI_)
if (m_pCurBitmap->GetPitch() * m_pCurBitmap->GetHeight() < FPDF_HUGE_IMAGE_SIZE) {
m_pCachedBitmap = m_pCurBitmap->Clone();
delete m_pCurBitmap;
m_pCurBitmap = NULL;
} else {
m_pCachedBitmap = m_pCurBitmap;
}
if (m_pCurMask) {
m_pCachedMask = m_pCurMask->Clone();
delete m_pCurMask;
m_pCurMask = NULL;
}
#else
if (m_pCurBitmap->GetFormat() == FXDIB_8bppRgb && m_pCurBitmap->GetPalette() &&
m_pCurBitmap->GetHeight() * m_pCurBitmap->GetWidth() * 3 < 1024) {
m_pCachedBitmap = m_pCurBitmap->CloneConvert(FXDIB_Rgb32);
m_pCachedBitmap = m_pCurBitmap->CloneConvert(FXDIB_Rgb);
delete m_pCurBitmap;
m_pCurBitmap = NULL;
} else if (m_pCurBitmap->GetPitch() * m_pCurBitmap->GetHeight() < 102400) {
m_pCachedBitmap = m_pCurBitmap->Clone();
delete m_pCurBitmap;
m_pCurBitmap = NULL;
} else {
m_pCachedBitmap = m_pCurBitmap;
}
m_pCachedMask = m_pCurMask;
#endif
m_pCurBitmap = m_pCachedBitmap;
m_pCurMask = m_pCachedMask;
CalcSize();
return 0;
}
int main(void)
{
unsigned long long total = 0;
unsigned int dim[3], temp;
char c;
unsigned char i;
temp = dim[0] = dim[1] = dim[2] = 0;
while ((c = fgetc(stdin)) != EOF) {
switch (c) {
case '9':
case '8':
case '7':
case '6':
case '5':
case '4':
case '3':
case '2':
case '1':
case '0':
temp *= 10;
temp += c-'0';
break;
case 'x':
case '\n':
for (i = 0; dim[i] != 0; i++) { ; }
dim[i] = temp;
temp = 0;
break;
default:
printf("Unknown character: %d\n", c);
break;
}
if (c == '\n') {
total += CalcSize(dim[0], dim[1], dim[2]);
temp = dim[0] = dim[1] = dim[2] = 0;
}
}
printf("Total size: %llu\n", total);
return 0;
}
/*
Usado para leer Meshes de un recurso
*/
DWORD C3DMesh::ReadFromMemory(void *lpPointer)
{
BYTE* m_lppos;
DWORD i;
m_onstatic=true;
m_lpdata = (S_3DMESH*)lpPointer;
m_lppos = (BYTE*)m_lpdata+sizeof(S_3DMESH);
if (m_lpdata ->m_version != sizeof (m_data))
return 1;
// Leer toda la informacion de la malla
// Leer todos los vertices
m_vertex = (S_3DSPOINT*)m_lppos;
m_lppos+= sizeof(S_3DSPOINT)*m_lpdata->m_nvertex;
// Leer todas las caras
m_faces = (S_3DSFACE*)m_lppos;
m_lppos+= sizeof(S_3DSFACE)*m_lpdata->m_nfaces;
// Reservar espacio para los materiales
m_materials=new S_3DMESHMAT[m_lpdata->m_nmat];
S_3DMESHMATDAT* m_mat_dat;
// Leer todos los materiales
for (i=0;i<m_lpdata->m_nmat;i++)
{
m_mat_dat = (S_3DMESHMATDAT*)m_lppos;
m_lppos+=sizeof(S_3DMESHMATDAT);
m_materials[i].m_data=*m_mat_dat;
m_materials[i].m_faces=(DWORD*)m_lppos;
if (m_3descene)
m_materials[i].m_material=m_3descene->GetMaterial(m_materials[i].m_data.m_mat_index);
else
m_materials[i].m_material=NULL;
m_lppos+=sizeof(DWORD)*m_mat_dat->m_faces_cant;
}
CalcSize();
return 0;
}
void CPDF_ImageCacheEntry::ContinueGetCachedBitmap() {
m_MatteColor = ((CPDF_DIBSource*)m_pCurBitmap)->GetMatteColor();
m_pCurMask = ((CPDF_DIBSource*)m_pCurBitmap)->DetachMask();
CPDF_RenderContext* pContext = m_pRenderStatus->GetContext();
CPDF_PageRenderCache* pPageRenderCache = pContext->GetPageCache();
m_dwTimeCount = pPageRenderCache->GetTimeCount();
if (m_pCurBitmap->GetPitch() * m_pCurBitmap->GetHeight() <
FPDF_HUGE_IMAGE_SIZE) {
m_pCachedBitmap = m_pCurBitmap->Clone();
delete m_pCurBitmap;
m_pCurBitmap = nullptr;
} else {
m_pCachedBitmap = m_pCurBitmap;
}
if (m_pCurMask) {
m_pCachedMask = m_pCurMask->Clone();
delete m_pCurMask;
m_pCurMask = nullptr;
}
m_pCurBitmap = m_pCachedBitmap;
m_pCurMask = m_pCachedMask;
CalcSize();
}
void Grid::Layout()
{
const Point size = GetSize();
Point childPos, childSize;
for (unsigned int rowNum = 0; rowNum < m_numRows; rowNum++) {
childSize.y = m_colSpec.cellPercent[rowNum]*size.y;
childPos.x = 0;
for (unsigned int colNum = 0; colNum < m_numCols; colNum++) {
childSize.x = m_rowSpec.cellPercent[colNum]*size.x;
const unsigned int n = rowNum*m_numCols+colNum;
if (m_widgets[n])
SetWidgetDimensions(m_widgets[n], childPos, CalcSize(m_widgets[n], childSize));
childPos.x += childSize.x;
}
childPos.y += childSize.y;
}
LayoutChildren();
}
void FileReader::LoadFile(const std::string &filename)
{
std::map<std::string, file_cache>::iterator file = ServerInstance->Config->Files.find(filename);
if (file != ServerInstance->Config->Files.end())
{
this->fc = file->second;
}
else
{
fc.clear();
FILE* f = fopen(filename.c_str(), "r");
if (!f)
return;
char linebuf[MAXBUF*10];
while (fgets(linebuf, sizeof(linebuf), f))
{
int len = strlen(linebuf);
if (len)
fc.push_back(std::string(linebuf, len - 1));
}
fclose(f);
}
CalcSize();
}
CTextureQuad::CTextureQuad(const char *srcImg,double maxW,double maxH)
{
Texture=CTexture::LoadTexture(srcImg);
HasAllocatedTex=true;
CalcSize(maxW,maxH);
}
///---------------------------------------------------------------------------------
/// fast
///---------------------------------------------------------------------------------
inline const Vector2 AABB2D::CalcCenter() const
{
Vector2 boxSize = CalcSize();
Vector2 center( boxSize.x * 0.5f, boxSize.y * 0.5f );
return center;
}
CTextureQuad::CTextureQuad(CTexture *tex,double maxW,double maxH) :
HasAllocatedTex(false),
Texture(tex)
{
CalcSize(maxW,maxH);
}
void TextEdit::sltTextChanged()
{
CalcSize();
}
