GStreamer issueshttps://gitlab.freedesktop.org/groups/gstreamer/-/issues2019-05-01T17:33:11Zhttps://gitlab.freedesktop.org/gstreamer/gst-plugins-base/-/issues/546glcolorbalance pipeline crash with GST-1.14.42019-05-01T17:33:11ZHaihua Huglcolorbalance pipeline crash with GST-1.14.4Below glcolorbalance pipeline crash with GST-1.14.4:
gst-launch-1.0 videotestsrc ! glupload ! glcolorbalance saturation=0.0 ! glcolorconvert ! gldownload ! waylandsink
This commit cause the crash
commit 5523e89c783b98659dbc5771873a9a82...Below glcolorbalance pipeline crash with GST-1.14.4:
gst-launch-1.0 videotestsrc ! glupload ! glcolorbalance saturation=0.0 ! glcolorconvert ! gldownload ! waylandsink
This commit cause the crash
commit 5523e89c783b98659dbc5771873a9a82d0d0b79c
Author: Jan Schmidt <jan@centricular.com>
Date: Tue Feb 27 23:22:24 2018 +1100
glcolorbalance: Support OES textures for input/passthrough
glcolorbalance is in the default GL path inside glimagesink,
so has been causing an possibly-unnecessary extra texture copy
on Android for a while now. If we're just doing passthrough,
we can support OES directly. If not, they'll be transformed
to 2D textures and colourbalanced.https://gitlab.freedesktop.org/gstreamer/gstreamer/-/issues/353Document that pad unlink function is called with pad lock held2019-02-13T12:24:52ZlawrencetroupDocument that pad unlink function is called with pad lock heldA pad's unlink function (set by gst_pad_set_unlink_function) is called with the pad's lock held. This means that any other calls made on the pad hang (because they also try and acquire the mutex).
In the link function, the lock is not h...A pad's unlink function (set by gst_pad_set_unlink_function) is called with the pad's lock held. This means that any other calls made on the pad hang (because they also try and acquire the mutex).
In the link function, the lock is not held - so the behaviour in the unlink function here is inconsistent, and makes the unlink function unusable for any functional purposes.
Relevant code block in `gstpad.c`:
```
GST_OBJECT_LOCK (srcpad);
GST_OBJECT_LOCK (sinkpad);
if (G_UNLIKELY (GST_PAD_PEER (srcpad) != sinkpad))
goto not_linked_together;
if (GST_PAD_UNLINKFUNC (srcpad)) {
GstObject *tmpparent;
ACQUIRE_PARENT (srcpad, tmpparent, no_src_parent);
GST_PAD_UNLINKFUNC (srcpad) (srcpad, tmpparent);
```https://gitlab.freedesktop.org/gstreamer/cerbero/-/issues/115stylish: Make and preserve code PEP8 compliant2024-01-09T21:12:53ZNacho Garciastylish: Make and preserve code PEP8 compliantCurrent code is not PEP8 compliant.
I'm opening this issue in order the discuss the convenience of a stylish patch to format it to PEP8, and then a patch to install a git pre-commit hook to force PEP8 compliance in the future.
This wou...Current code is not PEP8 compliant.
I'm opening this issue in order the discuss the convenience of a stylish patch to format it to PEP8, and then a patch to install a git pre-commit hook to force PEP8 compliance in the future.
This would save us time later by allowing automatic stylish. In my tests, 'autopep8' tool serves well this purpose.https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/issues/554GPMF support in mp4mux2023-10-12T16:59:00ZErlend EriksenGPMF support in mp4muxGoPro has open sourced their format for embedding telemetry data into a track in their videos. The format is defined [here](https://github.com/gopro/gpmf-parser). To make use of this format, mp4mux needs to have support for writing the a...GoPro has open sourced their format for embedding telemetry data into a track in their videos. The format is defined [here](https://github.com/gopro/gpmf-parser). To make use of this format, mp4mux needs to have support for writing the additional track with the right moov atom fields.https://gitlab.freedesktop.org/gstreamer/gst-editing-services/-/issues/61Make all TimelineElement timestamps "frame based" / rational numbers / TimeCodes2021-09-24T12:17:16ZThibault Sauniertsaunier@igalia.comMake all TimelineElement timestamps "frame based" / rational numbers / TimeCodesCurrently all times in GES are GstClockTime, meaning they are on a nanosecond scale.
Since video material is based on frames, for video editing this degree of freedom can
lead to small glitches. In that context it's more accurate to spec...Currently all times in GES are GstClockTime, meaning they are on a nanosecond scale.
Since video material is based on frames, for video editing this degree of freedom can
lead to small glitches. In that context it's more accurate to specify the times by
the number of frames, within a scale defined by the framerate. Note all major video
editing apps use this one way or the other.
This is a proposal to allow GES to base timestamps on output and media files framerates.
For that we can reuse [GstVideoTimeCode] which implements
all the logic for converting Video timecode as standardized by the SMPTE to
`GstClockTime`s. This means that if we write a new API using that object that
logic is already abstracted out even though the VideoTimeCode API doesn't 100%
match our needs and we will probably add some helper methods/constructors to
better fit with our use case.
[GstVideoTimeCode]: https://gstreamer.freedesktop.org/documentation/video/subprojects/gst-plugins-base/gst-libs/gst/video/gstvideotimecode.html?gi-language=c#GstVideoTimeCode
## API additions:
### `GESTimeline`
The idea would be to introduce a `(GstFraction) GESTimeline:rate` property on
which all timestamps will be "snapped", with that done, we need each and every
`GESTimelineElement` timestamps inside a timeline snapped to it.
We still need backward compatibility with previous behaviour, and to do so, the
idea is to have a mode where no snapping happens, and to make that happen, the
possible solution is to make `GESTimeline:rate == NULL` mean "no
snapping should happen. What should be the `GESTimeline:rate` default value?
`NULL` so that default behaviour is unchanged?
Also one case we need to handle is setting the `GESTimeline:rate`, which
involves retimestamping all contained objects in a sensible way.
Also, setting `GESTimeline:rate` will override any
`GESTrack:restriction-caps['framerate']` value.
### `GESTimelineElement`
Add `_timecode` setter variants for timestamps, for example:
``` c
gboolean ges_timeline_element_set_start_timecode (GESTimelineElement *element, GstVideoTimeCode *start);
gboolean ges_timeline_element_set_inpoint_timecode (GESTimelineElement *element, GstVideoTimeCode *duration);
gboolean ges_timeline_element_set_duration_timecode (GESTimelineElement *element, GstVideoTimeCode *duration);
gboolean ges_timeline_element_ripple_timecode (GESTimelineElement *self, GstVideoTimeCode *start);
gboolean ges_timeline_element_ripple_end_timecode (GESTimelineElement *self, GstVideoTimeCode *end);
gboolean ges_timeline_element_roll_start_timecode (GESTimelineElement *self, GstVideoTimeCode *start);
gboolean ges_timeline_element_roll_end_timecode (GESTimelineElement *self, GstVideoTimeCode *end);
gboolean ges_timeline_element_trim_timecode (GESTimelineElement *self, GstVideoTimeCode *start);
```
### Clips
* `GESUriSource:inpoint` should probably use the input file rate and we should
try to make that the default. Currently we anyway have a videorate element
that makes the output framerate the one of the `GESTrack:restriction-caps`
value, we should try to change that behaviour and let the `compositor` handle
the framerate modulation between input streams
* `GESTimelineElement:duration`: Currently we do not make a difference between
the consumed duration of the input clip and the outputed duration in the timeline,
mainly because we do not handle time stretching yet. Having a rate for that
timestamp that is different than the one of the timeline leads to inconsistency in
terms of what that timestamp represents, and when "drawing" a representation the time
will need to be converted, this is far from ideal.
=> **Should we add a new notion of "input-duration" or "media-duration" ?**
``` c
GESClip* ges_clip_split_timecode (GESClip *clip, GstVideoTimeCode *position);
```
### Container
``` c
gboolean ges_container_edit_timecode (GESContainer *container,
GList *layers,
gint new_layer_priority,
GESEditMode mode,
GESEdge edge,
GstVideoTimeCode *position);
```https://gitlab.freedesktop.org/gstreamer/gst-editing-services/-/issues/60Add support for nested timelines2019-08-30T21:48:05ZThibault Sauniertsaunier@igalia.comAdd support for nested timelinesBasically we need a way to have timelines inside timeline.
The implementation idea is to have GStreamer elements that are able to playback "serialized timelines" a.k.a `gesdemux` with a typefind function and simply reuse GESUriClip to p...Basically we need a way to have timelines inside timeline.
The implementation idea is to have GStreamer elements that are able to playback "serialized timelines" a.k.a `gesdemux` with a typefind function and simply reuse GESUriClip to play those. Then we need to be able to serialize projects with nested timelines inside `xges` files, and we want to be able to have several timelines serialized in one single `xges` file so we need a way to determine what timeline to load from the URI basically.
With https://gitlab.freedesktop.org/gstreamer/gst-editing-services/merge_requests/33 we are now able to load serialized timeline, even inside GES with `ges-launch-1.0 +clip file://some/file.xges` which reveals issue in `nlecomposition` but it is all fixable.
See also: https://gitlab.gnome.org/GNOME/pitivi/issues/500https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/issues/176Add bindings for the Tag library2023-02-08T08:07:38ZSebastian DrögeAdd bindings for the Tag libraryEspecially all those additional tag types defined there. They need to be manually implemented, one trait impl per tag type (see `gstreamer/src/tag.rs` for details).Especially all those additional tag types defined there. They need to be manually implemented, one trait impl per tag type (see `gstreamer/src/tag.rs` for details).https://gitlab.freedesktop.org/gstreamer/gst-plugins-base/-/issues/545gstaudioaggregator: segfault in gst_audio_aggregator_aggregate()2021-09-24T13:24:48ZYury Mukhitovgstaudioaggregator: segfault in gst_audio_aggregator_aggregate()GStreamer 1.14.2, OS CentOS 7.3 64-bit
**Problem Description**
`gst_audio_aggregator_aggregate()` function acquires locks on `'agg'` and `'aagg'` then iterates over sink pads:
```
(at gstaudioaggregator.c:1786)
for (; iter; iter = ...GStreamer 1.14.2, OS CentOS 7.3 64-bit
**Problem Description**
`gst_audio_aggregator_aggregate()` function acquires locks on `'agg'` and `'aagg'` then iterates over sink pads:
```
(at gstaudioaggregator.c:1786)
for (; iter; iter = iter->next) {
GstAudioAggregatorPad *pad = (GstAudioAggregatorPad *) iter->data;
GstAggregatorPad *aggpad = (GstAggregatorPad *) iter->data;
gboolean pad_eos = gst_aggregator_pad_is_eos (aggpad);
```
During the pads iteration the `gst_audio_aggregator_mix_buffer()` function gets called which releases the `'pad'` and `'aagg'` locks temporarily:
```
(at gstaudioaggregator.c:1577)
GST_OBJECT_UNLOCK (pad);
GST_OBJECT_UNLOCK (aagg);
filled = GST_AUDIO_AGGREGATOR_GET_CLASS (aagg)->aggregate_one_buffer (aagg,
pad, inbuf, in_offset, outbuf, out_start, overlap);
GST_OBJECT_LOCK (aagg);
GST_OBJECT_LOCK (pad);
```
This makes the removal of a pad from audiomixer possible (executed concurrently from other thread).
The pad removal invalidates current pad iterator because its memory (an element of GList) gets freed.
Next iteration cycle in `gst_audio_aggregator_aggregate()` executes `'iter = iter->next'` then accesses an invalid `'iter'` pointer with `'iter->data'` statement.
This results in a segfault due to dereferencing of invalid pointer. Occasionally this error manifests as a lock up on a mutex in `gst_aggregator_pad_is_eos()`.https://gitlab.freedesktop.org/gstreamer/cerbero/-/issues/114CI doesn't seem to clean-up correctly before starting up2023-01-24T20:58:24ZPhilippe NormandCI doesn't seem to clean-up correctly before starting upIn my -bad fork I have one branch adding autotools support for the WPE plugin and another fixing a memory leak. CI for the second branch failed because of remaining artifacts from the first:
https://gitlab.freedesktop.org/philn/gst-plug...In my -bad fork I have one branch adding autotools support for the WPE plugin and another fixing a memory leak. CI for the second branch failed because of remaining artifacts from the first:
https://gitlab.freedesktop.org/philn/gst-plugins-bad/-/jobs/86861https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/issues/878wpesrc: possible race condition in gst_wpe_src_create()2021-09-24T14:36:56ZPhilippe Normandwpesrc: possible race condition in gst_wpe_src_create()Sometimes the element hits this condition:
```
g_return_val_if_fail(img != NULL, GST_FLOW_ERROR);
```
The element should be able to wait for the first valid EGLImage coming from the WPE backend, filling empty buffers in the mean time.Sometimes the element hits this condition:
```
g_return_val_if_fail(img != NULL, GST_FLOW_ERROR);
```
The element should be able to wait for the first valid EGLImage coming from the WPE backend, filling empty buffers in the mean time.https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/issues/877curlhttpsrc: Delay in playback start with DASH compared to souphttpsrc2021-10-20T07:33:26Zgurram sandeep Reddycurlhttpsrc: Delay in playback start with DASH compared to souphttpsrcI have created a pipeline to play DASH content . Initially the pipeline used souphttpsrc ,now I have replaced it with curlhttpsrc. With curlhttpsrc ,I have observed delay in playback start . When I debugged curlhttpsrc , I found the http...I have created a pipeline to play DASH content . Initially the pipeline used souphttpsrc ,now I have replaced it with curlhttpsrc. With curlhttpsrc ,I have observed delay in playback start . When I debugged curlhttpsrc , I found the http requests are queued and select system call with a timeout of 1s . When I reduced the timeout to 50ms ,I observed same delay as souphttpsrc. Is timeout causing this delay or the delay is due to something else?https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/issues/876Memory leak with curlhttpsrc and adaptivedemux2019-02-19T18:50:19Zgurram sandeep ReddyMemory leak with curlhttpsrc and adaptivedemuxI have a pipeline to play DASH content. I have replaced souphttpsrc with curlhttpsrc but observed memory leaks with curlhttpsrc and adaptivedemux. The pipeline will be created only once and mpd data will be updated on url change(channel...I have a pipeline to play DASH content. I have replaced souphttpsrc with curlhttpsrc but observed memory leaks with curlhttpsrc and adaptivedemux. The pipeline will be created only once and mpd data will be updated on url change(channel Zap). Valgrind shows the leaks as below
* ==2989== 243 bytes in 18 blocks are definitely lost in loss record 7,766 of 8,397
* ==2989== at 0x483E590: malloc (vg_replace_malloc.c:299)
* ==2989== by 0x5058E7F: vasprintf (vasprintf.c:73)
* ==2989== by 0x4D6F28B: g_vasprintf (gprintf.c:316)
* ==2989== by 0x4D4D113: g_strdup_vprintf (gstrfuncs.c:514)
* ==2989== by 0x4D4D137: g_strdup_printf (gstrfuncs.c:540)
* ==2989== by 0x4BC2F57: gst_object_set_name_default (gstobject.c:546)
* ==2989== by 0x4BC2F57: gst_object_set_name (gstobject.c:609)
* ==2989== by 0x51641A7: object_set_property (gobject.c:1421)
* ==2989== by 0x51647B7: g_object_new_internal (gobject.c:1815)
* ==2989== by 0x516618F: g_object_newv (gobject.c:1928)
* ==2989== by 0x5166803: g_object_new (gobject.c:1621)
* ==2989== by 0x4BF790F: gst_element_factory_create (gstelementfactory.c:372)
* ==2989== by 0x4C534AB: gst_element_make_from_uri (gsturi.c:660)
* ==2989== by 0xBEEA1EB: gst_adaptive_demux_stream_update_source (gstadaptivedemux.c:2944)
* ==2989== by 0xBEEA1EB: gst_adaptive_demux_stream_download_uri (gstadaptivedemux.c:3097)
* ==2989== by 0xBEEC42B: gst_adaptive_demux_stream_download_header_fragment (gstadaptivedemux.c:3259)
* ==2989== by 0xBEEC42B: gst_adaptive_demux_stream_download_fragment (gstadaptivedemux.c:3314)
* ==2989== by 0xBEEC42B: gst_adaptive_demux_stream_download_loop (gstadaptivedemux.c:3739)
* ==2989== by 0x4C4C867: gst_task_func (gsttask.c:332)
* ==2989== by 0x4D55C2F: g_thread_pool_thread_proxy (gthreadpool.c:307)
* ==2989== by 0x4D553CF: g_thread_proxy (gthread.c:780)
* ==2989== by 0x4B805D7: start_thread (pthread_create.c:335)
* ==2989== by 0x50A2101: ??? (clone.S:86)
* =2989== 16,220 (720 direct, 15,500 indirect) bytes in 45 blocks are definitely lost in loss record 8,363 of 8,397
* ==2989== at 0x483E590: malloc (vg_replace_malloc.c:299)
* ==2989== by 0x4D398A7: g_malloc (gmem.c:94)
* ==2989== by 0x4D4BCBB: g_slice_alloc (gslice.c:1025)
* ==2989== by 0x4C3E1F3: gst_structure_new_id_empty_with_size (gststructure.c:147)
* ==2989== by 0x4C3FFAB: gst_structure_new_valist (gststructure.c:283)
* ==2989== by 0x4C3FFDF: gst_structure_new (gststructure.c:255)
* ==2989== by 0xD8ACE8F: gst_curl_http_src_handle_response (gstcurlhttpsrc.c:1179)
* ==2989== by 0xD8ACE8F: gst_curl_http_src_create (gstcurlhttpsrc.c:818)
* ==2989== by 0xBDC6DF7: gst_base_src_get_range (gstbasesrc.c:2512)
* ==2989== by 0xBDC8563: gst_base_src_loop (gstbasesrc.c:2836)
* ==2989== by 0x4C4C867: gst_task_func (gsttask.c:332)
* ==2989== by 0x4D55C2F: g_thread_pool_thread_proxy (gthreadpool.c:307)
* ==2989== by 0x4D553CF: g_thread_proxy (gthread.c:780)
* ==2989== by 0x4B805D7: start_thread (pthread_create.c:335)
* ==2989== by 0x50A2101: ??? (clone.S:86)
Valgrind didn't reported curlhttpsrc leak when I freed http_headers. But adaptivedemux leaks are still reported.
[vg.log](/uploads/f705fd96dece5d86208fb430d02e5575/vg.log)https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/issues/875mpegtspacketizer: Not enough information to calculate proper timestamp when p...2022-06-29T09:10:35Zdirac bracketmpegtspacketizer: Not enough information to calculate proper timestamp when playing radio streamHi,
I am on Debian 9.5 using GStreamer 1.10.4 and was trying to get the following radio stream URI to play:
```
http://kong.kbskme.gscdn.com/1fm/_definst_/1fm.stream/playlist.m3u8?_lsu_sa_=3c659434ccaf31a3e487c7ac3f91273d138c6da2308db4...Hi,
I am on Debian 9.5 using GStreamer 1.10.4 and was trying to get the following radio stream URI to play:
```
http://kong.kbskme.gscdn.com/1fm/_definst_/1fm.stream/playlist.m3u8?_lsu_sa_=3c659434ccaf31a3e487c7ac3f91273d138c6da2308db4ff6d84653b703034a987d8defc35733864acfc38d5dcb24358235664fa74b665a0aa1808b70d504d61efebb17d2c38ff66efc58c0f860e1f43
```
This is what the command line output is when using gst-launch-1.0 -v playbin3:
```
umagi@debian:~$ gst-launch-1.0 -v playbin3 uri=http://kong.kbskme.gscdn.com/1fm/_definst_/1fm.stream/playlist.m3u8?_lsu_sa_=3c659434ccaf31a3e487c7ac3f91273d138c6da2308db4ff6d84653b703034a987d8defc35733864acfc38d5dcb24358235664fa74b665a0aa1808b70d504d61efebb17d2c38ff66efc58c0f860e1f43
Setting pipeline to PAUSED ...
Pipeline is PREROLLING ...
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0: ring-buffer-max-size = 0
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0: buffer-size = -1
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0: buffer-duration = -1
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0: use-buffering = false
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0: download = false
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0: uri = http://kong.kbskme.gscdn.com/1fm/_definst_/1fm.stream/playlist.m3u8?_lsu_sa_=3c659434ccaf31a3e487c7ac3f91273d138c6da2308db4ff6d84653b703034a987d8defc35733864acfc38d5dcb24358235664fa74b665a0aa1808b70d504d61efebb17d2c38ff66efc58c0f860e1f43
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0: connection-speed = 0
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0: source = "\(GstSoupHTTPSrc\)\ source"
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0/GstTypeFindElement:typefindelement0.GstPad:src: caps = application/x-hls
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0/GstHLSDemux:hlsdemux0.GstPad:sink: caps = application/x-hls
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0/GstHLSDemux:hlsdemux0.GstPad:src_0: caps = video/mpegts, systemstream=(boolean)true, packetsize=(int)188
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0/GstQueue2:queue2-1.GstPad:sink: caps = video/mpegts, systemstream=(boolean)true, packetsize=(int)188
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0/GstQueue2:queue2-1.GstPad:src: caps = video/mpegts, systemstream=(boolean)true, packetsize=(int)188
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0.GstGhostPad:src_0: caps = video/mpegts, systemstream=(boolean)true, packetsize=(int)188
/GstPlayBin3:playbin3-0/GstDecodebin3:decodebin3-0.GstGhostPad:sink.GstProxyPad:proxypad0: caps = video/mpegts, systemstream=(boolean)true, packetsize=(int)188
/GstPlayBin3:playbin3-0/GstDecodebin3:decodebin3-0/GstParseBin:parsebin0.GstGhostPad:sink.GstProxyPad:proxypad3: caps = video/mpegts, systemstream=(boolean)true, packetsize=(int)188
/GstPlayBin3:playbin3-0/GstDecodebin3:decodebin3-0/GstParseBin:parsebin0/GstTypeFindElement:typefind.GstPad:src: caps = video/mpegts, systemstream=(boolean)true, packetsize=(int)188
/GstPlayBin3:playbin3-0/GstDecodebin3:decodebin3-0/GstParseBin:parsebin0/GstTSDemux:tsdemux0.GstPad:sink: caps = video/mpegts, systemstream=(boolean)true, packetsize=(int)188
/GstPlayBin3:playbin3-0/GstDecodebin3:decodebin3-0/GstParseBin:parsebin0/GstTypeFindElement:typefind.GstPad:sink: caps = video/mpegts, systemstream=(boolean)true, packetsize=(int)188
/GstPlayBin3:playbin3-0/GstDecodebin3:decodebin3-0/GstParseBin:parsebin0.GstGhostPad:sink: caps = video/mpegts, systemstream=(boolean)true, packetsize=(int)188
/GstPlayBin3:playbin3-0/GstDecodebin3:decodebin3-0.GstGhostPad:sink: caps = video/mpegts, systemstream=(boolean)true, packetsize=(int)188
/GstPlayBin3:playbin3-0/GstURISourceBin:urisourcebin0.GstGhostPad:src_0.GstProxyPad:proxypad2: caps = video/mpegts, systemstream=(boolean)true, packetsize=(int)188
/GstPlayBin3:playbin3-0/GstDecodebin3:decodebin3-0/GstParseBin:parsebin0/GstAacParse:aacparse0.GstPad:sink: caps = audio/mpeg, mpegversion=(int)2, stream-format=(string)adts
buffering... 0%
```
But nothing happens.
Since this kind of URI plays OK in VLC this does not seem to be a server-side issue.
Following the suggestions and help of Philippe Normand to my post on this issue on the GStreamer-devel mail list
[read post](http://gstreamer-devel.966125.n4.nabble.com/How-to-play-internet-radio-URL-with-query-td4689399.html), I added the gst.log and the stream.ts capture file in attach.
The gst.log file shows a flurry of warnings of the kind:
```
0:00:00.287885677 6377 0x555e54214630 WARN mpegtspacketizer mpegtspacketizer.c:2331:mpegts_packetizer_pts_to_ts: Not enough information to calculate proper timestamp
```
[gst.log](/uploads/8b0ebdebd3f2383b9ac8b106ef432fb9/gst.log)[stream.ts](/uploads/8b3e74bed7a0e1fe050cf854dd08e397/stream.ts)
Can you have a check?
Thanks!https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/issues/873fdkaacdec: Failed to build using fdk-aac < 0.1.42019-01-25T20:52:25ZYeongjin Jeonggingerbk247@gmail.comfdkaacdec: Failed to build using fdk-aac < 0.1.4With the old versions fdk-aac < 0.1.4 installed, compilation of the fdkaac plugin from git master fails with the following error:
```bash
gstfdkaacdec.c:154:41: error: ‘AAC_PCM_MAX_OUTPUT_CHANNELS’ undeclared (first use in this function...With the old versions fdk-aac < 0.1.4 installed, compilation of the fdkaac plugin from git master fails with the following error:
```bash
gstfdkaacdec.c:154:41: error: ‘AAC_PCM_MAX_OUTPUT_CHANNELS’ undeclared (first use in this function)
err = aacDecoder_SetParam (self->dec, AAC_PCM_MAX_OUTPUT_CHANNELS, 0);
^
```https://gitlab.freedesktop.org/gstreamer/gst-rtsp-server/-/issues/60Add a configuration for max-bitrate2021-09-24T11:03:44ZJuho YlikorpiAdd a configuration for max-bitrateRe-purposed from initial issue:
> UDP streams with large I-frames (4K ip-cameras and even some 1080p) are generating too large UDP burst and those will be dropped by routers/VPN GWs etc. with small buffers (datacenter connections are 10...Re-purposed from initial issue:
> UDP streams with large I-frames (4K ip-cameras and even some 1080p) are generating too large UDP burst and those will be dropped by routers/VPN GWs etc. with small buffers (datacenter connections are 10Gbits but Internet only 100Mbits).
While it's theoretically possible through GstBin::deep-element-added signal to do custom setup on the udpsink, it is likely that these days more and more users will need to control the burst rate. The buffer-size has been exposed similarly if I read the code correctly.https://gitlab.freedesktop.org/gstreamer/gstreamer/-/issues/352harness: caps/segment event sending should be decoupled2021-09-24T11:09:18ZSebastian Drögeharness: caps/segment event sending should be decoupledYou don't always want a new default segment event to be sent when the caps are changed, and you might want to handle segments yourself.
Any ideas for how to do this in a backwards compatible way?You don't always want a new default segment event to be sent when the caps are changed, and you might want to handle segments yourself.
Any ideas for how to do this in a backwards compatible way?https://gitlab.freedesktop.org/gstreamer/gst-libav/-/issues/48invalidate cache when external libav* changes2021-09-24T12:52:30ZRobert McQueeninvalidate cache when external libav* changesEndless OS and Flatpak runtimes with a codecs extension both share the property that in certain cases, libav gets replaced with a more capable version elsewhere on the library search path. The GStreamer caching machinery does not "notice...Endless OS and Flatpak runtimes with a codecs extension both share the property that in certain cases, libav gets replaced with a more capable version elsewhere on the library search path. The GStreamer caching machinery does not "notice" this change (indeed I'm not sure it's monitoring the dependent .so files at all) so in the case of a more capable system libav with more supported codecs, if GStreamer has already built its caches they are not updated and the new codecs are unavailable.
Endless has an ugly patch for this which has been copied into the Flatpak freedesktop-sdk runtime - https://gitlab.com/freedesktop-sdk/freedesktop-sdk/blob/18.08/patches/gst-libav-stop-caching-codecs.patch
This works, in as much as when a more capable libav is provided in an alternative location on the path, the cache is invalidated and refreshed. However it has the obvious downside that this is hardcoding the library search path, which means that if you place a different libav in another location on the library path (particularly in a sandboxed context like Flatpak where the library path can be changed dynamically) it is not noticed.
We could avoid hardcoding the library path and solve this problem more robustly by fetching the path of the currently loaded libav* using dlinfo, and then making the cache validity dependent on the properties of that file, so that if a different one is found by the linker, the cache will be correctly invalidated.
Perhaps in the end you would want to add a function to the registry to allow a dynamic library file cache dependency to be added easily, or you could do this dlinfo lookup in gst-libav as a special case.https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/-/issues/175Survey of functions returning `bool` under workspace `gstreamer-base`2019-02-07T11:22:24ZFrançois LaignelSurvey of functions returning `bool` under workspace `gstreamer-base`Survey of functions returning `bool` under workspace `gstreamer-base`
This is a survey of functions returning bool under workspace `gstreamer-base`. I filtered out the functions which, from their name, obviously return a genuine boole...Survey of functions returning `bool` under workspace `gstreamer-base`
This is a survey of functions returning bool under workspace `gstreamer-base`. I filtered out the functions which, from their name, obviously return a genuine boolean (`is_`, `has_`, ...) as well as the `get_property_xxx` and the `parent_` counterparts in order to reduce the list.
This is part of the discussions in #166 & !196 and a continuation of !200 and !207.
### Proposal
| Function | Location | Gst Function | Proposed Return Type | Optional? | Comment |
| ------------------------------ | -------- | -------------------------------------- | :---------------------------: | :-------: | ------- |
| Aggregator.negotiated_src_caps | subclass | GstAggregatorClass.negotiated_src_caps | `Result<(), LoggableError>` | yes | Notifies subclasses what caps format has been negotiated. **Note:** the return value seems to indicate whether the subclass is OK with the negotiation. @slomo comment: This is always an error it seems, and is basically like set_caps() elsewhere. I think I'd use BoolError here at least instead of a boolean |
| Aggregator.src_activate | subclass | GstAggregatorClass.src_activate | `Result<(), LoggableError>` | yes | Called when the src pad is activated, it will start/stop its pad task right after that call. **Note:** `Pad`'s `activate_function` was changed to `Result<...>` |
| Aggregator.src_event | subclass | GstAggregatorClass.src_event | keep `bool` | yes | Called when an event is received on the src pad, the subclass should always chain up. **Note:** Event fct -> bool |
| Aggregator.src_query | subclass | GstAggregatorClass.src_query | keep `bool` | yes | Called when a query is received on the src pad, the subclass should always chain up. **Note:** Query fct -> bool |
| Aggregator.start | subclass | GstAggregatorClass.start | `Result<(), ErrorMessage>` | yes | Called when the element goes from READY to PAUSED. The subclass should get ready to process aggregated buffers. See § `start` & `stop` below |
| Aggregator.stop | subclass | GstAggregatorClass.stop | `Result<(), ErrorMessage>` | yes | Called when the element goes from PAUSED to READY. The subclass should free all resources and reset its state. See § `start` & `stop` below |
| | | | | | |
| AggregatorPad.drop_buffer | auto | gst_aggregator_pad_drop_buffer | keep `bool` | n/a | Returns TRUE if there was a buffer queued in pad, or FALSE if not. **Note:** not a failure. |
| | | | | | |
| BaseSink.event | subclass | GstBaseSinkClass.sink_event | keep `bool` | yes | Event fct -> bool |
| BaseSink.query | subclass | GstBaseSinkClass.query | keep `bool` | yes | Query fct -> bool |
| BaseSink.set_caps | subclass | GstBaseSinkClass.set_caps | `Result<(), LoggableError>` | yes | Notify subclass of changed caps. |
| BaseSink.start | subclass | GstBaseSinkClass.start | `Result<(), ErrorMessage>` | yes | Start processing. Ideal for opening resources in the subclass. See § `start` & `stop` below |
| BaseSink.stop | subclass | GstBaseSinkClass.stop | `Result<(), ErrorMessage>` | yes | Stop processing. Subclasses should use this to close resources. See § `start` & `stop` below |
| BaseSink.unlock | subclass | GstBaseSinkClass.unlock | `Result<(), ErrorMessage>` | yes | Unlock any pending access to the resource. Subclasses should unblock any blocked function ASAP and call gst_base_sink_wait_preroll(). **Note:** return value is ignored. @slomo comment: This seems like a bug in the C code too (want to send a MR?). If this fails it generally means that everything is broken, so there should be an error message even. |
| BaseSink.unlock_stop | subclass | GstBaseSinkClass.unlock_stop | `Result<(), ErrorMessage>` | yes | Clear the previous unlock request. Subclasses should clear any state they set during GstBaseSinkClass.unlock(), and be ready to continue where they left off after gst_base_sink_wait_preroll(), gst_base_sink_wait() or gst_wait_sink_wait_clock() return or GstBaseSinkClass.render() is called again. **Note:** return value is ignored. See comment for `BaseSink.unlock` |
| | | | | | |
| BaseSrc.do_seek | subclass | GstBaseSinkClass.do_seek | keep `bool` | yes | Perform seeking on the resource to the indicated segment. |
| BaseSrc.event | subclass | GstBaseSinkClass.event | keep `bool` | yes | Event fct -> bool |
| BaseSrc.negotiate | subclass | GstBaseSinkClass.negotiate | `Result<(), LoggableError>` | yes | Negotiated the caps with the peer. |
| BaseSrc.new_seamless_segment | auto | gst_base_src_new_seamless_segment | `()` | n/a | Returns TRUE if preparation of the seamless segment succeeded. @slomo comment: This can literally never fail and should probably become () |
| BaseSrc.query | subclass | GstBaseSinkClass.query | keep `bool` | yes | Query fct -> bool |
| BaseSrc.set_caps | auto | gst_base_src_set_caps | `Result<(), glib::BoolError>` | n/a | Returns TRUE if the caps could be set. |
| BaseSrc.set_caps | subclass | GstBaseSinkClass.set_caps | `Result<(), LoggableError>` | yes | Notify the subclass of new caps. |
| BaseSrc.start | subclass | GstBaseSinkClass.start | `Result<(), ErrorMessage>` | yes | Start processing. Subclasses should open resources and prepare to produce data. Implementation should call gst_base_src_start_complete() when the operation completes, either from the current thread or any other thread that finishes the start operation asynchronously. See § `start` & `stop` below |
| BaseSrc.stop | subclass | GstBaseSinkClass.stop | `Result<(), ErrorMessage>` | yes | Stop processing. Subclasses should use this to close resources. See § `start` & `stop` below |
| BaseSrc.unlock | subclass | GstBaseSinkClass.unlock | `Result<(), ErrorMessage>` | yes | Unlock any pending access to the resource. Subclasses should unblock any blocked function ASAP and call gst_base_sink_wait_preroll(). **Note:** return value is ignored. See comment for `BaseSink.unlock` |
| BaseSrc.unlock_stop | subclass | GstBaseSinkClass.unlock_stop | `Result<(), ErrorMessage>` | yes | Clear the previous unlock request. Subclasses should clear any state they set during GstBaseSinkClass.unlock(), and be ready to continue where they left off after gst_base_sink_wait_preroll(), gst_base_sink_wait() or gst_wait_sink_wait_clock() return or GstBaseSinkClass.render() is called again. **Note:** return value is ignored. See comment for `BaseSink.unlock` |
| | | | | | |
| BaseTransform.sink_event | subclass | BaseTransformClass.sink_event | keep `bool` | yes | Event fct -> bool |
| BaseTransform.src_event | subclass | BaseTransformClass.src_event | keep `bool` | yes | Event fct -> bool |
| BaseTransform.start | subclass | BaseTransformClass.start | `Result<(), ErrorMessage>` | yes | Called when the element starts processing. Allows opening external resources. See § `start` & `stop` below |
| BaseTransform.stop | subclass | BaseTransformClass.stop | `Result<(), ErrorMessage>` | yes | Called when the element stops processing. Allows closing external resources. See § `start` & `stop` below |
| BaseTransform.update_src_caps | auto | gst_base_transform_update_src_caps | `Result<(), glib::BoolError>` | n/a | Returns TRUE if the caps could be sent downstream FALSE otherwise |
Edit: updated with feedback from @slomo.
Edit: update further to https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/issues/175#note_106495 and https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/merge_requests/214.
### `start` & `stop`
In https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/issues/166 and https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/merge_requests/196,
we were considering using `Result<(), ErrorMessage>` as the return type for the `start` and `stop` functions. The idea was to make it mandatory
for the implementer to characterize the error. The binding would take care of tracing the error and when it makes sense it would post the message on the bus.
In the table below, I tried to synthesize the behaviour of the `start` and `stop` function in the classes where they appear:
| Function | Trace when fct returns `FALSE` | Msg posted on the bus | Consequence |
| --------------------- | ---------------------------------- | ----------------------------------------- | ----------------------------------------------------- |
| `Aggregator.start` | ERROR "Subclass failed to start" | None | `xxx_change_state` returns `GST_STATE_CHANGE_FAILURE` |
| `Aggregator.stop` | ERROR "Subclass failed to stop." | None | None (`change_state` returns parent's `ret`) |
| | | | |
| `BaseSink.start` | DEBUG "failed to start" | ERROR CORE STATE_CHANGE "Failed to start" | `xxx_change_state` returns `GST_STATE_CHANGE_FAILURE` |
| `BaseSink.stop` | WARNING "failed to stop" | None | `xxx_change_state` returns `GST_STATE_CHANGE_SUCCESS` |
| | | | |
| `BaseSrc.start` | DEBUG "could not start" | ERROR CORE STATE_CHANGE "Failed to start" | `xxx_activate_mode` returns `FALSE` |
| `BaseSrc.stop` | DEBUG "Failed to stop in XXX mode" | None | `xxx_activate_mode` returns `FALSE` |
| | | | |
| `BaseTransform.start` | None | None | `xxx_activate_mode` returns `FALSE` |
| `BaseTransform.stop` | None | None | `xxx_activate_mode` returns `FALSE` |
Each class has its own way of dealing with the `start` / `stop` failure. `BaseSink.start` & `BaseSrc.start` already post a message on the bus.
Maybe it would be better to let the implementer in charge of the specific tracing / posting on the bus. If we'd adopted this approach, would it still
make sense to use `Result<(), ErrorMessage>`? How about just `Result<(), glib::BoolError>` since `glib::BoolError` embeds the error
building location now?
See reponse from @slomo in https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/issues/175#note_105923 and https://gitlab.freedesktop.org/gstreamer/gstreamer-rs/issues/175#note_106331https://gitlab.freedesktop.org/gstreamer/gst-template/-/issues/1Add meson.build templates2019-12-21T11:24:13ZAntonio OspiteAdd meson.build templatesIt would be useful to have a `meson.build` template to use for plugins.
Not sure when I can work on that myself so for now I am just reporting the idea in case anyone is interested to work on it.
Thank you.
AntonioIt would be useful to have a `meson.build` template to use for plugins.
Not sure when I can work on that myself so for now I am just reporting the idea in case anyone is interested to work on it.
Thank you.
Antoniohttps://gitlab.freedesktop.org/gstreamer/cerbero/-/issues/113gettext generating different output2019-01-20T07:09:18Zsprhawkgettext generating different outputI'm using latest Cerbero repo to build gst-python and pitivi from (https://github.com/sprhawk/cerbero-pitivi)
when I use `Cerbero-uninstalled build some-software`, which depends on gettext, gettext generated libintl.dylib may include _g...I'm using latest Cerbero repo to build gst-python and pitivi from (https://github.com/sprhawk/cerbero-pitivi)
when I use `Cerbero-uninstalled build some-software`, which depends on gettext, gettext generated libintl.dylib may include _g_libintl_xxxxx symbols
```
000000000000102c S __nl_msg_cat_cntr
0000000000000db0 T __proxy_libintl_deinit
0000000000001020 b _current_domain
U _free
0000000000000f50 T _g_libintl_bind_textdomain_codeset
0000000000000f30 T _g_libintl_bindtextdomain
0000000000000e20 T _g_libintl_dcgettext
0000000000000ea0 T _g_libintl_dcngettext
0000000000000e00 T _g_libintl_dgettext
0000000000000e70 T _g_libintl_dngettext
0000000000000de0 T _g_libintl_gettext
0000000000000e40 T _g_libintl_ngettext
0000000000000ed0 T _g_libintl_textdomain
0000000000001028 b _setup.beenhere
U _strdup
U dyld_stub_binder
```
, but some libs need _libintl_xxxxx,
when use `Cerbero-uninstalled buildone gettext`, it will generate _libintl_xxxxx,
```
U _CFArrayGetCount
U _CFArrayGetTypeID
U _CFArrayGetValueAtIndex
U _CFGetTypeID
U _CFLocaleCopyCurrent
U _CFLocaleGetIdentifier
U _CFPreferencesCopyAppValue
U _CFRelease
U _CFStringGetCString
U _CFStringGetTypeID
U __DefaultRuneLocale
U ___CFConstantStringClassReference
U ____mb_cur_max_l
U ___error
U ___maskrune
U ___stack_chk_fail
U ___stack_chk_guard
U ___tolower
0000000000004130 T __nl_expand_alias
000000000000a6e8 b __nl_expand_alias.locale_alias_path
0000000000004e80 t __nl_explode_name
0000000000002330 t __nl_find_domain
000000000000a330 d __nl_find_domain.lock
00000000000058f0 t __nl_find_msg
000000000000a730 b __nl_find_msg.freemem
000000000000a738 b __nl_find_msg.freemem_size
000000000000a610 d __nl_find_msg.lock
00000000000073c0 t __nl_language_preferences_default
000000000000a780 b __nl_language_preferences_default.cache_initialized
000000000000a778 b __nl_language_preferences_default.cached_languages
00000000000025e0 t __nl_load_domain
000000000000a3f8 d __nl_load_domain.lock
000000000000a6e0 b __nl_loaded_domains
0000000000007c00 t __nl_locale_name
0000000000007620 t __nl_locale_name_canonicalize
0000000000009c00 s __nl_locale_name_canonicalize.langtag_table
0000000000008da0 s __nl_locale_name_canonicalize.legacy_table
0000000000009cb0 s __nl_locale_name_canonicalize.script_table
0000000000007b40 t __nl_locale_name_default
000000000000a790 b __nl_locale_name_default.cached_localename
0000000000007ad0 t __nl_locale_name_environ
0000000000007a60 t __nl_locale_name_posix
00000000000078b0 t __nl_locale_name_thread
0000000000007860 t __nl_locale_name_thread_unsafe
0000000000007c90 t __nl_log_untranslated
0000000000004870 t __nl_make_l10nflist
000000000000afb8 S __nl_msg_cat_cntr
0000000000004cf0 t __nl_normalize_codeset
000000000000a480 d __nl_state_lock
U _abort
0000000000004260 t _alias_compare
0000000000008490 T _bind_textdomain_codeset
0000000000008480 T _bindtextdomain
U _bsearch
U _calloc
000000000000a750 b _charset_aliases
U _close
000000000000a760 b _curr_prefix
000000000000a770 b _curr_prefix_len
0000000000008430 T _dcgettext
0000000000008460 T _dcngettext
0000000000008420 T _dgettext
0000000000008450 T _dngettext
000000000000a728 b _enable_secure
U _fclose
U _fgets
U _fopen$DARWIN_EXTSN
U _fputs
U _free
U _freelocale
U _fstat$INODE64
U _fwrite
000000000000a740 b _get_output_charset.output_charset_cache
000000000000a748 b _get_output_charset.output_charset_cached
U _getcwd
U _getegid
U _getenv
U _geteuid
U _getgid
0000000000008410 T _gettext
U _getuid
U _iconv
U _iconv_open
0000000000007070 t _intl_locale_charset
U _kCFPreferencesCurrentApplication
000000000000afb0 b _last_logfile
000000000000afa8 b _last_logfilename
U _libiconv_set_relocation_prefix
00000000000022b0 T _libintl_bind_textdomain_codeset
0000000000001f00 T _libintl_bindtextdomain
00000000000022e0 T _libintl_dcgettext
0000000000005060 t _libintl_dcigettext
0000000000006370 T _libintl_dcngettext
0000000000002300 T _libintl_dgettext
0000000000006390 T _libintl_dngettext
0000000000002310 T _libintl_gettext
0000000000006f40 t _libintl_gettext_extract_plural
0000000000006ef0 t _libintl_gettext_free_exp
000000000000a2b8 s _libintl_gettext_germanic_plural
00000000000063d0 t _libintl_gettextparse
0000000000002590 t _libintl_hash_string
0000000000008240 T _libintl_newlocale
0000000000009d00 s _libintl_newlocale.categories
00000000000063a0 T _libintl_ngettext
000000000000a478 d _libintl_nl_current_default_domain
0000000000008960 s _libintl_nl_default_default_domain
0000000000008970 s _libintl_nl_default_dirname
000000000000afc0 s _libintl_nl_domain_bindings
00000000000071f0 t _libintl_once_singlethreaded
0000000000007160 t _libintl_recursive_lock_init_multithreaded
00000000000072e0 t _libintl_relocate
0000000000007210 T _libintl_set_relocation_prefix
0000000000007f70 T _libintl_setlocale
0000000000004790 T _libintl_textdomain
000000000000a6d0 D _libintl_version
000000000000a438 d _lock
000000000000a690 d _lock
U _malloc
000000000000a6f8 b _map
000000000000a700 b _maxmap
U _memcpy
U _mmap
U _munmap
U _newlocale
0000000000008440 T _ngettext
U _nl_langinfo
000000000000a6f0 b _nmap
U _open
000000000000a758 b _orig_prefix
000000000000a768 b _orig_prefix_len
0000000000008be0 s _plone
00000000000061c0 t _plural_eval
0000000000008bc0 s _plvar
0000000000007ea0 t _print_escaped
U _pthread_mutex_init
U _pthread_mutex_lock
U _pthread_mutex_unlock
U _pthread_mutexattr_destroy
U _pthread_mutexattr_init
U _pthread_mutexattr_settype
U _pthread_rwlock_init
U _pthread_rwlock_rdlock
U _pthread_rwlock_unlock
U _pthread_rwlock_wrlock
U _putc
U _qsort
U _querylocale
U _read
0000000000004270 t _read_alias_file
0000000000008950 s _read_alias_file.aliasfile
U _realloc
000000000000a720 b _root
0000000000001f30 t _set_binding_values
U _setlocale
U _stpcpy
U _strcasecmp
U _strchr
U _strcmp
U _strcpy
U _strcspn
U _strdup
000000000000a718 b _string_space
000000000000a708 b _string_space_act
000000000000a710 b _string_space_max
U _strlen
U _strncmp
U _strstr
U _strtoul
000000000000a7a0 b _struniq_hash_table
000000000000a650 d _struniq_lock
0000000000008470 T _textdomain
U _tfind
0000000000005890 t _transcmp
000000000000a548 d _tree_lock
U _tsearch
U _uselocale
0000000000008b00 s _yycheck
0000000000008b80 s _yydefact
0000000000008bba s _yydefgoto
00000000000089d0 s _yypact
0000000000008bb7 s _yypgoto
0000000000008ba9 s _yyr1
0000000000008b9b s _yyr2
0000000000008b40 s _yytable
00000000000089f0 s _yytranslate
U dyld_stub_binder
hongbo:lib (pitivi) $nm libintl.dylib
U _CFArrayGetCount
U _CFArrayGetTypeID
U _CFArrayGetValueAtIndex
U _CFGetTypeID
U _CFLocaleCopyCurrent
U _CFLocaleGetIdentifier
U _CFPreferencesCopyAppValue
U _CFRelease
U _CFStringGetCString
U _CFStringGetTypeID
U __DefaultRuneLocale
U ___CFConstantStringClassReference
U ____mb_cur_max_l
U ___error
U ___maskrune
U ___stack_chk_fail
U ___stack_chk_guard
U ___tolower
0000000000004130 T __nl_expand_alias
000000000000a6e8 b __nl_expand_alias.locale_alias_path
0000000000004e80 t __nl_explode_name
0000000000002330 t __nl_find_domain
000000000000a330 d __nl_find_domain.lock
00000000000058f0 t __nl_find_msg
000000000000a730 b __nl_find_msg.freemem
000000000000a738 b __nl_find_msg.freemem_size
000000000000a610 d __nl_find_msg.lock
00000000000073c0 t __nl_language_preferences_default
000000000000a780 b __nl_language_preferences_default.cache_initialized
000000000000a778 b __nl_language_preferences_default.cached_languages
00000000000025e0 t __nl_load_domain
000000000000a3f8 d __nl_load_domain.lock
000000000000a6e0 b __nl_loaded_domains
0000000000007c00 t __nl_locale_name
0000000000007620 t __nl_locale_name_canonicalize
0000000000009c00 s __nl_locale_name_canonicalize.langtag_table
0000000000008da0 s __nl_locale_name_canonicalize.legacy_table
0000000000009cb0 s __nl_locale_name_canonicalize.script_table
0000000000007b40 t __nl_locale_name_default
000000000000a790 b __nl_locale_name_default.cached_localename
0000000000007ad0 t __nl_locale_name_environ
0000000000007a60 t __nl_locale_name_posix
00000000000078b0 t __nl_locale_name_thread
0000000000007860 t __nl_locale_name_thread_unsafe
0000000000007c90 t __nl_log_untranslated
0000000000004870 t __nl_make_l10nflist
000000000000afb8 S __nl_msg_cat_cntr
0000000000004cf0 t __nl_normalize_codeset
000000000000a480 d __nl_state_lock
U _abort
0000000000004260 t _alias_compare
0000000000008490 T _bind_textdomain_codeset
0000000000008480 T _bindtextdomain
U _bsearch
U _calloc
000000000000a750 b _charset_aliases
U _close
000000000000a760 b _curr_prefix
000000000000a770 b _curr_prefix_len
0000000000008430 T _dcgettext
0000000000008460 T _dcngettext
0000000000008420 T _dgettext
0000000000008450 T _dngettext
000000000000a728 b _enable_secure
U _fclose
U _fgets
U _fopen$DARWIN_EXTSN
U _fputs
U _free
U _freelocale
U _fstat$INODE64
U _fwrite
000000000000a740 b _get_output_charset.output_charset_cache
000000000000a748 b _get_output_charset.output_charset_cached
U _getcwd
U _getegid
U _getenv
U _geteuid
U _getgid
0000000000008410 T _gettext
U _getuid
U _iconv
U _iconv_open
0000000000007070 t _intl_locale_charset
U _kCFPreferencesCurrentApplication
000000000000afb0 b _last_logfile
000000000000afa8 b _last_logfilename
U _libiconv_set_relocation_prefix
00000000000022b0 T _libintl_bind_textdomain_codeset
0000000000001f00 T _libintl_bindtextdomain
00000000000022e0 T _libintl_dcgettext
0000000000005060 t _libintl_dcigettext
0000000000006370 T _libintl_dcngettext
0000000000002300 T _libintl_dgettext
0000000000006390 T _libintl_dngettext
0000000000002310 T _libintl_gettext
0000000000006f40 t _libintl_gettext_extract_plural
0000000000006ef0 t _libintl_gettext_free_exp
000000000000a2b8 s _libintl_gettext_germanic_plural
00000000000063d0 t _libintl_gettextparse
0000000000002590 t _libintl_hash_string
0000000000008240 T _libintl_newlocale
0000000000009d00 s _libintl_newlocale.categories
00000000000063a0 T _libintl_ngettext
000000000000a478 d _libintl_nl_current_default_domain
0000000000008960 s _libintl_nl_default_default_domain
0000000000008970 s _libintl_nl_default_dirname
000000000000afc0 s _libintl_nl_domain_bindings
00000000000071f0 t _libintl_once_singlethreaded
0000000000007160 t _libintl_recursive_lock_init_multithreaded
00000000000072e0 t _libintl_relocate
0000000000007210 T _libintl_set_relocation_prefix
0000000000007f70 T _libintl_setlocale
0000000000004790 T _libintl_textdomain
000000000000a6d0 D _libintl_version
000000000000a438 d _lock
000000000000a690 d _lock
U _malloc
000000000000a6f8 b _map
000000000000a700 b _maxmap
U _memcpy
U _mmap
U _munmap
U _newlocale
0000000000008440 T _ngettext
U _nl_langinfo
000000000000a6f0 b _nmap
U _open
000000000000a758 b _orig_prefix
000000000000a768 b _orig_prefix_len
0000000000008be0 s _plone
00000000000061c0 t _plural_eval
0000000000008bc0 s _plvar
0000000000007ea0 t _print_escaped
U _pthread_mutex_init
U _pthread_mutex_lock
U _pthread_mutex_unlock
U _pthread_mutexattr_destroy
U _pthread_mutexattr_init
U _pthread_mutexattr_settype
U _pthread_rwlock_init
U _pthread_rwlock_rdlock
U _pthread_rwlock_unlock
U _pthread_rwlock_wrlock
U _putc
U _qsort
U _querylocale
U _read
0000000000004270 t _read_alias_file
0000000000008950 s _read_alias_file.aliasfile
U _realloc
000000000000a720 b _root
0000000000001f30 t _set_binding_values
U _setlocale
U _stpcpy
U _strcasecmp
U _strchr
U _strcmp
U _strcpy
U _strcspn
U _strdup
000000000000a718 b _string_space
000000000000a708 b _string_space_act
000000000000a710 b _string_space_max
U _strlen
U _strncmp
U _strstr
U _strtoul
000000000000a7a0 b _struniq_hash_table
000000000000a650 d _struniq_lock
0000000000008470 T _textdomain
U _tfind
0000000000005890 t _transcmp
000000000000a548 d _tree_lock
U _tsearch
U _uselocale
0000000000008b00 s _yycheck
0000000000008b80 s _yydefact
0000000000008bba s _yydefgoto
00000000000089d0 s _yypact
0000000000008bb7 s _yypgoto
0000000000008ba9 s _yyr1
0000000000008b9b s _yyr2
0000000000008b40 s _yytable
00000000000089f0 s _yytranslate
U dyld_stub_binder
```
but other libs need _g_libintl_xxxxx