Recherche avancée

Sur d’autres sites (6527)

• FFMPEG Segmenting skips when m3u8 changes file

  25 septembre 2012, par user792164

  I am attempting to segment a large video file in to segments. When streamed (even locally) by opening the m3u8 file it will jump forward in time by some period of time less than 1 second.

  The following commands are executed :

  First mp4 —> ts :

  ffmpeg -i input_file.mp4 -bsf:v h264_mp4toannexb -acodec libfaac -vcodec libx264 -f mpegts -threads 0 output.ts

  Then I split using :

  ffmpeg -i output.ts -vcodec copy -acodec copy -map 0 -f segment -segment_time 30 -segment_list output.m3u8 -segment_list_type m3u8 -segment_format mpegts output%03d.ts 

  Note : Changing segment time has no effect on issue.

  Generated manifest :

  #EXTM3U
  
  #EXT-X-VERSION:4
  
  #EXTINF:30.947578,
  
  output000.ts
  
  #EXTINF:30.155111,
  
  output001.ts
  
  ...
  
  #EXTINF:24.023989,
  
  output082.ts
  
  #EXT-X-TARGETDURATION:37
  
  #EXT-X-ENDLIST

  ---

  Meta Data :

  $> ffmpeg -version
  
  ffmpeg version git-2012-08-19-a93c221
  
  built on Aug 19 2012 13:18:58 with gcc 4.4.5 (Debian 4.4.5-8)
  
  configuration: --prefix=/usr --bindir=/usr/bin --datadir=/usr/share/ffmpeg --incdir=/usr/include/ffmpeg --libdir=/usr/lib/ --mandir=/usr/share/man --extra-cflags='-O3 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions \ -fstack-protector --param=ssp-buffer-size=4 -mtune=generic' --enable-gpl --enable-shared --enable-nonfree --enable-version3 --enable-libfaac --enable-libmp3lame --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-librtmp --enable-libtheora --enable-libvorbis --enable-libvpx --enable-libx264 --enable-pthreads --enable-libxvid --enable-postproc --enable-libgsm --enable-libspeex --enable-avfilter --disable-decoder=libdirac --enable-libfreetype --enable-libschroedinger --disable-decoder=libschroedinger --enable-libopenjpeg --disable-ffplay --disable-ffserver
  
  libavutil      51. 70.100 / 51. 70.100
  
  libavcodec     54. 53.100 / 54. 53.100
  
  libavformat    54. 25.104 / 54. 25.104
  
  libavdevice    54.  2.100 / 54.  2.100
  
  libavfilter     3. 11.101 /  3. 11.101
  
  libswscale      2.  1.101 /  2.  1.101
  
  libswresample   0. 15.100 /  0. 15.100
  
  libpostproc    52.  0.100 / 52.  0.100

  -

  $> ffprobe input_file.mp4
  
  
  
  Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'input_file.mp4':
  
  Metadata:
  
  major_brand     : isom
  
  minor_version   : 1
  
  compatible_brands: isom
  
  creation_time   : 2011-09-08 11:43:25
  
  Duration: 00:41:31.00, start: 0.000000, bitrate: 1146 kb/s
  
  Stream #0.0(und): Video: h264 (High), yuv420p, 720x404 [PAR 1:1 DAR 180:101], 1015 kb/s,    23.98 fps, 23.98 tbr, 24k tbn, 47.95 tbc
  
  Metadata:
  
    creation_time   : 2011-09-08 11:43:25
  
  Stream #0.1(und): Audio: aac, 48000 Hz, stereo, s16, 124 kb/s
  
  Metadata:
  
    creation_time   : 2011-09-08 11:43:25

  -

  $> ffprobe output_file.ts
  
  Input #0, mpegts, from 'output_file.ts':
  
  Duration: 00:41:30.98, start: 1.400000, bitrate: 807 kb/s
  
  Program 1 
  
  Metadata:
  
    service_name    : Service01
  
    service_provider: FFmpeg
  
  Stream #0.0[0x100]: Video: h264 (High), yuv420p, 720x404 [PAR 1:1 DAR 180:101], 23.98 fps, 23.98 tbr, 90k tbn, 47.95 tbc
  
  Stream #0.1[0x101](und): Audio: aac, 48000 Hz, stereo, s16, 141 kb/

  ---

  Is it possible to remove this jump, if so, what encoding parameters or incorrect assumptions have I made ? Thanks.

