bool LibManager::SaveLibrary()
{
InitHeader();
ObjIeeeIndexManager im1;
ObjFactory fact1(&im1);
if (!files.ReadFiles(stream, &fact1))
return false;
dictionary.CreateDictionary(files);
// can't do more reading
Close();
header.filesInModule = files.size();
FILE * ostr = fopen(name.c_str(), "wb");
fwrite(&header, sizeof(header), 1, ostr);
Align(ostr,16);
header.namesOffset = ftell(ostr);
files.WriteNames(ostr);
Align(ostr);
header.filesOffset = ftell(ostr);
files.WriteFiles(ostr, ALIGN);
Align(ostr);
header.offsetsOffset = ftell(ostr);
files.WriteOffsets(ostr);
Align(ostr);
header.dictionaryOffset = ftell(ostr);
header.dictionaryBlocks = 0;
dictionary.Write(ostr);
fseek(ostr, 0, SEEK_SET);
fwrite(&header, sizeof(header), 1, ostr);
return true;
// return !ostr.fail();
}
int InitHeader(CListCtrl& list, UINT formatID, const CString& add)
{
CString header;
header.Format(formatID, add);
return InitHeader(list, header, 0);
}
bool Archive::Init() {
if (!InitHeader()) {
std::cerr << "InitHeader failed" << std::endl;
goto on_error;
}
if (!InitFiles()) {
std::cerr << "InitFiles failed" << std::endl;
goto on_error;
}
if (!InitFilePaths()) {
std::cerr << "InitFilePaths failed" << std::endl;
goto on_error;
}
return true;
on_error:
if (file_ != NULL) {
fclose(file_);
file_ = NULL;
}
return false;
}
void ChatroomFrontpage::OnUserInfoChange(const std::list<nim::UserNameCard> &uinfos)
{
for (auto iter = uinfos.cbegin(); iter != uinfos.cend(); iter++)
{
if (nim_ui::LoginManager::GetInstance()->IsEqual(iter->GetAccId()))
{
InitHeader();
break;
}
}
}
void PersonalCenterForm::InitWindow()
{
InitHeader();
// InitRoomManageList();
m_pRoot->AttachBubbledEvent(ui::kEventSelect, nbase::Bind(&PersonalCenterForm::OnSelected, this, std::placeholders::_1));
unregister_cb.Add(nim_ui::UserManager::GetInstance()->RegUserInfoChange(nbase::Bind(&PersonalCenterForm::OnUserInfoChange, this, std::placeholders::_1)));
unregister_cb.Add(nim_ui::PhotoManager::GetInstance()->RegPhotoReady(nbase::Bind(&PersonalCenterForm::OnUserPhotoReady, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)));
((ui::OptionBox*)FindControl(L"apply_room"))->Selected(true, true);
}
void ChatroomFrontpage::InitWindow()
{
m_pRoot->AttachBubbledEvent(ui::kEventClick, nbase::Bind(&ChatroomFrontpage::OnClicked, this, std::placeholders::_1));
InitHeader();
unregister_cb.Add(nim_ui::UserManager::GetInstance()->RegUserInfoChange(nbase::Bind(&ChatroomFrontpage::OnUserInfoChange, this, std::placeholders::_1)));
unregister_cb.Add(nim_ui::PhotoManager::GetInstance()->RegPhotoReady(nbase::Bind(&ChatroomFrontpage::OnUserPhotoReady, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)));
room_list_ = (ui::TileBox*)FindControl(L"room_list");
InvokeGetRoomList();
}
void CUIStatsPlayerList::Init(CUIXml& xml_doc, LPCSTR path)
{
// init window
CUIXmlInit::InitScrollView (xml_doc, path, 0, this);
SetFixedScrollBar (false);
m_bStatus_mode = xml_doc.ReadAttribInt(path,0,"status_mode",0)? true: false;
m_bSpectator = xml_doc.ReadAttribInt(path,0,"spectator",0)? true: m_bStatus_mode;
SetSpectator (m_bSpectator);
// init item structure
int tabsCount = xml_doc.GetNodesNum(path, 0, "field");
XML_NODE* tab_node = xml_doc.NavigateToNode(path,0);
xml_doc.SetLocalRoot (tab_node);
for (int i = 0; i < tabsCount; ++i)
{
LPCSTR name = xml_doc.ReadAttrib("field",i,"name");
float width = xml_doc.ReadAttribFlt("field",i,"width");
if (0 == xr_strcmp(name, "artefacts") && GameID() != eGameIDArtefactHunt)
continue;
AddField (name,width);
}
xml_doc.SetLocalRoot (xml_doc.GetRoot());
string256 _path;
// init item text params
CUIXmlInit::InitFont (xml_doc, strconcat(sizeof(_path),_path, path, ":text_format"), 0, m_i.c, m_i.f);
m_i.h = xml_doc.ReadAttribFlt(strconcat(sizeof(_path),_path, path, ":text_format"), 0, "height", 25);
// init list header
switch (GameID())
{
case eGameIDCaptureTheArtefact:
case eGameIDArtefactHunt:
case eGameIDTeamDeathmatch:
if (!m_bSpectator || m_bStatus_mode)
InitTeamHeader(xml_doc, path);
case eGameIDDeathmatch:
InitHeader(xml_doc, path);
default:
break;
}
}
//***************************************************************************************
LRESULT CBCGPListCtrl::OnStyleChanged(WPARAM wp, LPARAM lp)
{
int nStyleType = (int) wp;
LPSTYLESTRUCT lpStyleStruct = (LPSTYLESTRUCT) lp;
CListCtrl::OnStyleChanged (nStyleType, lpStyleStruct);
if ((lpStyleStruct->styleNew & LVS_REPORT) &&
(lpStyleStruct->styleOld & LVS_REPORT) == 0)
{
if (GetHeaderCtrl ().GetSafeHwnd () == NULL)
{
InitHeader ();
}
}
return 0;
}
void* debug_calloc(size_t nmemb, size_t bytes) {
if (DebugCallsDisabled()) {
return g_dispatch->calloc(nmemb, bytes);
}
ScopedDisableDebugCalls disable;
size_t size;
if (__builtin_mul_overflow(nmemb, bytes, &size)) {
// Overflow
errno = ENOMEM;
return nullptr;
}
if (size == 0) {
size = 1;
}
size_t real_size;
if (__builtin_add_overflow(size, g_debug->extra_bytes(), &real_size)) {
// Overflow.
errno = ENOMEM;
return nullptr;
}
if (g_debug->need_header()) {
// The above check will guarantee the multiply will not overflow.
if (size > Header::max_size()) {
errno = ENOMEM;
return nullptr;
}
// Need to guarantee the alignment of the header.
Header* header = reinterpret_cast<Header*>(
g_dispatch->memalign(MINIMUM_ALIGNMENT_BYTES, real_size));
if (header == nullptr) {
return nullptr;
}
memset(header, 0, g_dispatch->malloc_usable_size(header));
return InitHeader(header, header, size);
} else {
return g_dispatch->calloc(1, real_size);
}
}
////////////////////////////////////////////////////////////////////////
/// @brief Called when plug-in setup is needed.
/// @return Return nonzero if you have processed.
DLLEXPORT int WINAPI BKC_OnPlugInSetup(HWND hWnd)
{
// Return nonzero if you have processed.
//return 1;
UINT chk = 0;
char buf[1024];
LPCSTR lpMailID;
::GetPrivateProfileString("BkTbHdr", "HeaderList", "X-Mailer",
buf, sizeof(buf) - 1, szIni);
DoSetting(g_hInstance, hWnd, buf, sizeof(buf), &chk);
::WritePrivateProfileString("BkTbHdr", "HeaderList",
buf, szIni);
InitHeader(szIni);
lpMailID = bka.GetCurrentMail();
ShowHeader(lpMailID);
return 1;
}
void CServerList::InitFromXml(CUIXml& xml_doc, LPCSTR path)
{
CUIXmlInit::InitWindow (xml_doc, path, 0, this);
string256 buf;
CUIXmlInit::InitListWnd (xml_doc, strconcat(sizeof(buf),buf,path,":list"), 0, &m_list[LST_SERVER]);
m_fListH[0] = m_list[LST_SERVER].GetHeight();
m_fListH[1] = xml_doc.ReadAttribFlt(buf,0,"height2");
CUIXmlInit::InitListWnd (xml_doc, strconcat(sizeof(buf),buf,path,":list_server_properties"), 0, &m_list[LST_SRV_PROP]);
CUIXmlInit::InitListWnd (xml_doc, strconcat(sizeof(buf),buf,path,":list_players_list"), 0, &m_list[LST_PLAYERS]);
CUIXmlInit::InitFrameWindow (xml_doc, strconcat(sizeof(buf),buf,path,":frame"), 0, &m_frame[LST_SERVER]);
CUIXmlInit::InitFrameWindow (xml_doc, strconcat(sizeof(buf),buf,path,":list_server_properties:frame"), 0, &m_frame[LST_SRV_PROP]);
CUIXmlInit::InitFrameWindow (xml_doc, strconcat(sizeof(buf),buf,path,":list_players_list:frame"), 0, &m_frame[LST_PLAYERS]);
CUIXmlInit::InitFont (xml_doc, strconcat(sizeof(buf),buf,path,":list_item:text"), 0, m_itemInfo.color, m_itemInfo.font);
CUIXmlInit::InitEditBox (xml_doc, strconcat(sizeof(buf),buf,path,":edit_gs_filter"), 0, &m_edit_gs_filter);
m_fEditPos[0] = m_edit_gs_filter.GetWndPos().y;
m_fEditPos[1] = xml_doc.ReadAttribFlt(buf,0,"y2");
CUIXmlInit::InitFrameLine (xml_doc, strconcat(sizeof(buf),buf,path,":cap_server_properties"), 0, &m_header2[0]);
CUIXmlInit::InitFrameLine (xml_doc, strconcat(sizeof(buf),buf,path,":cap_players_list"), 0, &m_header2[1]);
CUIXmlInit::InitFrameLine (xml_doc, strconcat(sizeof(buf),buf,path,":cap_frags"), 0, &m_header2[2]);
CUIXmlInit::InitFrameLine (xml_doc, strconcat(sizeof(buf),buf,path,":cap_death"), 0, &m_header2[3]);
m_itemInfo.size.icon = xml_doc.ReadAttribFlt( strconcat(sizeof(buf),buf, path, ":sizes"), 0, "icon");
m_itemInfo.size.server = xml_doc.ReadAttribFlt( buf, 0, "server");
m_itemInfo.size.map = xml_doc.ReadAttribFlt( buf, 0, "map");
m_itemInfo.size.game = xml_doc.ReadAttribFlt( buf, 0, "game");
m_itemInfo.size.players = xml_doc.ReadAttribFlt( buf, 0, "players");
m_itemInfo.size.ping = xml_doc.ReadAttribFlt( buf, 0, "ping");
m_itemInfo.size.version = xml_doc.ReadAttribFlt( buf, 0, "version");
// init header elements
for (int i = 0; i<LST_COLUMN_COUNT; i++)
{
CUIXmlInit::Init3tButtonEx (xml_doc,strconcat(sizeof(buf),buf,path,":header"), 0, &m_header[i]);
CUIXmlInit::InitFrameLine (xml_doc,strconcat(sizeof(buf),buf,path,":header_frames"), 0, &m_header_frames[i]);
}
m_header[0].Enable (false);
InitHeader ();
UpdateSizes ();
UpdateVisibility ();
}
////////////////////////////////////////////////////////////////////////
/// @brief Called when the program is started and the main window is created.
/// @return Always return 0.
DLLEXPORT int WINAPI BKC_OnStart()
{
/*
Since BKC_OnStart is called after Becky!'s main window is
created, at least BKC_OnMenuInit with BKC_MENU_MAIN is called
before BKC_OnStart. So, do not assume BKC_OnStart is called
prior to any other callback.
*/
// Always return 0.
HWND hMain, hTree, hList, hView;
g_hInstance = GetModuleHandle(NULL);
InitHeader(szIni);
bka.GetWindowHandles(&hMain, &hTree, &hList, &hView);
hookMailWindow(hMain);
return 0;
}
static void *internal_malloc(size_t size) {
if (size == 0) {
size = 1;
}
size_t real_size = size + g_debug->extra_bytes();
if (real_size < size) {
// Overflow.
errno = ENOMEM;
return nullptr;
}
void* pointer;
if (g_debug->need_header()) {
if (size > Header::max_size()) {
errno = ENOMEM;
return nullptr;
}
Header* header = reinterpret_cast<Header*>(
g_dispatch->memalign(MINIMUM_ALIGNMENT_BYTES, real_size));
if (header == nullptr) {
return nullptr;
}
pointer = InitHeader(header, header, size);
} else {
pointer = g_dispatch->malloc(real_size);
}
if (pointer != nullptr && g_debug->config().options & FILL_ON_ALLOC) {
size_t bytes = internal_malloc_usable_size(pointer);
size_t fill_bytes = g_debug->config().fill_on_alloc_bytes;
bytes = (bytes < fill_bytes) ? bytes : fill_bytes;
memset(pointer, g_debug->config().fill_alloc_value, bytes);
}
return pointer;
}
BOOL CBCGPListCtrl::InitList ()
{
InitHeader ();
InitColors ();
return TRUE;
}
CAhxSearch::CAhxSearch()
{
InitHeader("\x80\x00\x00\x20\x11\x00\x00\x01\x00\x00", 10);
InitFooter("AHXE(c)CRI", 10);
}
CMpgSearch::CMpgSearch()
{
InitHeader("\x00\x00\x01\xBA\x21\x00\x01\x00", 8);
InitFooter("\xFF\xFF\xFF\xFF\x00\x00\x01\xB9", 8);
}
int main( int ac, char* av[] )
{
WaveHeaderType h;
int i, j;
long x;
char c;
FILE* fp;
fp = fopen( "tone.wav", "wb" );
InitHeader( &h );
fwrite( &h, sizeof(h), 1, fp );
#if 0
/* 無音 1秒 */
c = 0x80;
for( i = 0; i < 11025; i++ ) {
fwrite( &c, sizeof(c), 1, fp );
}
/* 予告 1秒 ×3 */
for( j = 0; j < 3; j++ ) {
for( i = 0; i < 11025; i++ ) {
if( i < 11025/10 ) {
/* 100ms */
c = (unsigned char)( 128.0 * sin( 2.0 * PIE * (double)i / ( 11025.0 / 440.0 ) ) + 128.0 );
} else {
/* 残り900msは無音 */
c = 0x80;
}
fwrite( &c, sizeof(c), 1, fp );
}
}
#endif
#if 0 /* ORIG */
/* 本信号 2秒 */
/* 減衰 1秒 */
for( x = 0; x < 11025L*3L; x++ ) {
double d;
if( x < 11025L*2L ) {
/* 2秒間は本信号をフルレベル */
d = 128.0;
} else {
/* 残り1秒間は減衰 */
long n = 11025L*3L - x;
d = 128.0 * (double)n / 11025L;
}
c = (unsigned char)( d * sin( 2.0 * PIE * (double)x / ( 11025.0 / 880.0 ) ) + 128.0 );
fwrite( &c, sizeof(c), 1, fp );
}
#else
for( x = 0; x < 11025L*2L; x++ ) {
double d;
if( x < 11025L ) {
/* 2秒間は本信号をフルレベル */
d = 128.0;
} else {
/* 残り1秒間は減衰 */
long n = 11025L*2L - x;
d = 128.0 * (double)n / 11025L;
}
c = (unsigned char)( d * sin( 2.0 * PIE * (double)x / ( 11025.0 / 880.0 ) ) + 128.0 );
fwrite( &c, sizeof(c), 1, fp );
}
#endif
/* 無音 1秒 */
c = 0x80;
for( i = 0; i < 11025; i++ ) {
fwrite( &c, sizeof(c), 1, fp );
}
fclose( fp );
return( 0 );
}
Section* BinaryWriter<ElemType>::CreateSection(const ConfigParameters& config, Section* parentSection, size_t p_records, size_t p_windowSize)
{
// first check if we need to open a new section file
std::vector<std::wstring> sections;
// determine the element size, default to ElemType size
size_t elementSize = sizeof(ElemType);
if (config.ExistsCurrent(L"elementSize"))
{
elementSize = config(L"elementSize");
}
// get the number of records we should expect (max)
// if defined in previous levels same number will be used
size_t records = p_records;
if (config.ExistsCurrent(L"wrecords"))
{
records = config(L"wrecords");
}
if (records == 0)
{
InvalidArgument("Required config variable 'wrecords' missing from BinaryWriter configuration.");
}
size_t dim = 1; // default dimension (single item)
if (config.ExistsCurrent(L"dim"))
{
dim = config(L"dim");
}
// get the section type (used for caching)
SectionType sectionType = sectionTypeNull;
if (config.ExistsCurrent(L"sectionType"))
{
SectionType foundType = sectionTypeNull;
wstring type = config(L"sectionType");
for (int i = 0; i < sectionTypeMax; i++)
{
if (EqualCI(type, SectionTypeStrings[i]))
{
foundType = SectionType(i);
break;
}
}
// check to make sure it matched something
if (foundType == sectionTypeNull)
{
InvalidArgument("Invalid value for 'sectionType' in BinaryWriter configuration: %ls", type.c_str());
}
sectionType = foundType;
}
// calculate number of bytes = dim*elementSize*records
size_t dataOnlySize = records * elementSize * dim;
size_t dataSize = dataOnlySize + sectionHeaderMin;
// filename to use the one defined at this level, if there is none use the parent file
SectionFile* file = NULL;
if (config.ExistsCurrent(L"wfile"))
{
std::wstring wfile = config(L"wfile");
auto secFile = m_secFiles.find(wfile);
if (secFile != m_secFiles.end())
{
file = secFile->second;
}
else
{
// TODO: sanity check and use records as a clue of how big to make it
size_t initialSize = config(L"wsize", (size_t) 256); // default to 256MB if not provided
initialSize *= 1024 * 1024; // convert MB to bytes
if (initialSize < dataSize)
initialSize = dataSize * 5 / 4; // make the initalSize slightly larger than needed for data
file = new SectionFile(wfile, fileOptionsReadWrite, initialSize);
m_secFiles[wfile] = file;
parentSection = file->FileSection();
parentSection->SetElementCount(records);
parentSection->SetFileUniqueId(this->m_uniqueID);
}
}
else
{ // no file defined at this config level, use parent file
if (parentSection != NULL && parentSection->GetSectionFile() != NULL)
{
file = parentSection->GetSectionFile();
}
else if (sectionType != sectionTypeNull)
{
InvalidArgument("No filename (wfile) defined in BinaryWriter configuration.");
}
}
// determine file position if needed
size_t filePositionLast = 0;
size_t filePositionNext = 0;
if (file != NULL)
{
// get the next available position in the file (always on the end)
filePositionLast = file->GetFilePositionMax();
filePositionNext = file->RoundUp(filePositionLast);
// we have a gap, zero it out to keep the file clean
if (filePositionLast != filePositionNext)
{
size_t size = filePositionNext - filePositionLast;
size_t roundDown = file->RoundUp(filePositionLast - file->GetViewAlignment() - 1);
// need to get a veiw to zero out non-used bytes
void* view = file->GetView(roundDown, file->GetViewAlignment());
char* ptr = (char*) view + filePositionLast % file->GetViewAlignment();
memset(ptr, 0, size);
file->ReleaseView(view);
}
}
// get the new section name
std::string sectionName = config.ConfigName();
// get the window size, to see if we want to do separate element mapping
size_t windowSize = p_windowSize;
if (config.ExistsCurrent(L"windowSize"))
{
windowSize = config(L"windowSize");
}
MappingType mappingMain = windowSize ? mappingElementWindow : mappingParent;
MappingType mappingAux = windowSize ? mappingSection : mappingParent;
// now create the new section
Section* section = NULL;
switch (sectionType)
{
case sectionTypeNull:
// this happens for the original file header, nothing to do
// also used when multiple files are defined, but none at the base level
break;
case sectionTypeFile: // file header
// shouldn't occur, but same case as above
break;
case sectionTypeData: // data section
section = new Section(file, parentSection, filePositionNext, mappingMain, dataSize);
section->InitHeader(sectionTypeData, sectionName + ":Data Section", sectionDataFloat, sizeof(ElemType));
break;
case sectionTypeLabel: // label data
{
size_t elementSize2 = sizeof(LabelIdType);
dataSize = records * elementSize2 + sectionHeaderMin;
auto sectionLabel = new SectionLabel(file, parentSection, filePositionNext, mappingMain, dataSize);
SectionData dataType = sectionDataInt;
LabelKind labelKind = labelCategory; // default
if (config.Match(L"labelType", L"Regression"))
{
labelKind = labelRegression;
dataType = sectionDataFloat;
elementSize2 = sizeof(ElemType);
}
else if (config.Match(L"labelType", L"Category"))
{
// everything set already, default value
}
else
{
RuntimeError("Invalid type 'labelType' or missing in BinaryWriter configuration.");
}
// initialize the section header
sectionLabel->InitHeader(sectionTypeLabel, sectionName + ":Labels", dataType, (WORD) elementSize2);
// initialize the special label header items
sectionLabel->SetLabelKind(labelKind);
sectionLabel->SetLabelDim(config(L"labelDim"));
section = sectionLabel;
break;
}
case sectionTypeLabelMapping: // label mapping table (array of strings)
section = new SectionString(file, parentSection, filePositionNext, mappingAux, dataSize);
section->InitHeader(sectionTypeLabelMapping, sectionName + ":Label Map", sectionDataStrings, 0); // declare variable length strings
section->SetFlags(flagAuxilarySection);
section->SetFlags(flagVariableSized);
break;
case sectionTypeStats: // data statistics
{
ConfigArray calcStats = config(L"compute");
records = calcStats.size();
elementSize = sizeof(NumericStatistics);
dataOnlySize = records * elementSize;
dataSize = dataOnlySize + sectionHeaderMin;
auto sectionStats = new SectionStats(file, parentSection, filePositionNext, mappingAux, dataSize);
sectionStats->InitHeader(sectionTypeStats, sectionName + ":Data Statistics", sectionDataStruct, sizeof(NumericStatistics)); // declare variable length strings
sectionStats->SetFlags(flagAuxilarySection);
section = sectionStats;
break;
}
case sectionTypeCategoryLabel:
section = new Section(file, parentSection, filePositionNext, mappingMain, dataSize);
section->InitHeader(sectionTypeCategoryLabel, sectionName + ":Category Labels", sectionDataFloat, sizeof(ElemType)); // declare variable length strings
break;
}
// set the rest of the header variables necessary
if (section == NULL)
{
// NULL or file section/already created
section = parentSection;
}
else
{
section->SetElementSize(elementSize);
section->SetElementsPerRecord(dim);
section->SetElementCount(records * dim);
section->SetSize(dataSize);
section->SetSizeAll(dataSize);
// windowSize is in records, convert to bytes
size_t dataWindowSize = windowSize ? windowSize * elementSize * dim : dataOnlySize;
// clamp it down to actual data size
dataWindowSize = min(dataOnlySize, dataWindowSize);
// now get the data pointer setup and allocate the view as necessary
bool auxSection = !!(section->GetFlags() & flagAuxilarySection);
section->EnsureElements(0, auxSection ? dataOnlySize : dataWindowSize);
// update the max file position for the next section
file->SetFilePositionMax(section->GetFilePosition() + dataSize);
// Add new section to parent
parentSection->AddSection(section);
}
// From here on down we have a fully usable section object
// now find the subsections and repeat
vector<std::wstring> subsections;
FindConfigNames(config, "sectionType", subsections);
// look for any children and create them as well
for (std::wstring subsection : subsections)
{
CreateSection(config(subsection), section, records, windowSize);
}
// wait until here so everything is mapped and valid in the object
if (sectionType == sectionTypeStats)
{
ConfigArray calcStats = config(L"compute");
((SectionStats*) section)->InitCompute(calcStats);
}
// add to section map
if (sectionType != sectionTypeFile && sectionType != sectionTypeNull)
{
std::wstring wsectionName = msra::strfun::utf16(sectionName);
// can't have identical names in a write configuration
if (m_sections.find(wsectionName) != m_sections.end())
{
RuntimeError("Identical section name appears twice:%s", sectionName.c_str());
}
m_sections[wsectionName] = section;
}
// validate the header (make sure it's sane)
if (section && file && !section->ValidateHeader(file->Writing()))
{
RuntimeError("Invalid header in file %ls, in header %ls\n", file->GetName().c_str(), section->GetName().c_str());
}
// return the now complete section
return section;
}
void* debug_memalign(size_t alignment, size_t bytes) {
if (DebugCallsDisabled()) {
return g_dispatch->memalign(alignment, bytes);
}
ScopedDisableDebugCalls disable;
if (bytes == 0) {
bytes = 1;
}
void* pointer;
if (g_debug->need_header()) {
if (bytes > Header::max_size()) {
errno = ENOMEM;
return nullptr;
}
// Make the alignment a power of two.
if (!powerof2(alignment)) {
alignment = BIONIC_ROUND_UP_POWER_OF_2(alignment);
}
// Force the alignment to at least MINIMUM_ALIGNMENT_BYTES to guarantee
// that the header is aligned properly.
if (alignment < MINIMUM_ALIGNMENT_BYTES) {
alignment = MINIMUM_ALIGNMENT_BYTES;
}
// We don't have any idea what the natural alignment of
// the underlying native allocator is, so we always need to
// over allocate.
size_t real_size = alignment + bytes + g_debug->extra_bytes();
if (real_size < bytes) {
// Overflow.
errno = ENOMEM;
return nullptr;
}
pointer = g_dispatch->malloc(real_size);
if (pointer == nullptr) {
return nullptr;
}
uintptr_t value = reinterpret_cast<uintptr_t>(pointer) + g_debug->pointer_offset();
// Now align the pointer.
value += (-value % alignment);
Header* header = g_debug->GetHeader(reinterpret_cast<void*>(value));
pointer = InitHeader(header, pointer, bytes);
} else {
size_t real_size = bytes + g_debug->extra_bytes();
if (real_size < bytes) {
// Overflow.
errno = ENOMEM;
return nullptr;
}
pointer = g_dispatch->memalign(alignment, real_size);
}
if (pointer != nullptr && g_debug->config().options & FILL_ON_ALLOC) {
size_t bytes = internal_malloc_usable_size(pointer);
size_t fill_bytes = g_debug->config().fill_on_alloc_bytes;
bytes = (bytes < fill_bytes) ? bytes : fill_bytes;
memset(pointer, g_debug->config().fill_alloc_value, bytes);
}
return pointer;
}
CMidSearch::CMidSearch()
{
InitHeader("MThd\0\0\0\x06", 8);
}
CWmvSearch::CWmvSearch()
{
InitHeader("\x30\x26\xB2\x75\x8E\x66\xCF\x11\xA6\xD9\x00\xAA\x00\x62\xCE\x6C", 16);
InitFooter("\xA1\xDC\xAB\x8C\x47\xA9\xCF\x11\x8E\xE4\x00\xC0\x0C\x20\x53\x65\x68", 17);
}
