Recherche avancée

Sur d’autres sites (10097)

• How to generate submanifests based on offset and duration

  5 septembre 2015, par ayniam

  I am using hls-segment-reader for generating sub-manifests from a master manifest file.

  I want to provide an offset and duration to generate sub-manifest file. however, i am not able to find how can I pass them

  Any help in this regard is greatly appreciated.

  Thanks in Advance.

• cbs_h2645 : Fix infinite loop in more_rbsp_data

  5 juin 2019, par Andreas Rheinhardt

  cbs_h2645 : Fix infinite loop in more_rbsp_data
  cbs_h2645_read_more_rbsp_data does not handle malformed input very well :
  
  1. If there were <= 8 bits left in the bitreader, these bits were read
  
  via show_bits. But show_bits requires the number of bits to be read to
  
  be > 0 (internally it shifts by 32 - number of bits to be read which is
  
  undefined behaviour if said number is zero ; there is also an assert for
  
  this, but it is only an av_assert2). Furthermore, in this case a shift
  
  by -1 was performed which is of course undefined behaviour, too.
  
  2. If there were > 0 and <= 8 bits left and all of them were zero
  
  (this can only happen for defective input), it was reported that there
  
  was further RBSP data.
  This can lead to an infinite loop in H.265's cbs_h265_read_extension_data
  
  corresponding to the [vsp]ps_extension_data_flag syntax elements. If the
  
  relevant flag indicates the (potential) occurence of these syntax elements,
  
  while all bits after this flag are zero, cbs_h2645_read_more_rbsp_data
  
  always returns 1 on x86. Given that a checked bitstream reader is used,
  
  we are also not "saved" by an overflow in the bitstream reader's index.
  Signed-off-by : Andreas Rheinhardt <andreas.rheinhardt@gmail.com>
  

  • [DH] libavcodec/cbs_h2645.c

• avutil/threadmessage : split the pthread condition in two

  1er décembre 2015, par Clément Bœsch

  avutil/threadmessage : split the pthread condition in two
  Fix a dead lock under certain conditions. Let’s assume we have a queue of 1
  
  message max, 2 senders, and 1 receiver.
  Scenario (real record obtained with debug added) :
  
      [...]
  
      SENDER #0 : acquired lock
  
      SENDER #0 : queue is full, wait
  
      SENDER #1 : acquired lock
  
      SENDER #1 : queue is full, wait
  
      RECEIVER : acquired lock
  
      RECEIVER : reading a msg from the queue
  
      RECEIVER : signal the cond
  
      RECEIVER : acquired lock
  
      RECEIVER : queue is empty, wait
  
      SENDER #0 : writing a msg the queue
  
      SENDER #0 : signal the cond
  
      SENDER #0 : acquired lock
  
      SENDER #0 : queue is full, wait
  
      SENDER #1 : queue is full, wait
  Translated :
  
   - initially the queue contains 1/1 message with 2 senders blocking on
  
     it, waiting to push another message.
  
   - Meanwhile the receiver is obtaining the lock, read the message,
  
     signal & release the lock. For some reason it is able to acquire the
  
     lock again before the signal wakes up one of the sender. Since it
  
     just emptied the queue, the reader waits for the queue to fill up
  
     again.
  
   - The signal finally reaches one of the sender, which writes a message
  
     and then signal the condition. Unfortunately, instead of waking up
  
     the reader, it actually wakes up the other worker (signal = notify
  
     the condition just for 1 waiter), who can’t push another message in
  
     the queue because it’s full.
  
   - Meanwhile, the receiver is still waiting. Deadlock.
  This scenario can be triggered with for example :
  
      tests/api/api-threadmessage-test 1 2 100 100 1 1000 1000
  One working solution is to make av_thread_message_queue_send,recv()
  
  call pthread_cond_broadcast() instead of pthread_cond_signal() so both
  
  senders and receivers are unlocked when work is done (be it reading or
  
  writing).
  This second solution replaces the condition with two : one to notify the
  
  senders, and one to notify the receivers. This prevents senders from
  
  notifying other senders instead of a reader, and the other way around.
  
  It also avoid broadcasting to everyone like the first solution, and is,
  
  as a result in theory more optimized.
  

  • [DH] libavutil/threadmessage.c