• divx to mp4 converted videos using avconv are not playing with jwplayer in Firefox

  30 mai 2014, par Suresh

  I am trying to convert all format videos to mp4 using libav library. I am using the following command to convert any format to mp4 i.e

  "avconv -i input -s 1024x768 -strict 2 -c:v libx264 -c:a copy -f mp4 output.mp4" and it is working fine in chrome and IE where as not working in Firefox and safari.

  You can find the issue here https://ppe.maventus.com/player.php?v=721

  Note : avi to mp4 is working in all browsers.

  Any help to fix this would be much appreciated.

  Thanks in advance,
  Suresh

• Problems with Streaming a Multicast RTSP Stream with Live555

  16 juin 2014, par ALM865

  I am having trouble setting up a Multicast RTSP session using Live555. The examples included with Live555 are mostly irrelevant as they deal with reading in files and my code differs because it reads in encoded frames generated from a FFMPEG thread within my own program (no pipes, no saving to disk, it is genuinely passing pointers to memory that contain the encoded frames for Live555 to stream).

  My Live555 project that uses a custom Server Media Subsession so that I can receive data from an FFMPEG thread within my program (instead of Live555’s default reading from a file, yuk !). This is a requirement of my program as it reads in a GigEVision stream in one thread, sends the decoded raw RGB packets to the FFMPEG thread, which then in turn sends the encoded frames off to Live555 for RTSP streaming.

  For the life of me I can’t work out how to send the RTSP stream as multicast instead of unicast !

  Just a note, my program works perfectly at the moment streaming Unicast, so there is nothing wrong with my Live555 implementation (before you go crazy picking out irrelevant errors !). I just need to know how to modify my existing code to stream Multicast instead of Unicast.

  My program is way too big to upload and share so I’m just going to share the important bits :

  Live_AnalysingServerMediaSubsession.h

  #ifndef _ANALYSING_SERVER_MEDIA_SUBSESSION_HH
  
  #define _ANALYSING_SERVER_MEDIA_SUBSESSION_HH
  
  
  
  #include 
  
  #include "Live_AnalyserInput.h"
  
  
  
  class AnalysingServerMediaSubsession: public OnDemandServerMediaSubsession {
  
  
  
  public:
  
    static AnalysingServerMediaSubsession*
  
    createNew(UsageEnvironment& env, AnalyserInput& analyserInput, unsigned estimatedBitrate,
  
          Boolean iFramesOnly = False,
  
              double vshPeriod = 5.0
  
              /* how often (in seconds) to inject a Video_Sequence_Header,
  
                 if one doesn't already appear in the stream */);
  
  
  
  protected: // we're a virtual base class
  
    AnalysingServerMediaSubsession(UsageEnvironment& env, AnalyserInput& AnalyserInput, unsigned estimatedBitrate, Boolean iFramesOnly, double vshPeriod);
  
    virtual ~AnalysingServerMediaSubsession();
  
  
  
  protected:
  
    AnalyserInput& fAnalyserInput;
  
    unsigned fEstimatedKbps;
  
  
  
  private:
  
    Boolean fIFramesOnly;
  
    double fVSHPeriod;
  
  
  
    // redefined virtual functions
  
    virtual FramedSource* createNewStreamSource(unsigned clientSessionId, unsigned& estBitrate);
  
    virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource* inputSource);
  
  
  
  };
  
  
  
  #endif

  And "Live_AnalysingServerMediaSubsession.cpp"

  #include "Live_AnalysingServerMediaSubsession.h"
  
  #include 
  
  #include 
  
  #include 
  
  
  
  AnalysingServerMediaSubsession* AnalysingServerMediaSubsession::createNew(UsageEnvironment& env, AnalyserInput& wisInput, unsigned estimatedBitrate,
  
      Boolean iFramesOnly,
  
      double vshPeriod) {
  
          return new AnalysingServerMediaSubsession(env, wisInput, estimatedBitrate,
  
              iFramesOnly, vshPeriod);
  
  }
  
  
  
  AnalysingServerMediaSubsession
  
      ::AnalysingServerMediaSubsession(UsageEnvironment& env, AnalyserInput& analyserInput,   unsigned estimatedBitrate, Boolean iFramesOnly, double vshPeriod) 
  
      : OnDemandServerMediaSubsession(env, True /*reuse the first source*/),
  
  
  
      fAnalyserInput(analyserInput), fIFramesOnly(iFramesOnly), fVSHPeriod(vshPeriod) {
  
          fEstimatedKbps = (estimatedBitrate + 500)/1000;
  
  
  
  }
  
  
  
  AnalysingServerMediaSubsession
  
      ::~AnalysingServerMediaSubsession() {
  
  }
  
  
  
  FramedSource* AnalysingServerMediaSubsession ::createNewStreamSource(unsigned /*clientSessionId*/, unsigned& estBitrate) {
  
      estBitrate = fEstimatedKbps;
  
  
  
      // Create a framer for the Video Elementary Stream:
  
      //LOG_MSG("Create Net Stream Source [%d]", estBitrate);
  
  
  
      return MPEG1or2VideoStreamDiscreteFramer::createNew(envir(), fAnalyserInput.videoSource());
  
  }
  
  
  
  RTPSink* AnalysingServerMediaSubsession ::createNewRTPSink(Groupsock* rtpGroupsock, unsigned char /*rtpPayloadTypeIfDynamic*/, FramedSource* /*inputSource*/) {
  
      setVideoRTPSinkBufferSize();
  
      /*
  
      struct in_addr destinationAddress;
  
      destinationAddress.s_addr = inet_addr("239.255.12.42");
  
  
  
      rtpGroupsock->addDestination(destinationAddress,8888);
  
      rtpGroupsock->multicastSendOnly();
  
      */
  
      return MPEG1or2VideoRTPSink::createNew(envir(), rtpGroupsock);
  
  }

  Live_AnalyserSouce.h

  #ifndef _ANALYSER_SOURCE_HH
  
  #define _ANALYSER_SOURCE_HH
  
  
  
  #ifndef _FRAMED_SOURCE_HH
  
  #include "FramedSource.hh"
  
  #endif
  
  
  
  class FFMPEG;
  
  
  
  // The following class can be used to define specific encoder parameters
  
  class AnalyserParameters {
  
  public:
  
    FFMPEG * Encoding_Source;
  
  };
  
  
  
  class AnalyserSource: public FramedSource {
  
  public:
  
    static AnalyserSource* createNew(UsageEnvironment& env, FFMPEG * E_Source);
  
    static unsigned GetRefCount();
  
  
  
  
  
  public:
  
    static EventTriggerId eventTriggerId;
  
  
  
  protected:
  
    AnalyserSource(UsageEnvironment& env, FFMPEG *  E_Source);
  
    // called only by createNew(), or by subclass constructors
  
    virtual ~AnalyserSource();
  
  
  
  private:
  
    // redefined virtual functions:
  
    virtual void doGetNextFrame();
  
  
  
  private:
  
    static void deliverFrame0(void* clientData);
  
    void deliverFrame();
  
  
  
  
  
  private:
  
    static unsigned referenceCount; // used to count how many instances of this class currently exist
  
    FFMPEG * Encoding_Source;
  
  
  
    unsigned int Last_Sent_Frame_ID;
  
  };
  
  
  
  #endif

  Live_AnalyserSource.cpp

  #include "Live_AnalyserSource.h"
  
  #include  // for "gettimeofday()"
  
  #include "FFMPEGClass.h"
  
  
  
  AnalyserSource* AnalyserSource::createNew(UsageEnvironment& env, FFMPEG * E_Source) {
  
    return new AnalyserSource(env, E_Source);
  
  }
  
  
  
  
  
  EventTriggerId AnalyserSource::eventTriggerId = 0;
  
  
  
  unsigned AnalyserSource::referenceCount = 0;
  
  
  
  AnalyserSource::AnalyserSource(UsageEnvironment& env, FFMPEG * E_Source) : FramedSource(env), Encoding_Source(E_Source) {
  
    if (referenceCount == 0) {
  
      // Any global initialization of the device would be done here:
  
  
  
    }
  
    ++referenceCount;
  
  
  
    // Any instance-specific initialization of the device would be done here:
  
    Last_Sent_Frame_ID = 0;
  
  
  
    /* register us with the Encoding thread so we'll get notices when new frame data turns up.. */
  
    Encoding_Source->RegisterRTSP_Source(&(env.taskScheduler()), this);
  
  
  
    // We arrange here for our "deliverFrame" member function to be called
  
    // whenever the next frame of data becomes available from the device.
  
    //
  
    // If the device can be accessed as a readable socket, then one easy way to do this is using a call to
  
    //     envir().taskScheduler().turnOnBackgroundReadHandling( ... )
  
    // (See examples of this call in the "liveMedia" directory.)
  
    //
  
    // If, however, the device *cannot* be accessed as a readable socket, then instead we can implement is using 'event triggers':
  
    // Create an 'event trigger' for this device (if it hasn't already been done):
  
    if (eventTriggerId == 0) {
  
      eventTriggerId = envir().taskScheduler().createEventTrigger(deliverFrame0);
  
    }
  
  }
  
  
  
  AnalyserSource::~AnalyserSource() {
  
    // Any instance-specific 'destruction' (i.e., resetting) of the device would be done here:
  
  
  
    /* de-register this source from the Encoding thread, since we no longer need notices.. */
  
    Encoding_Source->Un_RegisterRTSP_Source(this);
  
  
  
    --referenceCount;
  
    if (referenceCount == 0) {
  
      // Any global 'destruction' (i.e., resetting) of the device would be done here:
  
  
  
      // Reclaim our 'event trigger'
  
      envir().taskScheduler().deleteEventTrigger(eventTriggerId);
  
      eventTriggerId = 0;
  
    }
  
  
  
  }
  
  
  
  unsigned AnalyserSource::GetRefCount() {
  
    return referenceCount;
  
  }
  
  
  
  void AnalyserSource::doGetNextFrame() {
  
    // This function is called (by our 'downstream' object) when it asks for new data.
  
    //LOG_MSG("Do Next Frame..");
  
    // Note: If, for some reason, the source device stops being readable (e.g., it gets closed), then you do the following:
  
    //if (0 /* the source stops being readable */ /*%%% TO BE WRITTEN %%%*/) {
  
    unsigned int FrameID = Encoding_Source->GetFrameID();
  
    if (FrameID == 0){
  
      //LOG_MSG("No Data. Close");
  
      handleClosure(this);
  
      return;
  
    }
  
  
  
  
  
  
  
    // If a new frame of data is immediately available to be delivered, then do this now:
  
    if (Last_Sent_Frame_ID != FrameID){
  
      deliverFrame();
  
      //DEBUG_MSG("Frame ID: %d",FrameID);
  
    }
  
  
  
    // No new data is immediately available to be delivered.  We don't do anything more here.
  
    // Instead, our event trigger must be called (e.g., from a separate thread) when new data becomes available.
  
  }
  
  
  
  void AnalyserSource::deliverFrame0(void* clientData) {
  
    ((AnalyserSource*)clientData)->deliverFrame();
  
  }
  
  
  
  void AnalyserSource::deliverFrame() {
  
  
  
    if (!isCurrentlyAwaitingData()) return; // we're not ready for the data yet
  
  
  
  
  
    static u_int8_t* newFrameDataStart;
  
    static unsigned newFrameSize = 0;
  
  
  
    /* get the data frame from the Encoding thread.. */
  
    if (Encoding_Source->GetFrame(&newFrameDataStart, &newFrameSize, &Last_Sent_Frame_ID)){
  
      if (newFrameDataStart!=NULL) {
  
          /* This should never happen, but check anyway.. */
  
          if (newFrameSize > fMaxSize) {
  
            fFrameSize = fMaxSize;
  
            fNumTruncatedBytes = newFrameSize - fMaxSize;
  
          } else {
  
            fFrameSize = newFrameSize;
  
          }
  
          gettimeofday(&fPresentationTime, NULL); // If you have a more accurate time - e.g., from an encoder - then use that instead.
  
          // If the device is *not* a 'live source' (e.g., it comes instead from a file or buffer), then set "fDurationInMicroseconds" here.
  
          /* move the data to be sent off.. */
  
          memmove(fTo, newFrameDataStart, fFrameSize);
  
  
  
          /* release the Mutex we had on the Frame's buffer.. */
  
          Encoding_Source->ReleaseFrame();
  
      }
  
      else {
  
          //AM Added, something bad happened
  
          //ALTRACE("LIVE555: FRAME NULL\n");
  
          fFrameSize=0;
  
          fTo=NULL;
  
          handleClosure(this);
  
      }
  
    }
  
    else {
  
      //LOG_MSG("Closing Connection due to Frame Error..");
  
      handleClosure(this);
  
    }
  
  
  
  
  
    // After delivering the data, inform the reader that it is now available:
  
    FramedSource::afterGetting(this);
  
  }

  Live_AnalyserInput.cpp

  #include "Live_AnalyserInput.h"
  
  #include "Live_AnalyserSource.h"
  
  
  
  
  
  ////////// WISInput implementation //////////
  
  
  
  AnalyserInput* AnalyserInput::createNew(UsageEnvironment& env, FFMPEG *Encoder) {
  
    if (!fHaveInitialized) {
  
      //if (!initialize(env)) return NULL;
  
      fHaveInitialized = True;
  
    }
  
  
  
    return new AnalyserInput(env, Encoder);
  
  }
  
  
  
  
  
  FramedSource* AnalyserInput::videoSource() {
  
    if (fOurVideoSource == NULL || AnalyserSource::GetRefCount() == 0) {
  
      fOurVideoSource = AnalyserSource::createNew(envir(), m_Encoder);
  
    }
  
    return fOurVideoSource;
  
  }
  
  
  
  
  
  AnalyserInput::AnalyserInput(UsageEnvironment& env, FFMPEG *Encoder): Medium(env), m_Encoder(Encoder) {
  
  }
  
  
  
  AnalyserInput::~AnalyserInput() {
  
    /* When we get destroyed, make sure our source is also destroyed.. */
  
    if (fOurVideoSource != NULL && AnalyserSource::GetRefCount() != 0) {
  
      AnalyserSource::handleClosure(fOurVideoSource);
  
    }
  
  }
  
  
  
  
  
  
  
  
  
  Boolean AnalyserInput::fHaveInitialized = False;
  
  int AnalyserInput::fOurVideoFileNo = -1;
  
  FramedSource* AnalyserInput::fOurVideoSource = NULL;

  Live_AnalyserInput.h

  #ifndef _ANALYSER_INPUT_HH
  
  #define _ANALYSER_INPUT_HH
  
  
  
  #include 
  
  #include "FFMPEGClass.h"
  
  
  
  
  
  class AnalyserInput: public Medium {
  
  public:
  
    static AnalyserInput* createNew(UsageEnvironment& env, FFMPEG *Encoder);
  
  
  
    FramedSource* videoSource();
  
  
  
  private:
  
    AnalyserInput(UsageEnvironment& env, FFMPEG *Encoder); // called only by createNew()
  
    virtual ~AnalyserInput();
  
  
  
  private:
  
    friend class WISVideoOpenFileSource;
  
    static Boolean fHaveInitialized;
  
    static int fOurVideoFileNo;
  
    static FramedSource* fOurVideoSource;
  
    FFMPEG *m_Encoder;
  
  };
  
  
  
  // Functions to set the optimal buffer size for RTP sink objects.
  
  // These should be called before each RTPSink is created.
  
  #define VIDEO_MAX_FRAME_SIZE 300000
  
  inline void setVideoRTPSinkBufferSize() { OutPacketBuffer::maxSize = VIDEO_MAX_FRAME_SIZE; }
  
  
  
  #endif

  And finally the relevant code from my Live555 worker thread that starts the whole process :

      Stop_RTSP_Loop=0;
  
      //  MediaSession     *ms;
  
      TaskScheduler    *scheduler;
  
      UsageEnvironment *env ;
  
      //  RTSPClient       *rtsp;
  
      //  MediaSubsession  *Video_Sub;
  
  
  
      char RTSP_Address[1024];
  
      RTSP_Address[0]=0x00;
  
  
  
      if (m_Encoder == NULL){
  
          //DEBUG_MSG("No Video Encoder registered for the RTSP Encoder");
  
          return 0;
  
      }
  
  
  
      scheduler = BasicTaskScheduler::createNew();
  
      env = BasicUsageEnvironment::createNew(*scheduler);
  
  
  
      UserAuthenticationDatabase* authDB = NULL;
  
  #ifdef ACCESS_CONTROL
  
      // To implement client access control to the RTSP server, do the following:
  
  
  
      if (m_Enable_Pass){
  
          authDB = new UserAuthenticationDatabase;
  
          authDB->addUserRecord(UserN, PassW);
  
      }
  
      ////////// authDB = new UserAuthenticationDatabase;
  
      ////////// authDB->addUserRecord((char*)"Admin", (char*)"Admin"); // replace these with real strings
  
      // Repeat the above with each <username>, <password> that you wish to allow
  
      // access to the server.
  
  #endif
  
  
  
      // Create the RTSP server:
  
      RTSPServer* rtspServer = RTSPServer::createNew(*env, 554, authDB);
  
      ServerMediaSession* sms;
  
  
  
      AnalyserInput* inputDevice;
  
  
  
  
  
      if (rtspServer == NULL) {
  
          TRACE("LIVE555: Failed to create RTSP server: %s\n", env->getResultMsg());
  
          return 0;
  
      }
  
      else {
  
          char const* descriptionString = "Session streamed by \"IMC Server\"";
  
  
  
  
  
  
  
          // Initialize the WIS input device:
  
          inputDevice = AnalyserInput::createNew(*env, m_Encoder);
  
          if (inputDevice == NULL) {
  
              TRACE("Live555: Failed to create WIS input device\n");
  
              return 0;
  
          }
  
          else {
  
              // A MPEG-1 or 2 video elementary stream:
  
              /* Increase the buffer size so we can handle the high res stream.. */
  
              OutPacketBuffer::maxSize = 300000;
  
              // NOTE: This *must* be a Video Elementary Stream; not a Program Stream
  
              sms = ServerMediaSession::createNew(*env, RTSP_Address, RTSP_Address, descriptionString);
  
  
  
              //sms->addSubsession(MPEG1or2VideoFileServerMediaSubsession::createNew(*env, inputFileName, reuseFirstSource, iFramesOnly));
  
  
  
              sms->addSubsession(AnalysingServerMediaSubsession::createNew(*env, *inputDevice, m_Encoder->Get_Bitrate()));
  
              //sms->addSubsession(WISMPEG1or2VideoServerMediaSubsession::createNew(sms->envir(), inputDevice, videoBitrate));
  
  
  
              rtspServer->addServerMediaSession(sms);
  
  
  
              //announceStream(rtspServer, sms, streamName, inputFileName);
  
              //LOG_MSG("Play this stream using the URL %s", rtspServer->rtspURL(sms));
  
  
  
          }
  
      }
  
  
  
      Stop_RTSP_Loop=0;
  
  
  
      for (;;)
  
      {
  
          /* The actual work is all carried out inside the LIVE555 Task scheduler */
  
          env->taskScheduler().doEventLoop(&amp;Stop_RTSP_Loop); // does not return
  
  
  
          if (mStop) {
  
              break;
  
          }
  
      }
  
  
  
      Medium::close(rtspServer); // will also reclaim "sms" and its "ServerMediaSubsession"s
  
      Medium::close(inputDevice);
  
  </password></username>