Recherche avancée

Sur d’autres sites (3185)

• libx264 - Setting up AVCodecContext for HD & SD capturing

  8 octobre 2013, par moose

  I'm trying to configure the AVCodecContext properly in order to capture HD in real-time (1080i) and SD (720 x 576) - also interlaced. I'm using libx264 with the ffmpeg static lib on Windows OS.
  If anybody can help with flags, gop_size, max_b_frames and all other AVCodecContext's members...

  For example, I guess I should have CODEC_FLAG_INTERLACED_ME | CODEC_FLAG_INTERLACED_DCT flags set. However, what I need is the whole story on how to set all this up.

• FFmpeg + iOS + lossy cellular connections

  9 novembre 2014, par Moss

  I am able to play an RTMP audio + video real-time stream on iOS with FFmpeg. Works fantastic when everything is on a solid WiFi connection.

  When I switch to a cellular connection (great signal strength and LTE/4G), av_read_frame() will intermittently block for an unacceptable amount of time. From what I can tell, it’s not that the cellular data connection just dropped, because I can reconnect immediately and start downloading more packets. In some cases, I’ve clocked 30+ seconds of hang time before it returns the next frame. When the next frame finally comes in, my real-time video stream is permanently delayed by the amount of time that av_read_frame() blocked.

  I attempted a work-around by using the AVIOInterruptCB interrupt callback to abort av_read_frame() if the function takes longer than 1 second to return. Here’s what that code looks like :

  - (void)readPackets {
  
      // Make sure FFmpeg calls our interrupt periodically
  
      _context->interrupt_callback.callback = interrupt_cb;
  
      _context->interrupt_callback.opaque = self;
  
  
  
      dispatch_async(_readPacketQueue, ^(void) {
  
          int err;
  
  
  
          while(true) {
  
              _readFrameTimeStamp = [[NSDate date] timeIntervalSince1970];
  
              err = av_read_frame(_context, &packet);
  
              _readFrameTimeStamp = 0;
  
  
  
              if(err) {
  
                  // Error - Reconnect the entire stream from scratch, taking 5-10 seconds
  
                  // And we know when av_read_frame() was aborted
  
                  // because its error code is -1414092869 ("EXIT")
  
              }
  
              else {
  
                  // Play this audio or video packet
  
              }
  
          }
  
     });
  
  }
  
  
  
  /**
  
   * Interrupt
  
   * @return 1 to abort the current operation
  
   */
  
  static int interrupt_cb(void *decoder) {
  
      if(decoder) {
  
          if(_readFrameTimeStamp != 0) {
  
              if([[NSDate date] timeIntervalSince1970] - _readFrameTimeStamp > 1) {
  
                  // Abort av_read_frame(), it's taking longer than 1 second
  
                  return 1;
  
              }
  
          }
  
      }
  
  }

  This definitely aborts av_read_frame() after 1 second, but unfortunately after I do this, future attempts to call av_read_frame() result in EIO errors (-5), which indicates that the connection has been severed.

  As a result, I am forced to fully reconnect the viewer, which takes 5-10 seconds. (avformat_open_input() takes 3-4 seconds, and then find the stream info again takes 2-3 seconds, and then start reading frames).

  The 5-10 second delay to fully reconnect is much better than waiting more than 10 seconds for av_read_frame() to unblock, and it’s much better than the real-time stream being delayed by a significant amount. But it’s much worse than being able to retry av_read_frame() immediately.

  From a cellular user’s perspective, their video locks up intermittently for 5-10 seconds while we reconnect the stream in the background from scratch, which isn’t a good user experience.

  What strategies are there to better way to manage av_read_frame() on a lossy cellular connection ?
  (Or strategies to improve the reconnect time ?)

• How to set normal speed of playback after capturing and transcoding stream video by `ffmpeg_streaming` in Python project ?

  30 avril 2020, par Harley Club

  Using ffmpeg_streaming module in Python project with Flask, I try to set up video streaming from online camera into local file. My purpose is receiving input stream that comes as HLS-compatible data. To implement this property, I've inserted some code accessible by this link :

  



  import ffmpeg_streaming
from ffmpeg_streaming import Formats, Bitrate, Representation, Size

from flask import render_template, Flask, send_from_directory, abort, json, Response  

import sys

app = Flask(__name__)

video = ffmpeg_streaming.input('http://wmccpinetop.axiscam.net/mjpg/video.mjpg')

_480p = Representation(Size(854, 480), Bitrate(750 * 1024, 192 * 1024))
hls_stream = video.hls(Formats.h264(), hls_list_size = 10, hls_time = 5)
hls_stream.representations(_480p)
hls_stream.output('/var/media/hls_outputs.m3u8')


  



  It works as expected, i.e. video stream gets written into local file, then I can see what camera shot somewhere far from there...But an only problem arises here which I can't manage : once playback starts, the video is being displayed utterly fast. Nearly 2 minutes period covered by camera (I can see how long real time was over due to camera-embedded timer option) has duration of 5 seconds when playing back. So, how do I want to enable video speed just as it fits into real-world timing ? My OS is Ubuntu 18.04 LTS and I open file with preinstalled Videos app to watch content.