void EffectLayer::RemoveAllEffects() { std::unique_lock<std::recursive_mutex> locker(lock); for (int x = 0; x < mEffects.size(); x++) { IncrementChangeCount(mEffects[x]->GetStartTimeMS(), mEffects[x]->GetEndTimeMS()); delete mEffects[x]; } mEffects.clear(); }
Effect* EffectLayer::AddEffect(int id, const std::string &name, const std::string &settings, const std::string &palette, int startTimeMS, int endTimeMS, int Selected, bool Protected) { std::unique_lock<std::recursive_mutex> locker(lock); Effect *e = new Effect(this, id, name, settings, palette, startTimeMS, endTimeMS, Selected, Protected); mEffects.push_back(e); SortEffects(); IncrementChangeCount(startTimeMS, endTimeMS); return e; }
void EffectLayer::RemoveEffect(int index) { std::unique_lock<std::recursive_mutex> locker(lock); if(index<mEffects.size()) { Effect *e = mEffects[index]; mEffects.erase(mEffects.begin()+index); IncrementChangeCount(e->GetStartTimeMS(), e->GetEndTimeMS()); delete e; } }
Element* SequenceElements::AddElement(const std::string &name, const std::string &type, bool visible,bool collapsed,bool active, bool selected) { if(!ElementExists(name)) { mAllViews[MASTER_VIEW].push_back(new Element(this, name,type,visible,collapsed,active,selected)); Element *el = mAllViews[MASTER_VIEW][mAllViews[MASTER_VIEW].size()-1]; IncrementChangeCount(el); return el; } return NULL; }
Element* SequenceElements::AddElement(int index, const std::string &name, const std::string &type, bool visible,bool collapsed,bool active, bool selected) { if(!ElementExists(name) && index <= mAllViews[MASTER_VIEW].size()) { mAllViews[MASTER_VIEW].insert(mAllViews[MASTER_VIEW].begin()+index,new Element(this, name,type,visible,collapsed,active,selected)); Element *el = mAllViews[MASTER_VIEW][index]; IncrementChangeCount(el); return el; } return NULL; }
void EffectLayer::DeleteSelectedEffects(UndoManager& undo_mgr) { std::unique_lock<std::recursive_mutex> locker(lock); for (std::vector<Effect*>::iterator it = mEffects.begin(); it != mEffects.end(); it++) { if ((*it)->GetSelected() != EFFECT_NOT_SELECTED) { IncrementChangeCount((*it)->GetStartTimeMS(), (*it)->GetEndTimeMS()); undo_mgr.CaptureEffectToBeDeleted( mParentElement->GetName(), mIndex, (*it)->GetEffectName(), (*it)->GetSettingsAsString(), (*it)->GetPaletteAsString(), (*it)->GetStartTimeMS(), (*it)->GetEndTimeMS(), (*it)->GetSelected(), (*it)->GetProtected() ); } } mEffects.erase(std::remove_if(mEffects.begin(), mEffects.end(),ShouldDeleteSelected),mEffects.end()); }
//! You must hold the address space's write lock. void VMUserAddressSpace::RemoveArea(VMArea* _area, uint32 allocationFlags) { VMUserArea* area = static_cast<VMUserArea*>(_area); fAreas.Remove(area); if (area->id != RESERVED_AREA_ID) { IncrementChangeCount(); fFreeSpace += area->Size(); if (area == fAreaHint) fAreaHint = NULL; } }
void SequenceElements::MoveElementDown(const std::string &name, int view) { IncrementChangeCount(nullptr); for(int i=0;i<mAllViews[view].size();i++) { if(name == mAllViews[view][i]->GetName()) { // found element if( i < mAllViews[view].size()-1 ) { MoveSequenceElement(i+1, i, view); } break; } } }
void SequenceElements::DeleteElement(const std::string &name) { for(wxXmlNode* view=mViewsNode->GetChildren(); view!=NULL; view=view->GetNext() ) { wxString view_models = view->GetAttribute("models"); wxArrayString all_models = wxSplit(view_models, ','); wxArrayString new_models; for( int model = 0; model < all_models.size(); model++ ) { if( all_models[model] != name ) { new_models.push_back(all_models[model]); } } view_models = wxJoin(new_models, ','); view->DeleteAttribute("models"); view->AddAttribute("models", view_models); } // delete element pointer from all views for(int i=0;i<mAllViews.size();i++) { for(int j=0;j<mAllViews[i].size();j++) { if(name == mAllViews[i][j]->GetName()) { mAllViews[i].erase(mAllViews[i].begin()+j); IncrementChangeCount(nullptr); break; } } } // delete contents of pointer for(int j=0;j<mAllViews[MASTER_VIEW].size();j++) { if(name == mAllViews[MASTER_VIEW][j]->GetName()) { Element *e = mAllViews[MASTER_VIEW][j]; delete e; break; } } PopulateRowInformation(); }
status_t VMKernelAddressSpace::ShrinkAreaHead(VMArea* _area, size_t newSize, uint32 allocationFlags) { TRACE("VMKernelAddressSpace::ShrinkAreaHead(%p, %#" B_PRIxSIZE ")\n", _area, newSize); VMKernelArea* area = static_cast<VMKernelArea*>(_area); Range* range = area->Range(); if (newSize == range->size) return B_OK; if (newSize > range->size) return B_BAD_VALUE; Range* previousRange = fRangeList.GetPrevious(range); size_t sizeDiff = range->size - newSize; if (previousRange != NULL && previousRange->type == Range::RANGE_FREE) { // the previous range is free -- just enlarge it _FreeListRemoveRange(previousRange, previousRange->size); previousRange->size += sizeDiff; _FreeListInsertRange(previousRange, previousRange->size); range->base += sizeDiff; range->size = newSize; } else { // no free range before -- we need to allocate a new one and // insert it previousRange = new(malloc_flags(allocationFlags)) Range(range->base, sizeDiff, Range::RANGE_FREE); if (previousRange == NULL) return B_NO_MEMORY; range->base += sizeDiff; range->size = newSize; _InsertRange(previousRange); } area->SetBase(range->base); area->SetSize(range->size); IncrementChangeCount(); PARANOIA_CHECK_STRUCTURES(); return B_OK; }
void SequenceElements::MoveSequenceElement(int index, int dest, int view) { IncrementChangeCount(nullptr); if(index<mAllViews[view].size() && dest<mAllViews[view].size()) { Element* e = mAllViews[view][index]; mAllViews[view].erase(mAllViews[view].begin()+index); if(index >= dest) { mAllViews[view].insert(mAllViews[view].begin()+dest,e); } else { mAllViews[view].insert(mAllViews[view].begin()+(dest-1),e); } } }
void VMKernelAddressSpace::_FreeRange(Range* range, uint32 allocationFlags) { TRACE(" VMKernelAddressSpace::_FreeRange(%p (%#" B_PRIxADDR ", %#" B_PRIxSIZE ", %d))\n", range, range->base, range->size, range->type); // Check whether one or both of the neighboring ranges are free already, // and join them, if so. Range* previousRange = fRangeList.GetPrevious(range); Range* nextRange = fRangeList.GetNext(range); if (previousRange != NULL && previousRange->type == Range::RANGE_FREE) { if (nextRange != NULL && nextRange->type == Range::RANGE_FREE) { // join them all -- keep the first one, delete the others _FreeListRemoveRange(previousRange, previousRange->size); _RemoveRange(range); _RemoveRange(nextRange); previousRange->size += range->size + nextRange->size; free_etc(range, allocationFlags); free_etc(nextRange, allocationFlags); _FreeListInsertRange(previousRange, previousRange->size); } else { // join with the previous range only, delete the supplied one _FreeListRemoveRange(previousRange, previousRange->size); _RemoveRange(range); previousRange->size += range->size; free_etc(range, allocationFlags); _FreeListInsertRange(previousRange, previousRange->size); } } else { if (nextRange != NULL && nextRange->type == Range::RANGE_FREE) { // join with the next range and delete it _RemoveRange(nextRange); range->size += nextRange->size; free_etc(nextRange, allocationFlags); } // mark the range free and add it to the respective free list range->type = Range::RANGE_FREE; _FreeListInsertRange(range, range->size); } IncrementChangeCount(); }
void SequenceElements::MoveElement(int index,int destinationIndex) { IncrementChangeCount(nullptr); if(index<destinationIndex) { mAllViews[mCurrentView][index]->Index() = destinationIndex; for(int i=index+1;i<destinationIndex;i++) { mAllViews[mCurrentView][i]->Index() = i-1; } } else { mAllViews[mCurrentView][index]->Index() = destinationIndex; for(int i=destinationIndex;i<index;i++) { mAllViews[mCurrentView][i]->Index() = i+1; } } SortElements(); }
status_t VMKernelAddressSpace::_AllocateRange( const virtual_address_restrictions* addressRestrictions, size_t size, bool allowReservedRange, uint32 allocationFlags, Range*& _range) { TRACE(" VMKernelAddressSpace::_AllocateRange(address: %p, size: %#" B_PRIxSIZE ", addressSpec: %#" B_PRIx32 ", reserved allowed: %d)\n", addressRestrictions->address, size, addressRestrictions->address_specification, allowReservedRange); // prepare size, alignment and the base address for the range search addr_t address = (addr_t)addressRestrictions->address; size = ROUNDUP(size, B_PAGE_SIZE); size_t alignment = addressRestrictions->alignment != 0 ? addressRestrictions->alignment : B_PAGE_SIZE; switch (addressRestrictions->address_specification) { case B_EXACT_ADDRESS: { if (address % B_PAGE_SIZE != 0) return B_BAD_VALUE; break; } case B_BASE_ADDRESS: address = ROUNDUP(address, B_PAGE_SIZE); break; case B_ANY_KERNEL_BLOCK_ADDRESS: // align the memory to the next power of two of the size while (alignment < size) alignment <<= 1; // fall through... case B_ANY_ADDRESS: case B_ANY_KERNEL_ADDRESS: address = fBase; // TODO: remove this again when vm86 mode is moved into the kernel // completely (currently needs a userland address space!) if (address == USER_BASE) address = USER_BASE_ANY; break; default: return B_BAD_VALUE; } // find a range Range* range = _FindFreeRange(address, size, alignment, addressRestrictions->address_specification, allowReservedRange, address); if (range == NULL) { return addressRestrictions->address_specification == B_EXACT_ADDRESS ? B_BAD_VALUE : B_NO_MEMORY; } TRACE(" VMKernelAddressSpace::_AllocateRange() found range:(%p (%#" B_PRIxADDR ", %#" B_PRIxSIZE ", %d)\n", range, range->base, range->size, range->type); // We have found a range. It might not be a perfect fit, in which case // we have to split the range. size_t rangeSize = range->size; if (address == range->base) { // allocation at the beginning of the range if (range->size > size) { // only partial -- split the range Range* leftOverRange = new(malloc_flags(allocationFlags)) Range( address + size, range->size - size, range); if (leftOverRange == NULL) return B_NO_MEMORY; range->size = size; _InsertRange(leftOverRange); } } else if (address + size == range->base + range->size) { // allocation at the end of the range -- split the range Range* leftOverRange = new(malloc_flags(allocationFlags)) Range( range->base, range->size - size, range); if (leftOverRange == NULL) return B_NO_MEMORY; range->base = address; range->size = size; _InsertRange(leftOverRange); } else { // allocation in the middle of the range -- split the range in three Range* leftOverRange1 = new(malloc_flags(allocationFlags)) Range( range->base, address - range->base, range); if (leftOverRange1 == NULL) return B_NO_MEMORY; Range* leftOverRange2 = new(malloc_flags(allocationFlags)) Range( address + size, range->size - size - leftOverRange1->size, range); if (leftOverRange2 == NULL) { free_etc(leftOverRange1, allocationFlags); return B_NO_MEMORY; } range->base = address; range->size = size; _InsertRange(leftOverRange1); _InsertRange(leftOverRange2); } // If the range is a free range, remove it from the respective free list. if (range->type == Range::RANGE_FREE) _FreeListRemoveRange(range, rangeSize); IncrementChangeCount(); TRACE(" VMKernelAddressSpace::_AllocateRange() -> %p (%#" B_PRIxADDR ", %#" B_PRIxSIZE ")\n", range, range->base, range->size); _range = range; return B_OK; }
/*! Finds a reserved area that covers the region spanned by \a start and \a size, inserts the \a area into that region and makes sure that there are reserved regions for the remaining parts. */ status_t VMUserAddressSpace::_InsertAreaIntoReservedRegion(addr_t start, size_t size, VMUserArea* area, uint32 allocationFlags) { VMUserArea* next; for (VMUserAreaList::Iterator it = fAreas.GetIterator(); (next = it.Next()) != NULL;) { if (next->Base() <= start && next->Base() + (next->Size() - 1) >= start + (size - 1)) { // This area covers the requested range if (next->id != RESERVED_AREA_ID) { // but it's not reserved space, it's a real area return B_BAD_VALUE; } break; } } if (next == NULL) return B_ENTRY_NOT_FOUND; // Now we have to transfer the requested part of the reserved // range to the new area - and remove, resize or split the old // reserved area. if (start == next->Base()) { // the area starts at the beginning of the reserved range fAreas.Insert(next, area); if (size == next->Size()) { // the new area fully covers the reversed range fAreas.Remove(next); Put(); next->~VMUserArea(); free_etc(next, allocationFlags); } else { // resize the reserved range behind the area next->SetBase(next->Base() + size); next->SetSize(next->Size() - size); } } else if (start + size == next->Base() + next->Size()) { // the area is at the end of the reserved range fAreas.Insert(fAreas.GetNext(next), area); // resize the reserved range before the area next->SetSize(start - next->Base()); } else { // the area splits the reserved range into two separate ones // we need a new reserved area to cover this space VMUserArea* reserved = VMUserArea::CreateReserved(this, next->protection, allocationFlags); if (reserved == NULL) return B_NO_MEMORY; Get(); fAreas.Insert(fAreas.GetNext(next), reserved); fAreas.Insert(reserved, area); // resize regions reserved->SetSize(next->Base() + next->Size() - start - size); next->SetSize(start - next->Base()); reserved->SetBase(start + size); reserved->cache_offset = next->cache_offset; } area->SetBase(start); area->SetSize(size); IncrementChangeCount(); return B_OK; }
/*! Must be called with this address space's write lock held */ status_t VMUserAddressSpace::_InsertAreaSlot(addr_t start, addr_t size, addr_t end, uint32 addressSpec, VMUserArea* area, uint32 allocationFlags) { VMUserArea* last = NULL; VMUserArea* next; bool foundSpot = false; TRACE(("VMUserAddressSpace::_InsertAreaSlot: address space %p, start " "0x%lx, size %ld, end 0x%lx, addressSpec %ld, area %p\n", this, start, size, end, addressSpec, area)); // do some sanity checking if (start < fBase || size == 0 || end > fEndAddress || start + (size - 1) > end) return B_BAD_ADDRESS; if (addressSpec == B_EXACT_ADDRESS && area->id != RESERVED_AREA_ID) { // search for a reserved area status_t status = _InsertAreaIntoReservedRegion(start, size, area, allocationFlags); if (status == B_OK || status == B_BAD_VALUE) return status; // There was no reserved area, and the slot doesn't seem to be used // already // TODO: this could be further optimized. } size_t alignment = B_PAGE_SIZE; if (addressSpec == B_ANY_KERNEL_BLOCK_ADDRESS) { // align the memory to the next power of two of the size while (alignment < size) alignment <<= 1; } start = ROUNDUP(start, alignment); // walk up to the spot where we should start searching second_chance: VMUserAreaList::Iterator it = fAreas.GetIterator(); while ((next = it.Next()) != NULL) { if (next->Base() > start + (size - 1)) { // we have a winner break; } last = next; } // find the right spot depending on the address specification - the area // will be inserted directly after "last" ("next" is not referenced anymore) switch (addressSpec) { case B_ANY_ADDRESS: case B_ANY_KERNEL_ADDRESS: case B_ANY_KERNEL_BLOCK_ADDRESS: { // find a hole big enough for a new area if (last == NULL) { // see if we can build it at the beginning of the virtual map addr_t alignedBase = ROUNDUP(fBase, alignment); if (is_valid_spot(fBase, alignedBase, size, next == NULL ? end : next->Base())) { foundSpot = true; area->SetBase(alignedBase); break; } last = next; next = it.Next(); } // keep walking while (next != NULL) { addr_t alignedBase = ROUNDUP(last->Base() + last->Size(), alignment); if (is_valid_spot(last->Base() + (last->Size() - 1), alignedBase, size, next->Base())) { foundSpot = true; area->SetBase(alignedBase); break; } last = next; next = it.Next(); } if (foundSpot) break; addr_t alignedBase = ROUNDUP(last->Base() + last->Size(), alignment); if (is_valid_spot(last->Base() + (last->Size() - 1), alignedBase, size, end)) { // got a spot foundSpot = true; area->SetBase(alignedBase); break; } else if (area->id != RESERVED_AREA_ID) { // We didn't find a free spot - if there are any reserved areas, // we can now test those for free space // TODO: it would make sense to start with the biggest of them it.Rewind(); next = it.Next(); for (last = NULL; next != NULL; next = it.Next()) { if (next->id != RESERVED_AREA_ID) { last = next; continue; } // TODO: take free space after the reserved area into // account! addr_t alignedBase = ROUNDUP(next->Base(), alignment); if (next->Base() == alignedBase && next->Size() == size) { // The reserved area is entirely covered, and thus, // removed fAreas.Remove(next); foundSpot = true; area->SetBase(alignedBase); next->~VMUserArea(); free_etc(next, allocationFlags); break; } if ((next->protection & RESERVED_AVOID_BASE) == 0 && alignedBase == next->Base() && next->Size() >= size) { // The new area will be placed at the beginning of the // reserved area and the reserved area will be offset // and resized foundSpot = true; next->SetBase(next->Base() + size); next->SetSize(next->Size() - size); area->SetBase(alignedBase); break; } if (is_valid_spot(next->Base(), alignedBase, size, next->Base() + (next->Size() - 1))) { // The new area will be placed at the end of the // reserved area, and the reserved area will be resized // to make space alignedBase = ROUNDDOWN( next->Base() + next->Size() - size, alignment); foundSpot = true; next->SetSize(alignedBase - next->Base()); area->SetBase(alignedBase); last = next; break; } last = next; } } break; } case B_BASE_ADDRESS: { // find a hole big enough for a new area beginning with "start" if (last == NULL) { // see if we can build it at the beginning of the specified // start if (next == NULL || next->Base() > start + (size - 1)) { foundSpot = true; area->SetBase(start); break; } last = next; next = it.Next(); } // keep walking while (next != NULL) { if (next->Base() - (last->Base() + last->Size()) >= size) { // we found a spot (it'll be filled up below) break; } last = next; next = it.Next(); } addr_t lastEnd = last->Base() + (last->Size() - 1); if (next != NULL || end - lastEnd >= size) { // got a spot foundSpot = true; if (lastEnd < start) area->SetBase(start); else area->SetBase(lastEnd + 1); break; } // we didn't find a free spot in the requested range, so we'll // try again without any restrictions start = fBase; addressSpec = B_ANY_ADDRESS; last = NULL; goto second_chance; } case B_EXACT_ADDRESS: // see if we can create it exactly here if ((last == NULL || last->Base() + (last->Size() - 1) < start) && (next == NULL || next->Base() > start + (size - 1))) { foundSpot = true; area->SetBase(start); break; } break; default: return B_BAD_VALUE; } if (!foundSpot) return addressSpec == B_EXACT_ADDRESS ? B_BAD_VALUE : B_NO_MEMORY; area->SetSize(size); if (last) fAreas.Insert(fAreas.GetNext(last), area); else fAreas.Insert(fAreas.Head(), area); IncrementChangeCount(); return B_OK; }
status_t VMKernelAddressSpace::ResizeArea(VMArea* _area, size_t newSize, uint32 allocationFlags) { TRACE("VMKernelAddressSpace::ResizeArea(%p, %#" B_PRIxSIZE ")\n", _area, newSize); VMKernelArea* area = static_cast<VMKernelArea*>(_area); Range* range = area->Range(); if (newSize == range->size) return B_OK; Range* nextRange = fRangeList.GetNext(range); if (newSize < range->size) { if (nextRange != NULL && nextRange->type == Range::RANGE_FREE) { // a free range is following -- just enlarge it _FreeListRemoveRange(nextRange, nextRange->size); nextRange->size += range->size - newSize; nextRange->base = range->base + newSize; _FreeListInsertRange(nextRange, nextRange->size); } else { // no free range following -- we need to allocate a new one and // insert it nextRange = new(malloc_flags(allocationFlags)) Range( range->base + newSize, range->size - newSize, Range::RANGE_FREE); if (nextRange == NULL) return B_NO_MEMORY; _InsertRange(nextRange); } } else { if (nextRange == NULL || (nextRange->type == Range::RANGE_RESERVED && nextRange->reserved.base > range->base)) { return B_BAD_VALUE; } // TODO: If there is free space after a reserved range (or vice versa), // it could be used as well. size_t sizeDiff = newSize - range->size; if (sizeDiff > nextRange->size) return B_BAD_VALUE; if (sizeDiff == nextRange->size) { // The next range is completely covered -- remove and delete it. _RemoveRange(nextRange); free_etc(nextRange, allocationFlags); } else { // The next range is only partially covered -- shrink it. if (nextRange->type == Range::RANGE_FREE) _FreeListRemoveRange(nextRange, nextRange->size); nextRange->size -= sizeDiff; nextRange->base = range->base + newSize; if (nextRange->type == Range::RANGE_FREE) _FreeListInsertRange(nextRange, nextRange->size); } } range->size = newSize; area->SetSize(newSize); IncrementChangeCount(); PARANOIA_CHECK_STRUCTURES(); return B_OK; }