Recherche avancée

Sur d’autres sites (6577)

• Error in ffmpeg when reading from UDP stream

  24 juillet 2013, par six6and1one

  I'm trying to process frames from a UDP stream using ffmpeg. Everything will run fine for a while but av_read_frame() will always eventually return either AVERROR_EXIT (Immeditate exit requested) or -5 (Error number -5 occurred) while the stream should still be running fine. Right before the error it always prints the following message to the console

  [mpeg2video @ 0caf6600] ac-tex damaged at 14 10
  
  [mpeg2video @ 0caf6600] Warning MVs not available
  
  [mpeg2video @ 0caf6600] concealing 800 DC, 800 AC, 800 MV errors in I frame

  (the numbers in the message vary from run to run)

  I have a suspicion that the error is related to calling av_read_frame too quickly. If I have it run as fast as possible, I usually get an error within 10-20 frames, but if I put a sleep before reading it will run fine for a minute or so and then exit with an error. I realize this is hacky and assume there is a better solution. Bottom line : is there a way to dynamically check if 'av_read_frame()' is ready to be called ? or a way to supress the error ?

  Psuedo code of what I'm doing below. Thanks in advance for the help !

  void getFrame()
  
  {
  
      //wait here?? seems hacky...
  
      //boost::this_thread::sleep(boost::posix_time::milliseconds(25));   
  
  
  
      int av_read_frame_error = av_read_frame(m_input_format_context, &m_input_packet);           
  
      if(av_read_frame_error == 0){       
  
          //DO STUFF - this all works fine when it gets here
  
      }
  
      else{               
  
          //error
  
          char errorBuf[AV_ERROR_MAX_STRING_SIZE];
  
          av_make_error_string(errorBuf, AV_ERROR_MAX_STRING_SIZE, av_read_frame_error);
  
          cout << "FFMPEG Input Stream Exit Code: " << av_read_frame_error << "   Message: " << errorBuf << endl;             
  
      }
  
  }

