This commit replaces the placeholder implementation of sbrk(), which
operated on a process' heap, with real implementations of brk() and
sbrk() that adjust a process' program break.
* unistd.h: Add standard definitions of brk() and sbrk(); include
stdint.h for intptr_t.
* thread.cpp: Recognize RLIMIT_AS and RLIMIT_DATA resource limits
(both currently unlimited); order limit identifiers alphabetically.
* arch-specific.cpp: Remove sbrk_hook().
* malloc_debug_api.cpp: Remove sbrk_hook().
* unistd/Jamfile: Build brk.c instead of sbrk.c.
* unistd/brk.c: Add.
* unistd/sbrk.c: Delete (placeholder implementation).
* libroot_stubs.c: Remove sbrk_hook().
* libroot_stubs_legacy.c: Remove sbrk_hook().
* src/tests/.../posix/Jamfile: Build brk_test.c.
* brk_test.c: Add (simple unit test that demonstrates behaviour of
sbrk()).
Signed-off-by: Jérôme Duval <jerome.duval@gmail.com>
* The message to send the mails never made it to the add-on looper.
* Mail protocol threads now have names.
* Added a "public" BOutboundMailProtocol::SendMessages() call that sends
itself a message (even the correct one this time).
* This caused the window to grow each time.
* This was especially noticeable at applications that store their
size on quit, and restore it on start.
* This fixes bug #12456.
The build with a newer revision of the source turned out to keep crashing.
Reverting back to #51740 (which can't be built with the old recipe, so I
manipulated the dependencies in the .PackageInfo of the old package
manually...)
In 2346363b, had corrected the offset writing to the disk, but missed
correcting the offset for reading from the entries struct.
Instead of writing a block, just write the single entry, simplifying
the offset logic considerably.
Some codecs will always output audio in planar mode no matter what we
request. This is the case for example with AAC used for youtube. We now
use swresample to convert from planar to packed format.
Note that since swresample does its own buffering, we could probably do
away with some of the code that handled buffering before, making the
audio pipeline simpler and faster.
Fixes audio in youtube, but now the video plays at 2x speed. It seems
something is wrong with the timestamps. Possible things to investigate:
* why do we use the packet dts instead of the pts from the frames anyway?
* the pts and pkt_dts are in "stream time_base units". We seem to assume
microseconds for audio but this is probably not the case. Or did I
miss where the conversion is done?
* Optimized code path for bitmap drawing with bilinear interpolation
scaling was assuming that source bitmap is always at least 2 rows
in size.
* Fixes#12469: in webkit, scaled 1-pixel-high bitmaps often occur.
If the bitmap allocation is by chance aligned to a page end, access
to the non-existant second row crashes app_server.
With the new session restore code in WebPositive, it would
restore the session and then open an extra window on top, as
the pagesCreated counter did not add the new window(s) to the
counter, only new tabs.
This states that our default license is the MIT license and includes all
the licenses from data/system/data/licenses.
The LICENSE file is scraped by various bots and also used by the GitHub
license API.
* Don't set a default fixed font size - just use the default fixed font.
* The preferences and signature window no longer have a default size,
and position, either. Instead, they are placed over the active window.
* Fixed spacing in the preferences window.
* Converted the signature window to use the layout API.
* Minor cleanup.
* Add a lock which is acquired when reattaching/regenerating masks,
and also acquired for a cached mask before making a clone of it,
to prevent the clone from having an inconsistent state in
concurrent edge cases.
* Maybe fixes#12469
* Our media kit is designed to work with packed audio: which means the
samples from different channels are interleaved in a single stream
* Old ffmpeg versions also used this, but they now switched to the
planar format, where each channel is stored separately.
* Fortunately, we can request ffmpeg to use the packed format. We
actually already tried to do that, but the API for requesting a sample
format has also changed.
* Finally, we didn't recognize the packed format reported by the codecs,
which in some cases could lead to 16/32 bit mismatches on top of the
planar/packed mixup.
Fixes audio with ffmpeg 2.8 (ticket #12460)
* If the same shape alpha mask is set again and again, we now keep
the rendered masks in a cache. On certain websites, WebKit sets
the same shape for clipping hundreds of times, which uses a lot
of time to render the masks.
* When a shape mask was generated, we put it into AlphaMaskCache.
The constructor for ShapeAlphaMask is made private and a factory
method is used for instantiation instead, which transparently
looks up in the cache whether a suitable mask was already generated
before (so the entire caching is encapsulated inside the AlphaMask
class).
* When taking a mask out of the cache, we still create a new
AlphaMask instance. However, the new instance will share the
mask bitmap with the previously generated instance (aside from
the rendering of their bitmap, AlphaMask instances are pretty
lightweight). Shape masks are only seen as identical when
their shape is the same, the inverse flag, and they have the
same parent mask.
* Cache is limited to a fixed size of currently 8 MiB, using a
simple random replacement scheme. An LRU scheme can be added in
the future if necessary. Counting of bytes for the cache size
includes parent masks of masks in the cache, even if the parent
itself is not cached. A reference counter for "indirect" cache
references keeps track of which masks are not part of the cache,
but still need to be added to the cache byte size.
* For now, only for ShapeAlphaMasks, other mask types can be added
as necessary.
* If there is an empty clipping region (invalid clipping) for the
current view, a new layer could still be started, but not ended
anymore. That's because unlike begin layer, end layer is handled in
_DispatchViewDrawingMessage (because it can do actual drawing)
and this method checks whether the clipping is valid and bails out
if it isn't.
* Add an exception for the AS_VIEW_END_LAYER command code to still
process it even when the clipping is invalid. The layer itself
can after all set a valid clipping later on when its command list
is played back. And even if it doesn't, we still have to play it
to make sure nested layers are cleaned up.
* Fixes the memory leak in #12460 where webkit creates
said situation: it had a layer open and then the closing was
ignored due to empty clipping. All subsequent layer calls created
nested layers in that one, hundreds of them, and their BPictures
contained bitmaps, quickly eating up and leaking hundreds of MiB
in app_server.
* When a layer has opacity 0, we can't just ignore it, we still
have to play back its picture, even if the drawing will never
appear on screen. This is because there might be nested layers
and if they don't get blended, their references are not released.
Also, it can be argued that state changes in the layer should be
applied even if the layer is invisible (if we ignore it there,
it would be inconsistent with other layers).
This edge case of invisible layers could be optimized further, but
it is rare enough anyway, so this should do.
