Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Buffering issues - is there a way to buffer ahead multiple segments? #8

Closed
glennguy opened this issue Dec 23, 2016 · 12 comments
Closed

Comments

@glennguy
Copy link
Contributor

I'm having an issue with a VOD provider in Australia that has very inconsistent download speeds/response times. It's being delivered through akamai cdn. Other providers that have higher bitrates have no issues. The android app for this service has no problems either, as it seems to fetch around 50 segments or so at a time so any sort of intermittent speed drop doesn't affect playback, whereas in Kodi it almost seems to have a buffer of 1 segment, and some of the 400kb segments can take up to 2000ms to download causing loss of continuous playback.

Is there a way to implement a segment buffer, whether it be manually or dynamically sized, in inputstream.adaptive? Or is this the responsibility of the inputstream interface itself?

I'm on a 60Mbps connection, I'm certain that it's not the issue.

@peak3d
Copy link
Contributor

peak3d commented Jan 24, 2017

Yep, it's a point on my todo list

@DjDiabolik
Copy link

I have a similar question about buffering........ i know the imputstream.adaptive it's also used by Recent version of youtube addons by jdf76.

I have tryed to make this question of official thread (here my question -> http://forum.kodi.tv/showthread.php?pid=2526482#pid2526482) and it's suggest to me to try to ask to imputstream boys and i'm here for this:

I have so many problems whit youtube video...... i obtain so various buffering problems almost of 90% of video i try to watch. Sometime it's impossible also get back to beginning of video....... the only ways to obtain a watchable video it's to remove if from playlist of kodi and try to re-load and sometime it's work.

But the problems it's..... previously when youtube addons doesn't use the imputstream i never obtain buffering problems (i have a italian 20MB/s adsl... every my speedtest it's pass the 15MB/s at media and sometime i reach 18/19MB/s) and i thinks it's probally i have wrong configure the imputstream..... for example:
What's the exact value i need to put in max and mix bandwidth ? On Max i have put 20.000.000 and i thinks this is my maxium speed but how it's work the min ?
How i can correctly set this value ?? I have tryed to put this value to 1.000.000 and buffering problems.... i have tryed to set at 10.000.000 buffering problems...... i have also tryed to put at 0 but nothings can help me.
On Max Resolution i have set to 720p because also when no imputstream has been used i ever use the youtube addons whit this max resolution and i never obtain problems whit caching (even at a time I could make the video full caching as soon immediatelly after the reproduction start) but now it does not seem to cache even for 10 seconds.....

@peak3d
Copy link
Contributor

peak3d commented Mar 12, 2017

In most cases not the bandwidth of your home connection is sthe issue, its the bandwith from the provider (youtube servers).

Normally you let all at default settings (0,0,Auto) and things work Ok.
But as written above, the field of improvements regarding buffering is hugr (currently only the 8 sek. internal kodi buffer is used), but as long most major VOD's run finde with this implementation I don't feel such a pressure.

Because I have heared off the YT issues in the last time, I'll fucus on it next (after a rough buffer improvement inside inputstream.adaptive wich comes together with bitrate switching)

@matthuisman
Copy link
Contributor

matthuisman commented Sep 21, 2018

I just struck this issue as well with a provider (DStv) which use akamai.
They are using MPD with Widevine for live streams.
KODI cache settings have no affect (as others have found)

Just real choppy. Almost like it's just slightly not keeping up.
Plays for a few seconds, shows buffering for a second and repeat.

Oddly, changing the quality of the stream has no affect.

@dgktkr
Copy link

dgktkr commented Jan 3, 2019

I'm running into buffering issues with plugin.video.netflix which uses inputstream.adaptive. I believe increasing the buffer size for incoming video streams would fix the problem. If I can find where in the code this is done, I'm inclined to edit my instance of the plugin.

Can anyone give me a pointer to where this is done in the inputstream.adaptive code?

@basrieter
Copy link

I had users reporting similar issues.

@V10lator
Copy link

Any news about this two years old issue? It's really annoying when DRM content hangs every few seconds on a kodi box while it runs just fine in browser or the official mobile app of the content server.

Just as @dgktkr I would be willing to help code / create a pull request but I don't have the time to read me into the codes, so a hint about where to look would be great.

@peak3d
Copy link
Contributor

peak3d commented Feb 13, 2019

It's not only buffering which solves issues here, it the combination of bit stream switch to lower bandwidth / resolution streams bundled with more buffering on good times.

Its not as simple as you may thing, you have ~10 different streams with different resolutions / bandwidth, which one do you want to buffer ahead? Most likely not the best one, because it is most likely to slow.

What happens if you download a low quality one and during that the speed increases? Skip the low res onse and start again with higher res? Go backwards and replace all slow res with already buffered high res?

There are tons of things to respect if you want to make it smart. If you don't have time to read in code, you most likely have no time to make an approach which is futur safe @V10lator .

Because of the complexity / my limited time for this I'm looking for dev power with some experience and lot of time :-)

@V10lator
Copy link

V10lator commented Feb 13, 2019

Thanks for the reply. I think a valid (I think youtube in the web browser does this, for example, but take this with a grain of salt) but maybe quick&dirty solution would be (simplified pseudo code) :
Try the best resolution possible and measure the incoming bandwith.
If minimum resolution is lower than maximum resolution execute the following in a loop:
If data gets in too slow and we're not at minimum resolution switch to next lower resolution stream.
Else if data gets in too fast and we're not at maximum resolution switch to next higher resolution,

Again, this is quick&dirty but should work and should be fairly simple to implement (again: I don't know the codes, so sorry if I'm wrong about that). After that implementation has been done it can be exchanged with some better algorithm at any time. It would just be nice for the users to have something until a better solution pops in.

//EDIT: Also you could make this adaption algo an optional setting in case some weird content providers or bad internet connections switches bandwith too fast or maybe even detect bandwith changes per timeslice (maybe minute?) and if it's too much just go lower but not higher anymore.

//EDIT²: Or remove the else if completely and just go lower from the beginning as it's unlikely for the bandwith to get higher and stay stable at that new, higher bandwith. In any case you might want to measure the average bandwith over some time as small fluctations are normal and should be ignored (except the buffer gets almost empty after being fully filled, that may be a corner case to handle).

//EDIT³: Or maybe even simpler: Start with highest. After buffer is filled > some % (maybe 50%) check fill state and if gets too low (<10% or something like that, so it's likely to interrupt the stream anyway) switch to next lower stream and start from the beginning. Also check if buffer needs to long to get filled to the initial 50% and if so go lower, too.

@peak3d
Copy link
Contributor

peak3d commented Feb 13, 2019

Biggest issue is, that the code is grown. At the time I started with this project, my only goal was to get amazon back. I have't realy expected that it will be used by > 100 content providers nowdays.

-> Cleanup required, Even I did already some cleanup and preparation steps, you'll have to analyze the full workflow including decryption (which is affcted by stream changes, too).

There is no real way to hack things into it without respecting the final goal. I believe, that this year will be done some work on it, there are dev options which haven't been there before.

@yoshimo
Copy link

yoshimo commented Feb 4, 2020

@peak3d has the situation with the code cleanup become good enough to justify work on this issue again?

@glennguy
Copy link
Contributor Author

glennguy commented Jun 9, 2021

Closing in favor of newer issue #392

@glennguy glennguy closed this as completed Jun 9, 2021
dobo90 added a commit to dobo90/inputstream.adaptive that referenced this issue Feb 8, 2023
* Add sleep inside AdaptiveTree.cpp to trigger the issue

From Kodi logs:

2023-02-08 18:02:11.679 T:22020    info <general>: Creating InputStream
2023-02-08 18:02:11.691 T:22020    info <general>: AddOnLog: inputstream.adaptive: [Repr. chooser] Resolution set: 4096x2304, max allowed: 8152x4436, Adjust refresh rate: 0
2023-02-08 18:02:11.989 T:22020    info <general>: AddOnLog: inputstream.adaptive: Successfully parsed manifest file (Periods: 1, Streams in first period: 2, Type: live)
2023-02-08 18:02:12.989 T:22024   error <general>: AddOnLog: inputstream.adaptive: SegmentUpdateWorker: DEBUG before RefreshLiveSegments()
2023-02-08 18:02:13.028 T:22020    info <general>: Creating Demuxer
2023-02-08 18:02:13.029 T:22020    info <general>: Opening stream: 1006 source: 256
2023-02-08 18:02:13.114 T:22024   error <general>: AddOnLog: inputstream.adaptive: SegmentUpdateWorker: DEBUG after RefreshLiveSegments()
2023-02-08 18:02:13.160 T:22020   error <general>: AddOnLog: inputstream.adaptive: DEBUG before sleep()
2023-02-08 18:02:14.114 T:22024   error <general>: AddOnLog: inputstream.adaptive: SegmentUpdateWorker: DEBUG before RefreshLiveSegments()
2023-02-08 18:02:14.135 T:22024   error <general>: AddOnLog: inputstream.adaptive: SegmentUpdateWorker: DEBUG after RefreshLiveSegments()
2023-02-08 18:02:15.135 T:22024   error <general>: AddOnLog: inputstream.adaptive: SegmentUpdateWorker: DEBUG before RefreshLiveSegments()
2023-02-08 18:02:15.155 T:22024   error <general>: AddOnLog: inputstream.adaptive: SegmentUpdateWorker: DEBUG after RefreshLiveSegments()
2023-02-08 18:02:16.155 T:22024   error <general>: AddOnLog: inputstream.adaptive: SegmentUpdateWorker: DEBUG before RefreshLiveSegments()
2023-02-08 18:02:16.161 T:22020   error <general>: AddOnLog: inputstream.adaptive: DEBUG after sleep()

Address sanitizer report:

==21945==ERROR: AddressSanitizer: heap-use-after-free on address 0x7f402596e960 at pc 0x7f40131c4944 bp 0x7f402616de50 sp 0x7f402616de40
READ of size 8 at 0x7f402596e960 thread T53
    #0 0x7f40131c4943 in adaptive::AdaptiveStream::start_stream() /home/dobo/kodi/inputstream.adaptive/src/common/AdaptiveStream.cpp:610
    xbmc#1 0x7f4013178317 in CInputStreamAdaptive::OpenStream(int) /home/dobo/kodi/inputstream.adaptive/src/main.cpp:309
    xbmc#2 0x7f4013187f07 in kodi::addon::CInstanceInputStream::ADDON_OpenStream(AddonInstance_InputStream const*, int) (/usr/lib/kodi/addons/inputstream.adaptive/inputstream.adaptive.so.20.3.2+0x387f07)
    xbmc#3 0x55abad48474b in CDVDDemuxClient::OpenStream(int) (/usr/lib/kodi/kodi.bin+0xb7c74b)
    xbmc#4 0x55abad508385 in CVideoPlayer::OpenStream(CCurrentStream&, long, int, int, bool) (/usr/lib/kodi/kodi.bin+0xc00385)
    xbmc#5 0x55abad508bba in CVideoPlayer::OpenDefaultStreams(bool) (/usr/lib/kodi/kodi.bin+0xc00bba)
    xbmc#6 0x55abad50a857 in CVideoPlayer::Prepare() (/usr/lib/kodi/kodi.bin+0xc02857)
    xbmc#7 0x55abad510d45 in CVideoPlayer::Process() (/usr/lib/kodi/kodi.bin+0xc08d45)
    xbmc#8 0x55abad758396 in CThread::Action() (/usr/lib/kodi/kodi.bin+0xe50396)
    xbmc#9 0x55abae0f0e24  (/usr/lib/kodi/kodi.bin+0x17e8e24)
    xbmc#10 0x55abad755dba  (/usr/lib/kodi/kodi.bin+0xe4ddba)
    xbmc#11 0x7f403d4d72c2 in execute_native_thread_routine /usr/src/debug/gcc/gcc/libstdc++-v3/src/c++11/thread.cc:82
    xbmc#12 0x7f403dd8cbb4  (/usr/lib/libc.so.6+0x85bb4)
    xbmc#13 0x7f403de0ed8f  (/usr/lib/libc.so.6+0x107d8f)

0x7f402596e960 is located 303456 bytes inside of 303840-byte region [0x7f4025924800,0x7f402596eae0)
freed by thread T57 here:
    #0 0x7f403fac178a in operator delete(void*, unsigned long) /usr/src/debug/gcc/gcc/libsanitizer/asan/asan_new_delete.cpp:164
    xbmc#1 0x7f40131de17d in std::__new_allocator<adaptive::AdaptiveTree::Segment>::deallocate(adaptive::AdaptiveTree::Segment*, unsigned long) /usr/include/c++/12.2.1/bits/new_allocator.h:158
    xbmc#2 0x7f40131d974a in std::allocator_traits<std::allocator<adaptive::AdaptiveTree::Segment> >::deallocate(std::allocator<adaptive::AdaptiveTree::Segment>&, adaptive::AdaptiveTree::Segment*, unsigned long) /usr/include/c++/12.2.1/bits/alloc_traits.h:496
    xbmc#3 0x7f40131d33cb in std::_Vector_base<adaptive::AdaptiveTree::Segment, std::allocator<adaptive::AdaptiveTree::Segment> >::_M_deallocate(adaptive::AdaptiveTree::Segment*, unsigned long) /usr/include/c++/12.2.1/bits/stl_vector.h:387
    xbmc#4 0x7f40131edabd in std::_Vector_base<adaptive::AdaptiveTree::Segment, std::allocator<adaptive::AdaptiveTree::Segment> >::~_Vector_base() /usr/include/c++/12.2.1/bits/stl_vector.h:366
    xbmc#5 0x7f40131edb57 in std::vector<adaptive::AdaptiveTree::Segment, std::allocator<adaptive::AdaptiveTree::Segment> >::~vector() /usr/include/c++/12.2.1/bits/stl_vector.h:733
    xbmc#6 0x7f40131ea67f in adaptive::SPINCACHE<adaptive::AdaptiveTree::Segment>::~SPINCACHE() /home/dobo/kodi/inputstream.adaptive/src/common/AdaptiveTree.h:44
    xbmc#7 0x7f40131eae13 in adaptive::AdaptiveTree::Representation::~Representation() /home/dobo/kodi/inputstream.adaptive/src/common/AdaptiveTree.h:208
    xbmc#8 0x7f40131eb5c2 in adaptive::AdaptiveTree::AdaptationSet::~AdaptationSet() /home/dobo/kodi/inputstream.adaptive/src/parser/../common/AdaptiveTree.h:326
    xbmc#9 0x7f40131ecef6 in adaptive::AdaptiveTree::Period::~Period() /home/dobo/kodi/inputstream.adaptive/src/parser/../common/AdaptiveTree.h:462
    xbmc#10 0x7f40131e19ef in adaptive::AdaptiveTree::~AdaptiveTree() /home/dobo/kodi/inputstream.adaptive/src/common/AdaptiveTree.cpp:92
    xbmc#11 0x7f401323f6a4 in adaptive::DASHTree::~DASHTree() /home/dobo/kodi/inputstream.adaptive/src/parser/DASHTree.h:16
    xbmc#12 0x7f401323f6bf in adaptive::DASHTree::~DASHTree() /home/dobo/kodi/inputstream.adaptive/src/parser/DASHTree.h:16
    xbmc#13 0x7f401323f73c in std::default_delete<adaptive::DASHTree>::operator()(adaptive::DASHTree*) const /usr/include/c++/12.2.1/bits/unique_ptr.h:95
    xbmc#14 0x7f401323c926 in std::unique_ptr<adaptive::DASHTree, std::default_delete<adaptive::DASHTree> >::~unique_ptr() /usr/include/c++/12.2.1/bits/unique_ptr.h:396
    xbmc#15 0x7f4013237aa8 in adaptive::DASHTree::RefreshLiveSegments() /home/dobo/kodi/inputstream.adaptive/src/parser/DASHTree.cpp:1962
    xbmc#16 0x7f40131e7842 in adaptive::AdaptiveTree::SegmentUpdateWorker() /home/dobo/kodi/inputstream.adaptive/src/common/AdaptiveTree.cpp:431
    xbmc#17 0x7f4013208eea in void std::__invoke_impl<void, void (adaptive::AdaptiveTree::*)(), adaptive::AdaptiveTree*>(std::__invoke_memfun_deref, void (adaptive::AdaptiveTree::*&&)(), adaptive::AdaptiveTree*&&) /usr/include/c++/12.2.1/bits/invoke.h:74
    xbmc#18 0x7f4013208d56 in std::__invoke_result<void (adaptive::AdaptiveTree::*)(), adaptive::AdaptiveTree*>::type std::__invoke<void (adaptive::AdaptiveTree::*)(), adaptive::AdaptiveTree*>(void (adaptive::AdaptiveTree::*&&)(), adaptive::AdaptiveTree*&&) /usr/include/c++/12.2.1/bits/invoke.h:96
    xbmc#19 0x7f4013208cc6 in void std::thread::_Invoker<std::tuple<void (adaptive::AdaptiveTree::*)(), adaptive::AdaptiveTree*> >::_M_invoke<0ul, 1ul>(std::_Index_tuple<0ul, 1ul>) /usr/include/c++/12.2.1/bits/std_thread.h:258
    xbmc#20 0x7f4013208c7f in std::thread::_Invoker<std::tuple<void (adaptive::AdaptiveTree::*)(), adaptive::AdaptiveTree*> >::operator()() /usr/include/c++/12.2.1/bits/std_thread.h:265
    xbmc#21 0x7f4013208c63 in std::thread::_State_impl<std::thread::_Invoker<std::tuple<void (adaptive::AdaptiveTree::*)(), adaptive::AdaptiveTree*> > >::_M_run() /usr/include/c++/12.2.1/bits/std_thread.h:210
    xbmc#22 0x7f403d4d72c2 in execute_native_thread_routine /usr/src/debug/gcc/gcc/libstdc++-v3/src/c++11/thread.cc:82

previously allocated by thread T53 here:
    #0 0x7f403fac0672 in operator new(unsigned long) /usr/src/debug/gcc/gcc/libsanitizer/asan/asan_new_delete.cpp:95
    xbmc#1 0x7f40131deab1 in std::__new_allocator<adaptive::AdaptiveTree::Segment>::allocate(unsigned long, void const*) /usr/include/c++/12.2.1/bits/new_allocator.h:137
    xbmc#2 0x7f40131db727 in std::allocator_traits<std::allocator<adaptive::AdaptiveTree::Segment> >::allocate(std::allocator<adaptive::AdaptiveTree::Segment>&, unsigned long) /usr/include/c++/12.2.1/bits/alloc_traits.h:464
    xbmc#3 0x7f40131d5b81 in std::_Vector_base<adaptive::AdaptiveTree::Segment, std::allocator<adaptive::AdaptiveTree::Segment> >::_M_allocate(unsigned long) /usr/include/c++/12.2.1/bits/stl_vector.h:378
    xbmc#4 0x7f40131d1308 in std::vector<adaptive::AdaptiveTree::Segment, std::allocator<adaptive::AdaptiveTree::Segment> >::reserve(unsigned long) /usr/include/c++/12.2.1/bits/vector.tcc:79
    xbmc#5 0x7f401322dd61 in end /home/dobo/kodi/inputstream.adaptive/src/parser/DASHTree.cpp:1253
    xbmc#6 0x7f403c4d8263  (/usr/lib/libexpat.so.1+0xd263)

Thread T53 created by T0 here:
    #0 0x7f403fa64207 in __interceptor_pthread_create /usr/src/debug/gcc/gcc/libsanitizer/asan/asan_interceptors.cpp:207
    xbmc#1 0x7f403d4d73a9 in __gthread_create /usr/src/debug/gcc/gcc-build/x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/gthr-default.h:663
    xbmc#2 0x7f403d4d73a9 in std::thread::_M_start_thread(std::unique_ptr<std::thread::_State, std::default_delete<std::thread::_State> >, void (*)()) /usr/src/debug/gcc/gcc/libstdc++-v3/src/c++11/thread.cc:147

Thread T57 created by T53 here:
    #0 0x7f403fa64207 in __interceptor_pthread_create /usr/src/debug/gcc/gcc/libsanitizer/asan/asan_interceptors.cpp:207
    xbmc#1 0x7f403d4d73a9 in __gthread_create /usr/src/debug/gcc/gcc-build/x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/gthr-default.h:663
    xbmc#2 0x7f403d4d73a9 in std::thread::_M_start_thread(std::unique_ptr<std::thread::_State, std::default_delete<std::thread::_State> >, void (*)()) /usr/src/debug/gcc/gcc/libstdc++-v3/src/c++11/thread.cc:147
    xbmc#3 0x7f40131e751e in adaptive::AdaptiveTree::StartUpdateThread() /home/dobo/kodi/inputstream.adaptive/src/common/AdaptiveTree.cpp:418
    xbmc#4 0x7f401323398d in adaptive::DASHTree::open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >) /home/dobo/kodi/inputstream.adaptive/src/parser/DASHTree.cpp:1639
    xbmc#5 0x7f401328c8ed in SESSION::CSession::Initialize() /home/dobo/kodi/inputstream.adaptive/src/Session.cpp:248
    xbmc#6 0x7f4013175f30 in CInputStreamAdaptive::Open(kodi::addon::InputstreamProperty const&) /home/dobo/kodi/inputstream.adaptive/src/main.cpp:86
    xbmc#7 0x7f40131871d5 in kodi::addon::CInstanceInputStream::ADDON_Open(AddonInstance_InputStream const*, INPUTSTREAM_PROPERTY*) (/usr/lib/kodi/addons/inputstream.adaptive/inputstream.adaptive.so.20.3.2+0x3871d5)
    xbmc#8 0x55abad46eddc in CInputStreamAddon::Open() (/usr/lib/kodi/kodi.bin+0xb66ddc)

SUMMARY: AddressSanitizer: heap-use-after-free /home/dobo/kodi/inputstream.adaptive/src/common/AdaptiveStream.cpp:610 in adaptive::AdaptiveStream::start_stream()
Shadow bytes around the buggy address:
  0x0fe884b25cd0: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd
  0x0fe884b25ce0: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd
  0x0fe884b25cf0: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd
  0x0fe884b25d00: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd
  0x0fe884b25d10: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd
=>0x0fe884b25d20: fd fd fd fd fd fd fd fd fd fd fd fd[fd]fd fd fd
  0x0fe884b25d30: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd
  0x0fe884b25d40: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd
  0x0fe884b25d50: fd fd fd fd fd fd fd fd fd fd fd fd fa fa fa fa
  0x0fe884b25d60: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0fe884b25d70: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
Shadow byte legend (one shadow byte represents 8 application bytes):
  Addressable:           00
  Partially addressable: 01 02 03 04 05 06 07
  Heap left redzone:       fa
  Freed heap region:       fd
  Stack left redzone:      f1
  Stack mid redzone:       f2
  Stack right redzone:     f3
  Stack after return:      f5
  Stack use after scope:   f8
  Global redzone:          f9
  Global init order:       f6
  Poisoned by user:        f7
  Container overflow:      fc
  Array cookie:            ac
  Intra object redzone:    bb
  ASan internal:           fe
  Left alloca redzone:     ca
  Right alloca redzone:    cb
==21945==ABORTING
dobo90 pushed a commit to dobo90/inputstream.adaptive that referenced this issue Feb 14, 2023
…hile CloseSession is active to avoid endless loop.

Sometimes when stopping a playback Kodi crashes with a following backtrace:

    (__m=<optimized out>, this=<optimized out>)
    at /usr/include/c++/12.1.0/bits/atomic_base.h:486
        __b = <optimized out>
    at /usr/include/c++/12.1.0/atomic:87
    (adp=std::shared_ptr<media::CdmAdapter> (use count 1, weak count 1) = {...}, delay=<optimized out>, context=<optimized out>)
    at /usr/src/debug/kodi-addon-inputstream-adaptive/inputstream.adaptive-20.3.3-Nexus/wvdecrypter/cdm/media/cdm/cdm_adapter.cc:81
    at /usr/include/c++/12.1.0/bits/invoke.h:96, unsigned long long, void*), std::shared_ptr<media::CdmAdapter>, long long, void*> >::_M_invoke<0u, 1u, 2u, 3u>(std::_Index_tuple<0u, 1u, 2u, 3u>)
    (this=<optimized out>) at /usr/include/c++/12.1.0/bits/std_thread.h:252
    at /usr/include/c++/12.1.0/bits/std_thread.h:259
    at /usr/include/c++/12.1.0/bits/std_thread.h:210
    at /usr/src/debug/gcc/libstdc++-v3/src/c++11/thread.cc:82
        ret = <optimized out>
        pd = 0x85cf9080
        unwind_buf = {cancel_jmp_buf = {{jmp_buf = {857629366, 66004830, -2049994624, -2008033272, -2008033282, 338, -2008033281, 8387456, -2058383360, -2049995908, 1920, 1080, 3840, 2160, 0, 10000000, -1431355392, 1107558643, 0 <repeats 46 times>}, mask_was_saved = 0}}, priv = {pad = {0x0, 0x0, 0x0, 0x0}, data = {prev = 0x0, cleanup = 0x0, canceltype = 0}}}
        not_first_call = <optimized out>
        robust = <optimized out>

After searching in the github history it came out that there was a
similar issue adressed in xbmc#728.

For some reason that piece of code got removed in
xbmc@8889fe9
(in pull request xbmc#883).

The stack trace is from the Raspberry Pi 4 machine. But I can also reproduce the issue
on my x86_64 Linux machine by adding a 1s sleep in the beginning of CdmAdapter::SetTimer.

In order to reproduce it is necessary to quickly play/stop streams.
Script attached at the end of the commit message can be used to ease the reproduction.
In my environment running the script for 1-3 minutes makes Kodi crash.
Although the root cause described in xbmc#729
was a busy loop. Right now address sanitizer reports:
```
AddressSanitizer:DEADLYSIGNAL
=================================================================
==108079==ERROR: AddressSanitizer: SEGV on unknown address 0x7f6e314f7d4a (pc 0x7f6e314f7d4a bp 0x7f6e263fd830 sp 0x7f6e263fd720 T464)
==108079==The signal is caused by a READ memory access.
==108079==Hint: PC is at a non-executable region. Maybe a wild jump?
    #0 0x7f6e314f7d4a  (<unknown module>)
    xbmc#1 0x7f6e3151c066  (<unknown module>)
    xbmc#2 0x7f6e31526947  (<unknown module>)
    xbmc#3 0x7f6e31526729  (<unknown module>)
    xbmc#4 0x7f6e31526620  (<unknown module>)
    xbmc#5 0x7f6e315265a1  (<unknown module>)
    xbmc#6 0x7f6e31526585  (<unknown module>)
    xbmc#7 0x7f6e46ed72c2 in execute_native_thread_routine /usr/src/debug/gcc/gcc/libstdc++-v3/src/c++11/thread.cc:82

AddressSanitizer can not provide additional info.
SUMMARY: AddressSanitizer: SEGV (<unknown module>)
Thread T464 created by T51 here:
    #0 0x7f6e49464207 in __interceptor_pthread_create /usr/src/debug/gcc/gcc/libsanitizer/asan/asan_interceptors.cpp:207
    xbmc#1 0x7f6e46ed73a9 in __gthread_create /usr/src/debug/gcc/gcc-build/x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/gthr-default.h:663
    xbmc#2 0x7f6e46ed73a9 in std::thread::_M_start_thread(std::unique_ptr<std::thread::_State, std::default_delete<std::thread::_State> >, void (*)()) /usr/src/debug/gcc/gcc/libstdc++-v3/src/c++11/thread.cc:147
    xbmc#3 0x7f6e31522028  (<unknown module>)
    xbmc#4 0x7f6e27569d40  (/home/dobo/.kodi/cdm/libwidevinecdm.so+0x969d40)
    xbmc#5 0x7f6e2757e7fc  (/home/dobo/.kodi/cdm/libwidevinecdm.so+0x97e7fc)
    xbmc#6 0x7f6e27569c36  (/home/dobo/.kodi/cdm/libwidevinecdm.so+0x969c36)
    xbmc#7 0x7f6e3151fb28  (<unknown module>)
    xbmc#8 0x7f6e3151c0b1  (<unknown module>)
    xbmc#9 0x7f6e31526947  (<unknown module>)
    xbmc#10 0x7f6e31526729  (<unknown module>)
    xbmc#11 0x7f6e31526620  (<unknown module>)
    xbmc#12 0x7f6e315265a1  (<unknown module>)
    xbmc#13 0x7f6e31526585  (<unknown module>)
    xbmc#14 0x7f6e46ed72c2 in execute_native_thread_routine /usr/src/debug/gcc/gcc/libstdc++-v3/src/c++11/thread.cc:82

Thread T51 created by T45 here:
    #0 0x7f6e49464207 in __interceptor_pthread_create /usr/src/debug/gcc/gcc/libsanitizer/asan/asan_interceptors.cpp:207
    xbmc#1 0x7f6e46ed73a9 in __gthread_create /usr/src/debug/gcc/gcc-build/x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/gthr-default.h:663
    xbmc#2 0x7f6e46ed73a9 in std::thread::_M_start_thread(std::unique_ptr<std::thread::_State, std::default_delete<std::thread::_State> >, void (*)()) /usr/src/debug/gcc/gcc/libstdc++-v3/src/c++11/thread.cc:147
    xbmc#3 0x7f6e31522028  (<unknown module>)
    xbmc#4 0x7f6e27569d40  (/home/dobo/.kodi/cdm/libwidevinecdm.so+0x969d40)
    xbmc#5 0x7f6e2757e7fc  (/home/dobo/.kodi/cdm/libwidevinecdm.so+0x97e7fc)
    xbmc#6 0x7f6e2757e70e  (/home/dobo/.kodi/cdm/libwidevinecdm.so+0x97e70e)
    xbmc#7 0x7f6e274e4ecc  (/home/dobo/.kodi/cdm/libwidevinecdm.so+0x8e4ecc)
    xbmc#8 0x7f6e3151f280  (<unknown module>)
    xbmc#9 0x7f6e314e9ea1  (<unknown module>)
    xbmc#10 0x7f6e314e49bb  (<unknown module>)
    xbmc#11 0x7f6e314f45ce  (<unknown module>)
    xbmc#12 0x7f6e2889228f in SESSION::CSession::InitializeDRM(bool) /home/dobo/kodi/inputstream.adaptive/src/Session.cpp:643
    xbmc#13 0x7f6e28893279 in SESSION::CSession::InitializePeriod(bool) /home/dobo/kodi/inputstream.adaptive/src/Session.cpp:723
    xbmc#14 0x7f6e2888e36d in SESSION::CSession::Initialize() /home/dobo/kodi/inputstream.adaptive/src/Session.cpp:266
    xbmc#15 0x7f6e28775f4c in CInputStreamAdaptive::Open(kodi::addon::InputstreamProperty const&) /home/dobo/kodi/inputstream.adaptive/src/main.cpp:101
    xbmc#16 0x7f6e287871a1 in kodi::addon::CInstanceInputStream::ADDON_Open(AddonInstance_InputStream const*, INPUTSTREAM_PROPERTY*) (/usr/lib/kodi/addons/inputstream.adaptive/inputstream.adaptive.so.20.3.2+0x3871a1)
    xbmc#17 0x55c2811f4ddc in CInputStreamAddon::Open() (/usr/lib/kodi/kodi.bin+0xb66ddc)

Thread T45 created by T0 here:
    #0 0x7f6e49464207 in __interceptor_pthread_create /usr/src/debug/gcc/gcc/libsanitizer/asan/asan_interceptors.cpp:207
    xbmc#1 0x7f6e46ed73a9 in __gthread_create /usr/src/debug/gcc/gcc-build/x86_64-pc-linux-gnu/libstdc++-v3/include/x86_64-pc-linux-gnu/bits/gthr-default.h:663
    xbmc#2 0x7f6e46ed73a9 in std::thread::_M_start_thread(std::unique_ptr<std::thread::_State, std::default_delete<std::thread::_State> >, void (*)()) /usr/src/debug/gcc/gcc/libstdc++-v3/src/c++11/thread.cc:147
```

The root cause of the crash is unknown as it comes directly from
libwidevine library. But it crashes when we call cdm->TimerExpired when
the session is closed. After applying mentioned commit I'm not able
to reproduce the crash anymore.

Script to reproduce the issue:
```
set -x

URI='Change it to some uri to play'

while true; do
  curl -s "http://kodi:kodi@127.0.0.1:8080/jsonrpc" -H 'Content-Type: application/json' --data "{\"jsonrpc\":\"2.0\",\"method\":\"Player.Open\",\"params\":{\"item\":{\"file\":\"$URI\"}}}"
  sleep $[ ($RANDOM % 70 + 30) / 10.0 ]

  curl -s "http://kodi:kodi@127.0.0.1:8080/jsonrpc" -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","method":"Player.Stop","params":{"playerid":1}}'
  sleep 1
done
```
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

No branches or pull requests

8 participants