• Decoding with FFMPEG on Visual Studio 2010

  6 juin 2013, par user2439801

  I just started using FFMPEG with C++ and try to code an audio decoder then write the decoded audio into a file.

  However i'm not sure about which data to write to the output file. As far as i know from looking at the sample codes it seems to be the AVFrame -> data[0].
  But when i try to print it on the consoles, i get some random numbers that are different each time i run the program. And when i try to write this AVFrame->data[0] into a file i keep getting an error.

  So my question is how can i write the decoded audio after i call the function av_codec_decode_audio4 ?

  Below i attached my code and i pass the argument "C :\02.mp3" which is a path for a valid mp3 file on my PC.

  Thank you for your help.

  // TestFFMPEG.cpp : Audio Decoder
  
  //
  
  
  
  #include "stdafx.h"
  
  
  
  #include <iostream>
  
  #include <fstream>
  
  #include <sstream>
  
  
  
  extern "C" {
  
      #include 
  
      #include 
  
      #include 
  
  
  
  }
  
  
  
  using namespace std;
  
  
  
  
  
  int main(int argc, char* argv[])
  
  {
  
  int audioStream = -1;
  
  
  
  AVCodec         *aCodec;
  
  AVPacket        avPkt;
  
  AVFrame         *decode_frame = avcodec_alloc_frame();
  
  
  
  AVCodecContext  *aCodecCtxt;
  
  AVFormatContext *pFormatCtxt = NULL;
  
  
  
  if(argc != 2) {     // Checking  whether there is enough argument
  
      return -1; 
  
  }
  
  
  
  av_register_all();  //Initialize CODEC
  
  avformat_network_init();
  
  av_init_packet (&amp;avPkt);
  
  
  
  
  
   if (avformat_open_input (&amp;pFormatCtxt, argv[1],NULL,NULL)!= 0 ){ //Opening File
  
       return -2;
  
   }
  
  
  
   if(avformat_find_stream_info (pFormatCtxt,NULL) &lt; 0){ //Get Streams Info 
  
       return -3; 
  
   }
  
  
  
   AVStream *stream = NULL;
  
   //av_read_play (pFormatCtxt); //open streams
  
  
  
  
  
   for (int i = 0;  i &lt; pFormatCtxt->nb_streams ; i++) { //Find Audio Stream
  
       if (pFormatCtxt->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO){
  
           audioStream =i;
  
       }
  
   }
  
  
  
   aCodecCtxt = pFormatCtxt ->streams [audioStream]->codec; // opening decoder   
  
   aCodec = avcodec_find_decoder( pFormatCtxt->streams [audioStream] ->codec->codec_id);
  
  
  
   if (!aCodec) {
  
       return -8;
  
   }
  
  
  
   if (avcodec_open2(aCodecCtxt,aCodec,NULL)!=0) {
  
       return -9; 
  
   } 
  
  
  
  int cnt = 0;
  
  
  
  while(av_read_frame(pFormatCtxt,&amp;avPkt) >= 0 ){
  
  
  
      if (avPkt.stream_index == audioStream){
  
          int check = 0; 
  
          int result = avcodec_decode_audio4 (aCodecCtxt,decode_frame,&amp;check, &amp;avPkt);
  
          cout &lt;&lt; "Decoded : "&lt;&lt; (int) decode_frame->data[0] &lt;&lt;", "&lt;&lt; "Check : " &lt;&lt; check &lt;&lt; ", Format :" &lt;&lt; decode_frame->format &lt;&lt;" " &lt;&lt; decode_frame->linesize[0]&lt;&lt; " "&lt;<cnt return="return" acodec="acodec">id;  
  
  } 
  
  </cnt></sstream></fstream></iostream>

• Jitsi and ffplay

  15 juin 2014, par Kotkot

  I’m playing with jitsi. Got examples form source code. I modified it a bit.
  Here is what I’ve got.
  I am trying to play the transmitted stream in VLC of ffplay or any other player,
  but I cannot.

  I use these application parameters to run the code :

  --local-port-base=5000 --remote-host=localhost --remote-port-base=10000

  What am I doing wrong ?

   package com.company;
  
  
  
  
  
      /*
  
       * Jitsi, the OpenSource Java VoIP and Instant Messaging client.
  
       *
  
   * Distributable under LGPL license.
  
   * See terms of license at gnu.org.
  
   */
  
  
  
  import org.jitsi.service.libjitsi.LibJitsi;
  
  import org.jitsi.service.neomedia.*;
  
  import org.jitsi.service.neomedia.device.MediaDevice;
  
  import org.jitsi.service.neomedia.format.MediaFormat;
  
  import org.jitsi.service.neomedia.format.MediaFormatFactory;
  
  
  
  import java.io.PrintStream;
  
  import java.net.DatagramSocket;
  
  import java.net.InetAddress;
  
  import java.net.InetSocketAddress;
  
  import java.util.HashMap;
  
  import java.util.Map;
  
  
  
  /**
  
   * Implements an example application in the fashion of JMF's AVTransmit2 example
  
   * which demonstrates the use of the <tt>libjitsi</tt> library for the purposes
  
   * of transmitting audio and video via RTP means.
  
   *
  
   * @author Lyubomir Marinov
  
   */
  
  public class VideoTransmitter {
  
      /**
  
       * The port which is the source of the transmission i.e. from which the
  
       * media is to be transmitted.
  
       *
  
       * @see #LOCAL_PORT_BASE_ARG_NAME
  
       */
  
      private int localPortBase;
  
  
  
      /**
  
       * The <tt>MediaStream</tt> instances initialized by this instance indexed
  
       * by their respective <tt>MediaType</tt> ordinal.
  
       */
  
      private MediaStream[] mediaStreams;
  
  
  
      /**
  
       * The <tt>InetAddress</tt> of the host which is the target of the
  
       * transmission i.e. to which the media is to be transmitted.
  
       *
  
       * @see #REMOTE_HOST_ARG_NAME
  
       */
  
      private InetAddress remoteAddr;
  
  
  
      /**
  
       * The port which is the target of the transmission i.e. to which the media
  
       * is to be transmitted.
  
       *
  
       * @see #REMOTE_PORT_BASE_ARG_NAME
  
       */
  
      private int remotePortBase;
  
  
  
      /**
  
       * Initializes a new <tt>AVTransmit2</tt> instance which is to transmit
  
       * audio and video to a specific host and a specific port.
  
       *
  
       * @param localPortBase  the port which is the source of the transmission
  
       *                       i.e. from which the media is to be transmitted
  
       * @param remoteHost     the name of the host which is the target of the
  
       *                       transmission i.e. to which the media is to be transmitted
  
       * @param remotePortBase the port which is the target of the transmission
  
       *                       i.e. to which the media is to be transmitted
  
       * @throws Exception if any error arises during the parsing of the specified
  
       *                   <tt>localPortBase</tt>, <tt>remoteHost</tt> and <tt>remotePortBase</tt>
  
       */
  
      private VideoTransmitter(
  
              String localPortBase,
  
              String remoteHost, String remotePortBase)
  
              throws Exception {
  
          this.localPortBase
  
                  = (localPortBase == null)
  
                  ? -1
  
                  : Integer.valueOf(localPortBase).intValue();
  
          this.remoteAddr = InetAddress.getByName(remoteHost);
  
          this.remotePortBase = Integer.valueOf(remotePortBase).intValue();
  
      }
  
  
  
      /**
  
       * Starts the transmission. Returns null if transmission started ok.
  
       * Otherwise it returns a string with the reason why the setup failed.
  
       */
  
      private String start()
  
              throws Exception {
  
          /*
  
           * Prepare for the start of the transmission i.e. initialize the
  
           * MediaStream instances.
  
           */
  
          MediaType[] mediaTypes = MediaType.values();
  
          MediaService mediaService = LibJitsi.getMediaService();
  
          int localPort = localPortBase;
  
          int remotePort = remotePortBase;
  
  
  
          mediaStreams = new MediaStream[mediaTypes.length];
  
          for (MediaType mediaType : mediaTypes) {
  
              if(mediaType != MediaType.VIDEO) continue;
  
              /*
  
               * The default MediaDevice (for a specific MediaType) is configured
  
               * (by the user of the application via some sort of UI) into the
  
               * ConfigurationService. If there is no ConfigurationService
  
               * instance known to LibJitsi, the first available MediaDevice of
  
               * the specified MediaType will be chosen by MediaService.
  
               */
  
              MediaDevice device
  
                      = mediaService.getMediaDeviceForPartialDesktopStreaming(100,100,100,100);
  
              if (device == null) {
  
                  continue;
  
              }
  
              MediaStream mediaStream = mediaService.createMediaStream(device);
  
  
  
              // direction
  
              /*
  
               * The AVTransmit2 example sends only and the AVReceive2 receives
  
               * only. In a call, the MediaStream's direction will most commonly
  
               * be set to SENDRECV.
  
               */
  
              mediaStream.setDirection(MediaDirection.SENDONLY);
  
  
  
              // format
  
              String encoding;
  
              double clockRate;
  
              /*
  
               * The AVTransmit2 and AVReceive2 examples use the H.264 video
  
               * codec. Its RTP transmission has no static RTP payload type number
  
               * assigned.
  
               */
  
              byte dynamicRTPPayloadType;
  
  
  
              switch (device.getMediaType()) {
  
                  case AUDIO:
  
                      encoding = "PCMU";
  
                      clockRate = 8000;
  
                  /* PCMU has a static RTP payload type number assigned. */
  
                      dynamicRTPPayloadType = -1;
  
                      break;
  
                  case VIDEO:
  
                      encoding = "H264";
  
                      clockRate = MediaFormatFactory.CLOCK_RATE_NOT_SPECIFIED;
  
                  /*
  
                   * The dymanic RTP payload type numbers are usually negotiated
  
                   * in the signaling functionality.
  
                   */
  
                      dynamicRTPPayloadType = 99;
  
                      break;
  
                  default:
  
                      encoding = null;
  
                      clockRate = MediaFormatFactory.CLOCK_RATE_NOT_SPECIFIED;
  
                      dynamicRTPPayloadType = -1;
  
              }
  
  
  
              if (encoding != null) {
  
                  MediaFormat format
  
                          = mediaService.getFormatFactory().createMediaFormat(
  
                          encoding,
  
                          clockRate);
  
  
  
                  /*
  
                   * The MediaFormat instances which do not have a static RTP
  
                   * payload type number association must be explicitly assigned
  
                   * a dynamic RTP payload type number.
  
                   */
  
                  if (dynamicRTPPayloadType != -1) {
  
                      mediaStream.addDynamicRTPPayloadType(
  
                              dynamicRTPPayloadType,
  
                              format);
  
                  }
  
  
  
                  mediaStream.setFormat(format);
  
              }
  
  
  
              // connector
  
              StreamConnector connector;
  
  
  
              if (localPortBase == -1) {
  
                  connector = new DefaultStreamConnector();
  
              } else {
  
                  int localRTPPort = localPort++;
  
                  int localRTCPPort = localPort++;
  
  
  
                  connector
  
                          = new DefaultStreamConnector(
  
                          new DatagramSocket(localRTPPort),
  
                          new DatagramSocket(localRTCPPort));
  
              }
  
              mediaStream.setConnector(connector);
  
  
  
              // target
  
              /*
  
               * The AVTransmit2 and AVReceive2 examples follow the common
  
               * practice that the RTCP port is right after the RTP port.
  
               */
  
              int remoteRTPPort = remotePort++;
  
              int remoteRTCPPort = remotePort++;
  
  
  
              mediaStream.setTarget(
  
                      new MediaStreamTarget(
  
                              new InetSocketAddress(remoteAddr, remoteRTPPort),
  
                              new InetSocketAddress(remoteAddr, remoteRTCPPort)));
  
  
  
              // name
  
              /*
  
               * The name is completely optional and it is not being used by the
  
               * MediaStream implementation at this time, it is just remembered so
  
               * that it can be retrieved via MediaStream#getName(). It may be
  
               * integrated with the signaling functionality if necessary.
  
               */
  
              mediaStream.setName(mediaType.toString());
  
  
  
              mediaStreams[mediaType.ordinal()] = mediaStream;
  
          }
  
  
  
          /*
  
           * Do start the transmission i.e. start the initialized MediaStream
  
           * instances.
  
           */
  
          for (MediaStream mediaStream : mediaStreams) {
  
              if (mediaStream != null) {
  
  
  
                  mediaStream.start();
  
              }
  
          }
  
  
  
  
  
  
  
          return null;
  
      }
  
  
  
      /**
  
       * Stops the transmission if already started
  
       */
  
      private void stop() {
  
          if (mediaStreams != null) {
  
              for (int i = 0; i &lt; mediaStreams.length; i++) {
  
                  MediaStream mediaStream = mediaStreams[i];
  
  
  
                  if (mediaStream != null) {
  
                      try {
  
                          mediaStream.stop();
  
                      } finally {
  
                          mediaStream.close();
  
                          mediaStreams[i] = null;
  
                      }
  
                  }
  
              }
  
  
  
              mediaStreams = null;
  
          }
  
      }
  
  
  
      /**
  
       * The name of the command-line argument which specifies the port from which
  
       * the media is to be transmitted. The command-line argument value will be
  
       * used as the port to transmit the audio RTP from, the next port after it
  
       * will be to transmit the audio RTCP from. Respectively, the subsequent
  
       * ports will be used to transmit the video RTP and RTCP from."
  
       */
  
      private static final String LOCAL_PORT_BASE_ARG_NAME
  
              = "--local-port-base=";
  
  
  
      /**
  
       * The name of the command-line argument which specifies the name of the
  
       * host to which the media is to be transmitted.
  
       */
  
      private static final String REMOTE_HOST_ARG_NAME = "--remote-host=";
  
  
  
      /**
  
       * The name of the command-line argument which specifies the port to which
  
       * the media is to be transmitted. The command-line argument value will be
  
       * used as the port to transmit the audio RTP to, the next port after it
  
       * will be to transmit the audio RTCP to. Respectively, the subsequent ports
  
       * will be used to transmit the video RTP and RTCP to."
  
       */
  
      private static final String REMOTE_PORT_BASE_ARG_NAME
  
              = "--remote-port-base=";
  
  
  
      /**
  
       * The list of command-line arguments accepted as valid by the
  
       * <tt>AVTransmit2</tt> application along with their human-readable usage
  
       * descriptions.
  
       */
  
      private static final String[][] ARGS
  
              = {
  
              {
  
                      LOCAL_PORT_BASE_ARG_NAME,
  
                      "The port which is the source of the transmission i.e. from"
  
                              + " which the media is to be transmitted. The specified"
  
                              + " value will be used as the port to transmit the audio"
  
                              + " RTP from, the next port after it will be used to"
  
                              + " transmit the audio RTCP from. Respectively, the"
  
                              + " subsequent ports will be used to transmit the video RTP"
  
                              + " and RTCP from."
  
              },
  
              {
  
                      REMOTE_HOST_ARG_NAME,
  
                      "The name of the host which is the target of the transmission"
  
                              + " i.e. to which the media is to be transmitted"
  
              },
  
              {
  
                      REMOTE_PORT_BASE_ARG_NAME,
  
                      "The port which is the target of the transmission i.e. to which"
  
                              + " the media is to be transmitted. The specified value"
  
                              + " will be used as the port to transmit the audio RTP to"
  
                              + " the next port after it will be used to transmit the"
  
                              + " audio RTCP to. Respectively, the subsequent ports will"
  
                              + " be used to transmit the video RTP and RTCP to."
  
              }
  
      };
  
  
  
      public static void main(String[] args)
  
              throws Exception {
  
          // We need two parameters to do the transmission. For example,
  
          // ant run-example -Drun.example.name=AVTransmit2 -Drun.example.arg.line="--remote-host=127.0.0.1 --remote-port-base=10000"
  
          if (args.length &lt; 2) {
  
              prUsage();
  
          } else {
  
              Map argMap = parseCommandLineArgs(args);
  
  
  
              LibJitsi.start();
  
              try {
  
                  // Create a audio transmit object with the specified params.
  
                  VideoTransmitter at
  
                          = new VideoTransmitter(
  
                          argMap.get(LOCAL_PORT_BASE_ARG_NAME),
  
                          argMap.get(REMOTE_HOST_ARG_NAME),
  
                          argMap.get(REMOTE_PORT_BASE_ARG_NAME));
  
                  // Start the transmission
  
                  String result = at.start();
  
  
  
                  // result will be non-null if there was an error. The return
  
                  // value is a String describing the possible error. Print it.
  
                  if (result == null) {
  
                      System.err.println("Start transmission for 600 seconds...");
  
  
  
                      // Transmit for 60 seconds and then close the processor
  
                      // This is a safeguard when using a capture data source
  
                      // so that the capture device will be properly released
  
                      // before quitting.
  
                      // The right thing to do would be to have a GUI with a
  
                      // "Stop" button that would call stop on AVTransmit2
  
                      try {
  
                          Thread.sleep(600_000);
  
                      } catch (InterruptedException ie) {
  
                      }
  
  
  
                      // Stop the transmission
  
                      at.stop();
  
  
  
                      System.err.println("...transmission ended.");
  
                  } else {
  
                      System.err.println("Error : " + result);
  
                  }
  
              } finally {
  
                  LibJitsi.stop();
  
              }
  
          }
  
      }
  
  
  
      /**
  
       * Parses the arguments specified to the <tt>AVTransmit2</tt> application on
  
       * the command line.
  
       *
  
       * @param args the arguments specified to the <tt>AVTransmit2</tt>
  
       *             application on the command line
  
       * @return a <tt>Map</tt> containing the arguments specified to the
  
       * <tt>AVTransmit2</tt> application on the command line in the form of
  
       * name-value associations
  
       */
  
      static Map parseCommandLineArgs(String[] args) {
  
          Map argMap = new HashMap();
  
  
  
          for (String arg : args) {
  
              int keyEndIndex = arg.indexOf('=');
  
              String key;
  
              String value;
  
  
  
              if (keyEndIndex == -1) {
  
                  key = arg;
  
                  value = null;
  
              } else {
  
                  key = arg.substring(0, keyEndIndex + 1);
  
                  value = arg.substring(keyEndIndex + 1);
  
              }
  
              argMap.put(key, value);
  
          }
  
          return argMap;
  
      }
  
  
  
      /**
  
       * Outputs human-readable description about the usage of the
  
       * <tt>AVTransmit2</tt> application and the command-line arguments it
  
       * accepts as valid.
  
       */
  
      private static void prUsage() {
  
          PrintStream err = System.err;
  
  
  
          err.println("Usage: " + VideoTransmitter.class.getName() + " <args>");
  
          err.println("Valid args:");
  
          for (String[] arg : ARGS)
  
              err.println("  " + arg[0] + " " + arg[1]);
  
      }
  
      }
  
  </args>