Recherche avancée

Sur d’autres sites (4709)

• ADD Image overlay to ffmpeg video stream

  1er juillet 2017, par Chris

  I am new to ffmpeg and want to add an HUD to the video stream, so a few questions.

  1. What file do I need to edit.
  2. What do I need to do to achieve this.

  Thanks in advance. Also I am VERY new to all of this, I will need instructions step by step

  I saw other questions saying to add this : ffmpeg -n -i video.mp4 -i logo.png -filter_complex "[0:v]setsar=sar=1[v];[v][1]blend=all_mode='overlay':all_opacity=0.7" -movflags +faststart tmb/video.mp4

  But I dont know where to put it, i entered it in the terminal and got this :

  pi@raspberrypi:~ $ ffmpeg -n -i video.mp4 -i logo.png -filter_complex "[0:v]setsar=sar=1[v];[v][1]blend=all_mode='overlay':all_opacity=0.7" -movflags +faststart tmb/video.mp4
  
  ffmpeg version N-86215-gb5228e4 Copyright (c) 2000-2017 the FFmpeg developers
  
    built with gcc 4.9.2 (Raspbian 4.9.2-10)
  
    configuration: --arch=armel --target-os=linux --enable-gpl --enable-libx264 --enable-nonfree --extra-libs=-ldl
  
    libavutil      55. 63.100 / 55. 63.100
  
    libavcodec     57. 96.101 / 57. 96.101
  
    libavformat    57. 72.101 / 57. 72.101
  
    libavdevice    57.  7.100 / 57.  7.100
  
    libavfilter     6. 90.100 /  6. 90.100
  
    libswscale      4.  7.101 /  4.  7.101
  
    libswresample   2.  8.100 /  2.  8.100
  
    libpostproc    54.  6.100 / 54.  6.100
  
  video.mp4: No such file or directory

  I dont understand what i am supposed to do with the video.mp4 ?

  HERE IS THE SCRIPT THAT SENDS THE VIDEO.

  import subprocess
  
  import shlex
  
  import re
  
  import os
  
  import time
  
  import urllib2
  
  import platform
  
  import json
  
  import sys
  
  import base64
  
  import random
  
  
  
  
  
  import argparse
  
  
  
  parser = argparse.ArgumentParser(description='robot control')
  
  parser.add_argument('camera_id')
  
  parser.add_argument('video_device_number', default=0, type=int)
  
  parser.add_argument('--kbps', default=450, type=int)
  
  parser.add_argument('--brightness', default=75, type=int, help='camera brightness')
  
  parser.add_argument('--contrast', default=75, type=int, help='camera contrast')
  
  parser.add_argument('--saturation', default=15, type=int, help='camera saturation')
  
  parser.add_argument('--rotate180', default=False, type=bool, help='rotate image 180 degrees')
  
  parser.add_argument('--env', default="prod")
  
  
  
  
  
  
  
  args = parser.parse_args()
  
  
  
  
  
  
  
  server = "runmyrobot.com"
  
  #server = "52.52.213.92"
  
  
  
  
  
  from socketIO_client import SocketIO, LoggingNamespace
  
  
  
  # enable raspicam driver in case a raspicam is being used
  
  os.system("sudo modprobe bcm2835-v4l2")
  
  
  
  
  
  if args.env == "dev":
  
      print "using dev port 8122"
  
      port = 8122
  
  elif args.env == "prod":
  
      print "using prod port 8022"
  
      port = 8022
  
  else:
  
      print "invalid environment"
  
      sys.exit(0)
  
  
  
  
  
  print "initializing socket io"
  
  print "server:", server
  
  print "port:", port
  
  socketIO = SocketIO(server, port, LoggingNamespace)
  
  print "finished initializing socket io"
  
  
  
  #ffmpeg -f qtkit -i 0 -f mpeg1video -b 400k -r 30 -s 320x240 http://52.8.81.124:8082/hello/320/240/
  
  
  
  
  
  def onHandleCameraCommand(*args):
  
      #thread.start_new_thread(handle_command, args)
  
      print args
  
  
  
  
  
  socketIO.on('command_to_camera', onHandleCameraCommand)
  
  
  
  
  
  def onHandleTakeSnapshotCommand(*args):
  
      print "taking snapshot"
  
      inputDeviceID = streamProcessDict['device_answer']
  
      snapShot(platform.system(), inputDeviceID)
  
      with open ("snapshot.jpg", 'rb') as f:
  
          data = f.read()
  
      print "emit"
  
  
  
      socketIO.emit('snapshot', {'image':base64.b64encode(data)})
  
  
  
  socketIO.on('take_snapshot_command', onHandleTakeSnapshotCommand)
  
  
  
  
  
  def randomSleep():
  
      """A short wait is good for quick recovery, but sometimes a longer delay is needed or it will just keep trying and failing short intervals, like because the system thinks the port is still in use and every retry makes the system think it's still in use. So, this has a high likelihood of picking a short interval, but will pick a long one sometimes."""
  
  
  
      timeToWait = random.choice((0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 5))
  
      print "sleeping", timeToWait
  
      time.sleep(timeToWait)
  
  
  
  
  
  
  
  def getVideoPort():
  
  
  
  
  
      url = 'http://%s/get_video_port/%s' % (server, cameraIDAnswer)
  
  
  
  
  
      for retryNumber in range(2000):
  
          try:
  
              print "GET", url
  
              response = urllib2.urlopen(url).read()
  
              break
  
          except:
  
              print "could not open url ", url
  
              time.sleep(2)
  
  
  
      return json.loads(response)['mpeg_stream_port']
  
  
  
  def getAudioPort():
  
  
  
  
  
      url = 'http://%s/get_audio_port/%s' % (server, cameraIDAnswer)
  
  
  
  
  
      for retryNumber in range(2000):
  
          try:
  
              print "GET", url
  
              response = urllib2.urlopen(url).read()
  
              break
  
          except:
  
              print "could not open url ", url
  
              time.sleep(2)
  
  
  
      return json.loads(response)['audio_stream_port']
  
  
  
  
  
  
  
  def runFfmpeg(commandLine):
  
  
  
      print commandLine
  
      ffmpegProcess = subprocess.Popen(shlex.split(commandLine))
  
      print "command started"
  
  
  
      return ffmpegProcess
  
  
  
  
  
  
  
  def handleDarwin(deviceNumber, videoPort, audioPort):
  
  
  
  
  
      p = subprocess.Popen(["ffmpeg", "-list_devices", "true", "-f", "qtkit", "-i", "dummy"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  
  
  
      out, err = p.communicate()
  
  
  
      print err
  
  
  
      deviceAnswer = raw_input("Enter the number of the camera device for your robot from the list above: ")
  
      commandLine = 'ffmpeg -f qtkit -i %s -f mpeg1video -b 400k -r 30 -s 320x240 http://%s:%s/hello/320/240/' % (deviceAnswer, server, videoPort)
  
  
  
      process = runFfmpeg(commandLine)
  
  
  
      return {'process': process, 'device_answer': deviceAnswer}
  
  
  
  
  
  def handleLinux(deviceNumber, videoPort, audioPort):
  
  
  
      print "sleeping to give the camera time to start working"
  
      randomSleep()
  
      print "finished sleeping"
  
  
  
  
  
      #p = subprocess.Popen(["ffmpeg", "-list_devices", "true", "-f", "qtkit", "-i", "dummy"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  
      #out, err = p.communicate()
  
      #print err
  
  
  
  
  
      os.system("v4l2-ctl -c brightness={brightness} -c contrast={contrast} -c saturation={saturation}".format(brightness=args.brightness,
  
                                                                                                               contrast=args.contrast,
  
                                                                                                               saturation=args.saturation))
  
  
  
  
  
      if deviceNumber is None:
  
          deviceAnswer = raw_input("Enter the number of the camera device for your robot: ")
  
      else:
  
          deviceAnswer = str(deviceNumber)
  
  
  
  
  
      #commandLine = '/usr/local/bin/ffmpeg -s 320x240 -f video4linux2 -i /dev/video%s -f mpeg1video -b 1k -r 20 http://runmyrobot.com:%s/hello/320/240/' % (deviceAnswer, videoPort)
  
      #commandLine = '/usr/local/bin/ffmpeg -s 640x480 -f video4linux2 -i /dev/video%s -f mpeg1video -b 150k -r 20 http://%s:%s/hello/640/480/' % (deviceAnswer, server, videoPort)
  
      # For new JSMpeg
  
      #commandLine = '/usr/local/bin/ffmpeg -f v4l2 -framerate 25 -video_size 640x480 -i /dev/video%s -f mpegts -codec:v mpeg1video -s 640x480 -b:v 250k -bf 0 http://%s:%s/hello/640/480/' % (deviceAnswer, server, videoPort) # ClawDaddy
  
      #commandLine = '/usr/local/bin/ffmpeg -s 1280x720 -f video4linux2 -i /dev/video%s -f mpeg1video -b 1k -r 20 http://runmyrobot.com:%s/hello/1280/720/' % (deviceAnswer, videoPort)
  
  
  
  
  
      if args.rotate180:
  
          rotationOption = "-vf transpose=2,transpose=2"
  
      else:
  
          rotationOption = ""
  
  
  
      # video with audio
  
      videoCommandLine = '/usr/local/bin/ffmpeg -f v4l2 -framerate 25 -video_size 640x480 -i /dev/video%s %s -f mpegts -codec:v mpeg1video -s 640x480 -b:v %dk -bf 0 -muxdelay 0.001 http://%s:%s/hello/640/480/' % (deviceAnswer, rotationOption, args.kbps, server, videoPort)
  
      audioCommandLine = '/usr/local/bin/ffmpeg -f alsa -ar 44100 -ac 1 -i hw:1 -f mpegts -codec:a mp2 -b:a 32k -muxdelay 0.001 http://%s:%s/hello/640/480/' % (server, audioPort)
  
  
  
  
  
      print videoCommandLine
  
      print audioCommandLine
  
  
  
      videoProcess = runFfmpeg(videoCommandLine)
  
      audioProcess = runFfmpeg(audioCommandLine)
  
  
  
      return {'video_process': videoProcess, 'audioProcess': audioProcess, 'device_answer': deviceAnswer}
  
  
  
  
  
  
  
  def handleWindows(deviceNumber, videoPort):
  
  
  
      p = subprocess.Popen(["ffmpeg", "-list_devices", "true", "-f", "dshow", "-i", "dummy"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  
  
  
  
  
      out, err = p.communicate() 
  
      lines = err.split('\n')
  
  
  
      count = 0
  
  
  
      devices = []
  
  
  
      for line in lines:
  
  
  
          #if "]  \"" in line:
  
          #    print "line:", line
  
  
  
          m = re.search('.*\\"(.*)\\"', line)
  
          if m != None:
  
              #print line
  
              if m.group(1)[0:1] != '@':
  
                  print count, m.group(1)
  
                  devices.append(m.group(1))
  
                  count += 1
  
  
  
  
  
      if deviceNumber is None:
  
          deviceAnswer = raw_input("Enter the number of the camera device for your robot from the list above: ")
  
      else:
  
          deviceAnswer = str(deviceNumber)
  
  
  
      device = devices[int(deviceAnswer)]
  
      commandLine = 'ffmpeg -s 640x480 -f dshow -i video="%s" -f mpegts -codec:v mpeg1video -b 200k -r 20 http://%s:%s/hello/640/480/' % (device, server, videoPort)
  
  
  
  
  
      process = runFfmpeg(commandLine)
  
  
  
      return {'process': process, 'device_answer': device}
  
  
  
  
  
  
  
  def handleWindowsScreenCapture(deviceNumber, videoPort):
  
  
  
      p = subprocess.Popen(["ffmpeg", "-list_devices", "true", "-f", "dshow", "-i", "dummy"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  
  
  
  
  
      out, err = p.communicate()
  
  
  
      lines = err.split('\n')
  
  
  
      count = 0
  
  
  
      devices = []
  
  
  
      for line in lines:
  
  
  
          #if "]  \"" in line:
  
          #    print "line:", line
  
  
  
          m = re.search('.*\\"(.*)\\"', line)
  
          if m != None:
  
              #print line
  
              if m.group(1)[0:1] != '@':
  
                  print count, m.group(1)
  
                  devices.append(m.group(1))
  
                  count += 1
  
  
  
  
  
      if deviceNumber is None:
  
          deviceAnswer = raw_input("Enter the number of the camera device for your robot from the list above: ")
  
      else:
  
          deviceAnswer = str(deviceNumber)
  
  
  
  
  
  
  
      device = devices[int(deviceAnswer)]
  
      commandLine = 'ffmpeg -f dshow -i video="screen-capture-recorder" -vf "scale=640:480" -f mpeg1video -b 50k -r 20 http://%s:%s/hello/640/480/' % (server, videoPort)
  
  
  
      print "command line:", commandLine
  
  
  
      process = runFfmpeg(commandLine)
  
  
  
      return {'process': process, 'device_answer': device}
  
  
  
  
  
  
  
  
  
  def snapShot(operatingSystem, inputDeviceID, filename="snapshot.jpg"):    
  
  
  
      try:
  
          os.remove('snapshot.jpg')
  
      except:
  
          print "did not remove file"
  
  
  
      commandLineDict = {
  
          'Darwin': 'ffmpeg -y -f qtkit -i %s -vframes 1 %s' % (inputDeviceID, filename),
  
          'Linux': '/usr/local/bin/ffmpeg -y -f video4linux2 -i /dev/video%s -vframes 1 -q:v 1000 -vf scale=320:240 %s' % (inputDeviceID, filename),
  
          'Windows': 'ffmpeg -y -s 320x240 -f dshow -i video="%s" -vframes 1 %s' % (inputDeviceID, filename)}
  
  
  
      print commandLineDict[operatingSystem]
  
      os.system(commandLineDict[operatingSystem])
  
  
  
  
  
  
  
  def startVideoCapture():
  
  
  
      videoPort = getVideoPort()
  
      audioPort = getAudioPort()
  
      print "video port:", videoPort
  
      print "audio port:", audioPort
  
  
  
      #if len(sys.argv) >= 3:
  
      #    deviceNumber = sys.argv[2]
  
      #else:
  
      #    deviceNumber = None
  
      deviceNumber = args.video_device_number
  
  
  
      result = None
  
      if platform.system() == 'Darwin':
  
          result = handleDarwin(deviceNumber, videoPort, audioPort)
  
      elif platform.system() == 'Linux':
  
          result = handleLinux(deviceNumber, videoPort, audioPort)
  
      elif platform.system() == 'Windows':
  
          #result = handleWindowsScreenCapture(deviceNumber, videoPort)
  
          result = handleWindows(deviceNumber, videoPort, audioPort)
  
      else:
  
          print "unknown platform", platform.system()
  
  
  
      return result
  
  
  
  
  
  def timeInMilliseconds():
  
      return int(round(time.time() * 1000))
  
  
  
  
  
  
  
  def main():
  
  
  
      print "main"
  
  
  
      streamProcessDict = None
  
  
  
  
  
      twitterSnapCount = 0
  
  
  
      while True:
  
  
  
  
  
  
  
          socketIO.emit('send_video_status', {'send_video_process_exists': True,
  
                                              'camera_id':cameraIDAnswer})
  
  
  
  
  
          if streamProcessDict is not None:
  
              print "stopping previously running ffmpeg (needs to happen if this is not the first iteration)"
  
              streamProcessDict['process'].kill()
  
  
  
          print "starting process just to get device result" # this should be a separate function so you don't have to do this
  
          streamProcessDict = startVideoCapture()
  
          inputDeviceID = streamProcessDict['device_answer']
  
          print "stopping video capture"
  
          streamProcessDict['process'].kill()
  
  
  
          #print "sleeping"
  
          #time.sleep(3)
  
          #frameCount = int(round(time.time() * 1000))
  
  
  
          videoWithSnapshots = False
  
          while videoWithSnapshots:
  
  
  
              frameCount = timeInMilliseconds()
  
  
  
              print "taking single frame image"
  
              snapShot(platform.system(), inputDeviceID, filename="single_frame_image.jpg")
  
  
  
              with open ("single_frame_image.jpg", 'rb') as f:
  
  
  
                  # every so many frames, post a snapshot to twitter
  
                  #if frameCount % 450 == 0:
  
                  if frameCount % 6000 == 0:
  
                          data = f.read()
  
                          print "emit"
  
                          socketIO.emit('snapshot', {'frame_count':frameCount, 'image':base64.b64encode(data)})
  
                  data = f.read()
  
  
  
              print "emit"
  
              socketIO.emit('single_frame_image', {'frame_count':frameCount, 'image':base64.b64encode(data)})
  
              time.sleep(0)
  
  
  
              #frameCount += 1
  
  
  
  
  
          if False:
  
           if platform.system() != 'Windows':
  
              print "taking snapshot"
  
              snapShot(platform.system(), inputDeviceID)
  
              with open ("snapshot.jpg", 'rb') as f:
  
                  data = f.read()
  
              print "emit"
  
  
  
              # skip sending the first image because it's mostly black, maybe completely black
  
              #todo: should find out why this black image happens
  
              if twitterSnapCount > 0:
  
                  socketIO.emit('snapshot', {'image':base64.b64encode(data)})
  
  
  
  
  
  
  
  
  
          print "starting video capture"
  
          streamProcessDict = startVideoCapture()
  
  
  
  
  
          # This loop counts out a delay that occurs between twitter snapshots.
  
          # Every 50 seconds, it kills and restarts ffmpeg.
  
          # Every 40 seconds, it sends a signal to the server indicating status of processes.
  
          period = 2*60*60 # period in seconds between snaps
  
          for count in range(period):
  
              time.sleep(1)
  
  
  
              if count % 20 == 0:
  
                  socketIO.emit('send_video_status', {'send_video_process_exists': True,
  
                                                      'camera_id':cameraIDAnswer})
  
  
  
              if count % 40 == 30:
  
                  print "stopping video capture just in case it has reached a state where it's looping forever, not sending video, and not dying as a process, which can happen"
  
                  streamProcessDict['video_process'].kill()
  
                  streamProcessDict['audio_process'].kill()
  
                  time.sleep(1)
  
  
  
              if count % 80 == 75:
  
                  print "send status about this process and its child process ffmpeg"
  
                  ffmpegProcessExists = streamProcessDict['process'].poll() is None
  
                  socketIO.emit('send_video_status', {'send_video_process_exists': True,
  
                                                      'ffmpeg_process_exists': ffmpegProcessExists,
  
                                                      'camera_id':cameraIDAnswer})
  
  
  
              #if count % 190 == 180:
  
              #    print "reboot system in case the webcam is not working"
  
              #    os.system("sudo reboot")
  
  
  
              # if the video stream process dies, restart it
  
              if streamProcessDict['video_process'].poll() is not None or streamProcessDict['audio_process'].poll():
  
                  # wait before trying to start ffmpeg
  
                  print "ffmpeg process is dead, waiting before trying to restart"
  
                  randomSleep()
  
                  streamProcessDict = startVideoCapture()
  
  
  
          twitterSnapCount += 1
  
  
  
  if __name__ == "__main__":
  
  
  
  
  
      #if len(sys.argv) > 1:
  
      #    cameraIDAnswer = sys.argv[1]
  
      #else:
  
      #    cameraIDAnswer = raw_input("Enter the Camera ID for your robot, you can get it by pointing a browser to the runmyrobot server %s: " % server)
  
  
  
      cameraIDAnswer = args.camera_id
  
  
  
  
  
      main()

  ERROR :

  ffmpeg -n -f mpegts -i http://54.183.232.63:12221 -i logo.png -filter_complex "[0:v]setsar=sar=1[v];[v][1]blend=all_mode='overlay':all_opacity=0.7" -movflags +faststart tmb/video.mp4
  
  ffmpeg version N-86215-gb5228e4 Copyright (c) 2000-2017 the FFmpeg developers
  
    built with gcc 4.9.2 (Raspbian 4.9.2-10)
  
    configuration: --arch=armel --target-os=linux --enable-gpl --enable-libx264 --enable-nonfree --extra-libs=-ldl
  
    libavutil      55. 63.100 / 55. 63.100
  
    libavcodec     57. 96.101 / 57. 96.101
  
    libavformat    57. 72.101 / 57. 72.101
  
    libavdevice    57.  7.100 / 57.  7.100
  
    libavfilter     6. 90.100 /  6. 90.100
  
    libswscale      4.  7.101 /  4.  7.101
  
    libswresample   2.  8.100 /  2.  8.100
  
    libpostproc    54.  6.100 / 54.  6.100
  
  [mpegts @ 0x1a57390] Could not detect TS packet size, defaulting to non-FEC/DVHS
  
  http://54.183.232.63:12221: could not find codec parameters

• Video rotating to left by 90 degree when converted using ffmpeg

  15 juillet 2017, par Herdesh Verma

  I developed a below code :

  extern "C"
  
  {
  
  #include <libavutil></libavutil>imgutils.h>
  
  #include <libavutil></libavutil>opt.h>
  
  #include <libavcodec></libavcodec>avcodec.h>
  
  #include <libavutil></libavutil>mathematics.h>
  
  #include <libavutil></libavutil>samplefmt.h>
  
  #include <libavutil></libavutil>timestamp.h>
  
  #include <libavformat></libavformat>avformat.h>
  
  #include <libavfilter></libavfilter>avfiltergraph.h>
  
  #include <libswscale></libswscale>swscale.h>
  
  }
  
  #include 
  
  static AVFormatContext *fmt_ctx = NULL;
  
  
  
  static int frame_index = 0;
  
  
  
  static int j = 0, nbytes=0;
  
  uint8_t *video_outbuf = NULL;
  
  static AVPacket *pAVPacket=NULL;
  
  static int value=0;
  
  static AVFrame *pAVFrame=NULL;
  
  static AVFrame *outFrame=NULL;
  
  static AVStream *video_st=NULL;
  
  static AVFormatContext *outAVFormatContext=NULL;
  
  static AVCodec *outAVCodec=NULL;
  
  static AVOutputFormat *output_format=NULL;
  
  static AVCodecContext *video_dec_ctx = NULL, *audio_dec_ctx;
  
  static AVCodecContext *outAVCodecContext=NULL;
  
  static int width, height;
  
  static enum AVPixelFormat pix_fmt;
  
  static AVStream *video_stream = NULL, *audio_stream = NULL;
  
  static const char *src_filename = NULL;
  
  static const char *video_dst_filename = NULL;
  
  static const char *audio_dst_filename = NULL;
  
  static FILE *video_dst_file = NULL;
  
  static FILE *audio_dst_file = NULL;
  
  static uint8_t *video_dst_data[4] = {NULL};
  
  static int      video_dst_linesize[4];
  
  static int video_dst_bufsize;
  
  static int video_stream_idx = -1, audio_stream_idx = -1;
  
  static AVPacket *pkt=NULL;
  
  static AVPacket *pkt1=NULL;
  
  static AVFrame *frame = NULL;
  
  //static AVPacket pkt;
  
  static int video_frame_count = 0;
  
  static int audio_frame_count = 0;
  
  static int refcount = 0;
  
  AVCodec *codec;
  
  static struct SwsContext *sws_ctx;
  
  AVCodecContext *c= NULL;
  
   int i, out_size, size, x, y, outbuf_size;
  
   AVFrame *picture;
  
   uint8_t *outbuf, *picture_buf;
  
  int video_outbuf_size;
  
  int w, h;
  
  AVPixelFormat pixFmt;
  
  uint8_t *data[4];
  
  int linesize[4];
  
  
  
  static int open_codec_context(int *stream_idx,
  
                            AVCodecContext **dec_ctx, AVFormatContext 
  
  *fmt_ctx, enum AVMediaType type)
  
  {
  
  int ret, stream_index;
  
  AVStream *st;
  
  AVCodec *dec = NULL;
  
  AVDictionary *opts = NULL;
  
  ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0);
  
  if (ret &lt; 0) {
  
      printf("Could not find %s stream in input file '%s'\n",
  
              av_get_media_type_string(type), src_filename);
  
      return ret;
  
  } else {
  
      stream_index = ret;
  
      st = fmt_ctx->streams[stream_index];
  
      /* find decoder for the stream */
  
      dec = avcodec_find_decoder(st->codecpar->codec_id);
  
      if (!dec) {
  
          printf("Failed to find %s codec\n",
  
                  av_get_media_type_string(type));
  
          return AVERROR(EINVAL);
  
      }
  
      /* Allocate a codec context for the decoder */
  
      *dec_ctx = avcodec_alloc_context3(dec);
  
      if (!*dec_ctx) {
  
          printf("Failed to allocate the %s codec context\n",
  
                  av_get_media_type_string(type));
  
          return AVERROR(ENOMEM);
  
      }
  
      /* Copy codec parameters from input stream to output codec context */
  
      if ((ret = avcodec_parameters_to_context(*dec_ctx, st->codecpar)) &lt; 0) {
  
          printf("Failed to copy %s codec parameters to decoder context\n",
  
                  av_get_media_type_string(type));
  
          return ret;
  
      }
  
      /* Init the decoders, with or without reference counting */
  
      av_dict_set(&amp;opts, "refcounted_frames", refcount ? "1" : "0", 0);
  
      if ((ret = avcodec_open2(*dec_ctx, dec, &amp;opts)) &lt; 0) {
  
          printf("Failed to open %s codec\n",
  
                  av_get_media_type_string(type));
  
          return ret;
  
      }
  
      *stream_idx = stream_index;
  
  }
  
  return 0;
  
  }
  
  
  
  
  
  
  
  int main (int argc, char **argv)
  
  {
  
   int ret = 0, got_frame;
  
  src_filename = argv[1];
  
  video_dst_filename = argv[2];
  
  audio_dst_filename = argv[3];
  
  av_register_all();
  
  avcodec_register_all();
  
  printf("Registered all\n");
  
  
  
  /* open input file, and allocate format context */
  
  if (avformat_open_input(&amp;fmt_ctx, src_filename, NULL, NULL) &lt; 0) {
  
      printf("Could not open source file %s\n", src_filename);
  
      exit(1);
  
  }
  
  
  
  /* retrieve stream information */
  
  if (avformat_find_stream_info(fmt_ctx, NULL) &lt; 0) {
  
      printf("Could not find stream information\n");
  
      exit(1);
  
  }
  
  
  
  if (open_codec_context(&amp;video_stream_idx, &amp;video_dec_ctx, fmt_ctx, 
  
  AVMEDIA_TYPE_VIDEO) >= 0) {
  
      video_stream = fmt_ctx->streams[video_stream_idx];
  
      avformat_alloc_output_context2(&amp;outAVFormatContext, NULL, NULL, 
  
  video_dst_filename);
  
      if (!outAVFormatContext)
  
      {
  
              printf("\n\nError : avformat_alloc_output_context2()");
  
              return -1;
  
      }
  
  }
  
  
  
  if (open_codec_context(&amp;audio_stream_idx, &amp;audio_dec_ctx, fmt_ctx, 
  
  AVMEDIA_TYPE_AUDIO) >= 0) {
  
      audio_stream = fmt_ctx->streams[audio_stream_idx];
  
      audio_dst_file = fopen(audio_dst_filename, "wb");
  
      if (!audio_dst_file) {
  
          printf("Could not open destination file %s\n", audio_dst_filename);
  
          ret = 1;
  
          goto end;
  
      }
  
  }
  
  /* dump input information to stderr */
  
  av_dump_format(fmt_ctx, 0, src_filename, 0);
  
  
  
  if (!audio_stream &amp;&amp; !video_stream) {
  
      printf("Could not find audio or video stream in the input, aborting\n");
  
      ret = 1;
  
      goto end;
  
  }
  
  
  
      output_format = av_guess_format(NULL, video_dst_filename, NULL);
  
      if( !output_format )
  
      {
  
       printf("\n\nError : av_guess_format()");
  
       return -1;
  
      }
  
  
  
      video_st = avformat_new_stream(outAVFormatContext ,NULL);
  
      if( !video_st )
  
      {
  
              printf("\n\nError : avformat_new_stream()");
  
        return -1;
  
      }
  
  
  
      outAVCodecContext = avcodec_alloc_context3(outAVCodec);
  
      if( !outAVCodecContext )
  
      {
  
        printf("\n\nError : avcodec_alloc_context3()");
  
        return -1;
  
      }
  
  
  
  
  
      outAVCodecContext = video_st->codec;
  
      outAVCodecContext->codec_id = AV_CODEC_ID_MPEG4;// AV_CODEC_ID_MPEG4; // 
  
   AV_CODEC_ID_H264 // AV_CODEC_ID_MPEG1VIDEO
  
      outAVCodecContext->codec_type = AVMEDIA_TYPE_VIDEO;
  
      outAVCodecContext->pix_fmt  = AV_PIX_FMT_YUV420P;
  
      outAVCodecContext->bit_rate = 400000; // 2500000
  
      outAVCodecContext->width = 1920;
  
      //outAVCodecContext->width = 500;
  
      outAVCodecContext->height = 1080;
  
      //outAVCodecContext->height = 500;
  
      outAVCodecContext->gop_size = 3;
  
      outAVCodecContext->max_b_frames = 2;
  
      outAVCodecContext->time_base.num = 1;
  
      outAVCodecContext->time_base.den = 30; // 15fps
  
  
  
      if (outAVCodecContext->codec_id == AV_CODEC_ID_H264)
  
      {
  
       av_opt_set(outAVCodecContext->priv_data, "preset", "slow", 0);
  
      }
  
  
  
      outAVCodec = avcodec_find_encoder(AV_CODEC_ID_MPEG4);
  
      if( !outAVCodec )
  
      {
  
       printf("\n\nError : avcodec_find_encoder()");
  
       return -1;
  
      }
  
  
  
      /* Some container formats (like MP4) require global headers to be 
  
   present
  
         Mark the encoder so that it behaves accordingly. */
  
  
  
      if ( outAVFormatContext->oformat->flags &amp; AVFMT_GLOBALHEADER)
  
      {
  
              outAVCodecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
  
      }
  
  
  
      value = avcodec_open2(outAVCodecContext, outAVCodec, NULL);
  
      if( value &lt; 0)
  
      {
  
              printf("\n\nError : avcodec_open2()");
  
              return -1;
  
      }
  
  
  
  /* create empty video file */
  
      if ( !(outAVFormatContext->flags &amp; AVFMT_NOFILE) )
  
      {
  
       if( avio_open2(&amp;outAVFormatContext->pb , video_dst_filename, 
  
  AVIO_FLAG_WRITE ,NULL, NULL) &lt; 0 )
  
       {
  
        printf("\n\nError : avio_open2()");
  
       }
  
      }
  
  
  
      if(!outAVFormatContext->nb_streams)
  
      {
  
              printf("\n\nError : Output file dose not contain any stream");
  
        return -1;
  
      }
  
  
  
      /* imp: mp4 container or some advanced container file required header 
  
   information*/
  
      value = avformat_write_header(outAVFormatContext , NULL);
  
      if(value &lt; 0)
  
      {
  
              printf("\n\nError : avformat_write_header()");
  
              return -1;
  
      }
  
  
  
      printf("\n\nOutput file information :\n\n");
  
      av_dump_format(outAVFormatContext , 0 ,video_dst_filename ,1);
  
  
  
  
  
      int flag;
  
      int frameFinished;
  
  
  
  
  
      value = 0;
  
  
  
      pAVPacket = (AVPacket *)av_malloc(sizeof(AVPacket));
  
      av_init_packet(pAVPacket);
  
  
  
      pAVFrame = av_frame_alloc();
  
      if( !pAVFrame )
  
      {
  
       printf("\n\nError : av_frame_alloc()");
  
       return -1;
  
      }
  
  
  
      outFrame = av_frame_alloc();//Allocate an AVFrame and set its fields to 
  
   default values.
  
      if( !outFrame )
  
      {
  
       printf("\n\nError : av_frame_alloc()");
  
       return -1;
  
      }
  
  
  
      nbytes = av_image_get_buffer_size(outAVCodecContext-
  
   >pix_fmt,outAVCodecContext->width,outAVCodecContext->height,32);
  
      video_outbuf = (uint8_t*)av_malloc(nbytes);
  
      if( video_outbuf == NULL )
  
      {
  
      printf("\n\nError : av_malloc()");
  
      }
  
  
  
  
  
      value = av_image_fill_arrays( outFrame->data, outFrame->linesize, 
  
   video_outbuf , AV_PIX_FMT_YUV420P, outAVCodecContext-
  
   >width,outAVCodecContext->height,1 ); // returns : the size in bytes 
  
   required for src
  
      if(value &lt; 0)
  
      {
  
      printf("\n\nError : av_image_fill_arrays()");
  
      }
  
  
  
      SwsContext* swsCtx_ ;
  
  
  
      // Allocate and return swsContext.
  
      // a pointer to an allocated context, or NULL in case of error
  
      // Deprecated : Use sws_getCachedContext() instead.
  
      swsCtx_ = sws_getContext(video_dec_ctx->width,
  
                              video_dec_ctx->height,
  
                              video_dec_ctx->pix_fmt,
  
                              video_dec_ctx->width,
  
                              video_dec_ctx->height,
  
                              video_dec_ctx->pix_fmt,
  
                              SWS_BICUBIC, NULL, NULL, NULL);
  
  
  
  
  
      AVPacket outPacket;
  
  
  
      int got_picture;
  
  
  
      while( av_read_frame( fmt_ctx , pAVPacket ) >= 0 )
  
      {
  
              if(pAVPacket->stream_index == video_stream_idx)
  
              {
  
                      value = avcodec_decode_video2(video_dec_ctx , pAVFrame , 
  
    &amp;frameFinished , pAVPacket );
  
                      if( value &lt; 0)
  
                      {
  
                              printf("Error : avcodec_decode_video2()");
  
                      }
  
  
  
                      if(frameFinished)// Frame successfully decoded :)
  
                      {
  
                              sws_scale(swsCtx_, pAVFrame->data, pAVFrame-
  
   >linesize,0, video_dec_ctx->height, outFrame->data,outFrame->linesize);
  
  //                              sws_scale(swsCtx_, pAVFrame->data, pAVFrame-
  
  >linesize,0, video_dec_ctx->height, outFrame->data,outFrame->linesize);
  
                              av_init_packet(&amp;outPacket);
  
                              outPacket.data = NULL;    // packet data will be 
  
   allocated by the encoder
  
                              outPacket.size = 0;
  
  
  
                              avcodec_encode_video2(outAVCodecContext , 
  
   &amp;outPacket ,outFrame , &amp;got_picture);
  
  
  
                              if(got_picture)
  
                              {
  
                                      if(outPacket.pts != AV_NOPTS_VALUE)
  
                                              outPacket.pts = 
  
   av_rescale_q(outPacket.pts, video_st->codec->time_base, video_st-
  
   >time_base);
  
                                      if(outPacket.dts != AV_NOPTS_VALUE)
  
                                              outPacket.dts = 
  
   av_rescale_q(outPacket.dts, video_st->codec->time_base, video_st-
  
   >time_base);
  
  
  
                                      printf("Write frame %3d (size= %2d)\n", 
  
   j++, outPacket.size/1000);
  
                                      if(av_write_frame(outAVFormatContext , 
  
   &amp;outPacket) != 0)
  
                                      {
  
                                              printf("\n\nError : 
  
   av_write_frame()");
  
                                      }
  
  
  
                              av_packet_unref(&amp;outPacket);
  
                              } // got_picture
  
  
  
                      av_packet_unref(&amp;outPacket);
  
                      } // frameFinished
  
  
  
              }
  
      }// End of while-loop
  
  
  
      value = av_write_trailer(outAVFormatContext);
  
      if( value &lt; 0)
  
      {
  
              printf("\n\nError : av_write_trailer()");
  
      }
  
  
  
  
  
      //THIS WAS ADDED LATER
  
      av_free(video_outbuf);
  
  
  
  end:
  
      avcodec_free_context(&amp;video_dec_ctx);
  
      avcodec_free_context(&amp;audio_dec_ctx);
  
      avformat_close_input(&amp;fmt_ctx);
  
      if (video_dst_file)
  
          fclose(video_dst_file);
  
     if (audio_dst_file)
  
         fclose(audio_dst_file);
  
     //av_frame_free(&amp;frame);
  
     av_free(video_dst_data[0]);
  
     return ret &lt; 0;
  
  }

  Problem with above code is that it rotates a video to left by 90 degree.

  Snapshot of video given as input to above program

  Snapshot of output video. It is rotated by 90 degree to left.

  I compiled program using below command :

  g++ -D__STDC_CONSTANT_MACROS -Wall -g ScreenRecorder.cpp -I/home/harry/Documents/compressor/ffmpeg-3.3/ -I/root/android-ndk-r14b/platforms/android-21/arch-x86_64/usr/include/ -c -o ScreenRecorder.o -w

  And linked it using below command :

  g++ -Wall -g ScreenRecorder.o -I/home/harry/Documents/compressor/ffmpeg-3.3/ -I/root/android-ndk-r14b/platforms/android-21/arch-x86_64/usr/include/ -L/usr/lib64 -L/lib64 -L/usr/lib/gcc/x86_64-redhat-linux/4.4.7/ -L/home/harry/Documents/compressor/ffmpeg-3.3/ffmpeg-build -L/root/android-ndk-r14b/platforms/android-21/arch-x86_64/usr/lib64 -o ScreenRecorder.exe -lavformat -lavcodec -lavutil -lavdevice -lavfilter -lswscale -lx264 -lswresample -lm -lpthread -ldl -lstdc++ -lc -lrt

  Program is being run using below command :

  ./ScreenRecorder.exe vertical.MOV videoH.mp4 audioH.mp3

  Note :
  - Source video is taken from iphone and is of .mov format.
  - Output video is being stored in .mp4 file.

  Can anyone please tell me why it is rotating video by 90 degree ?

  One thing i noticed in dump is shown below :

    Duration: 00:00:06.04, start: 0.000000, bitrate: 17087 kb/s
  
  Stream #0:0(und): Video: h264 (High) (avc1 / 0x31637661), yuv420p(tv, bt709), 1920x1080, 17014 kb/s, 29.98 fps, 29.97 tbr, 600 tbn, 1200 tbc (default)
  
  Metadata:
  
    rotate          : 90
  
    creation_time   : 2017-07-09T10:56:42.000000Z
  
    handler_name    : Core Media Data Handler
  
    encoder         : H.264
  
  Side data:
  
    displaymatrix: rotation of -90.00 degrees

  it says displaymatrix: rotation of -90.00 degrees. Is it responsible for rotating video by 90 degree ?

• KLV data in RTP stream

  18 septembre 2013, par Ardoramor

  I have implemented RFC6597 to stream KLV is RTP SMPTE336M packets. Currently, my SDP looks like this :

  v=2
  
  o=- 0 0 IN IP4 127.0.0.1
  
  s=Unnamed
  
  i=N/A
  
  c=IN IP4 192.168.1.6
  
  t=0 0
  
  a=recvonly
  
  m=video 8202 RTP/AVP 96
  
  a=rtpmap:96 H264/90000
  
  a=fmtp:96 packetization-mode=1;profile-level-id=428028;sprop-parameter-sets=Z0KAKJWgKA9E,aM48gA==;
  
  a=control:trackID=0
  
  m=application 8206 RTP/AVP 97
  
  a=rtpmap:97 smpte336m/1000
  
  a=control:trackID=1

  I try to remux the RTP stream with FFmpeg like so :

  ffmpeg.exe -i test.sdp -map 0:0 -map 0:1 -c:v copy -c:d copy test.m2ts

  I get the following output with FFmpeg :

  ffmpeg version 1.2 Copyright (c) 2000-2013 the FFmpeg developers
  
    built on Mar 28 2013 00:34:08 with gcc 4.8.0 (GCC)
  
    configuration: --enable-gpl --enable-version3 --disable-w32threads --enable-avisynth --enable-bzlib --enable-fontconfig --enable-frei0r --enable-gnutls --enable-libass --enable-libbluray --enable-libcaca --enable-libfreetype --enable-libgsm --enable-libilbc --enable-libmp3lame --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libopenjpeg --enable-libopus --enable-librtmp --enable-libschroedinger --enable-libsoxr --enable-libspeex --enable-libtheora --enable-libtwolame --enable-libvo-aacenc --enable-libvo-amrwbenc --enable-libvorbis --enable-libvpx --enable-libx264 --enable-libxavs --enable-libxvid --enable-zlib
  
    libavutil      52. 18.100 / 52. 18.100
  
    libavcodec     54. 92.100 / 54. 92.100
  
    libavformat    54. 63.104 / 54. 63.104
  
    libavdevice    54.  3.103 / 54.  3.103
  
    libavfilter     3. 42.103 /  3. 42.103
  
    libswscale      2.  2.100 /  2.  2.100
  
    libswresample   0. 17.102 /  0. 17.102
  
    libpostproc    52.  2.100 / 52.  2.100
  
  [aac @ 0000000002137900] Sample rate index in program config element does not match the sample rate index configured by the container.
  
      Last message repeated 1 times
  
  [aac @ 0000000002137900] decode_pce: Input buffer exhausted before END element found
  
  [h264 @ 00000000002ce540] Missing reference picture, default is 0
  
  [h264 @ 00000000002ce540] decode_slice_header error
  
  [sdp @ 00000000002cfa80] Estimating duration from bitrate, this may be inaccurate
  
  Input #0, sdp, from 'C:\Users\dragan\Documents\Workspace\Android\uvlens\tests\test.sdp':
  
    Metadata:
  
      title           : Unnamed
  
      comment         : N/A
  
    Duration: N/A, start: 0.000000, bitrate: N/A
  
      Stream #0:0: Audio: aac, 32000 Hz, 58 channels, fltp
  
      Stream #0:1: Video: h264 (Baseline), yuv420p, 640x480, 14.83 tbr, 90k tbn, 180k tbc
  
      Stream #0:2: Data: none
  
  File 'C:\Users\dragan\Documents\Workspace\Android\uvlens\tests\test.m2ts' already exists. Overwrite ? [y/N] y
  
  Output #0, mpegts, to 'C:\Users\dragan\Documents\Workspace\Android\uvlens\tests\test.m2ts':
  
    Metadata:
  
      title           : Unnamed
  
      comment         : N/A
  
      encoder         : Lavf54.63.104
  
      Stream #0:0: Video: h264, yuv420p, 640x480, q=2-31, 90k tbn, 90k tbc
  
      Stream #0:1: Data: none
  
  Stream mapping:
  
    Stream #0:1 -> #0:0 (copy)
  
    Stream #0:2 -> #0:1 (copy)
  
  Press [q] to stop, [?] for help
  
  [mpegts @ 0000000002159940] Application provided invalid, non monotonically increasing dts to muxer in stream 1: 8583659665 >= 8583656110
  
  av_interleaved_write_frame(): Invalid argument

  The problem is that KLV stream packets do not contain have a DTS field. According to the RFC6597 STMPE336M, RTP packet structure is the same as a standard structure :

  4.1.  RTP Header Usage
  
  
  
  This payload format uses the RTP packet header fields as described in
  
  the table below:
  
  
  
  +-----------+-------------------------------------------------------+
  
  | Field     | Usage                                                 |
  
  +-----------+-------------------------------------------------------+
  
  | Timestamp | The RTP Timestamp encodes the instant along a         |
  
  |           | presentation timeline that the entire KLVunit encoded |
  
  |           | in the packet payload is to be presented.  When one   |
  
  |           | KLVunit is placed in multiple RTP packets, the RTP    |
  
  |           | timestamp of all packets comprising that KLVunit MUST |
  
  |           | be the same.  The timestamp clock frequency is        |
  
  |           | defined as a parameter to the payload format          |
  
  |           | (Section 6).                                          |
  
  |           |                                                       |
  
  | M-bit     | The RTP header marker bit (M) is used to demarcate    |
  
  |           | KLVunits.  Senders MUST set the marker bit to '1' for |
  
  |           | any RTP packet that contains the final byte of a      |
  
  |           | KLVunit.  For all other packets, senders MUST set the |
  
  |           | RTP header marker bit to '0'.  This allows receivers  |
  
  |           | to pass a KLVunit for parsing/decoding immediately    |
  
  |           | upon receipt of the last RTP packet comprising the    |
  
  |           | KLVunit.  Without this, a receiver would need to wait |
  
  |           | for the next RTP packet with a different timestamp to |
  
  |           | arrive, thus signaling the end of one KLVunit and the |
  
  |           | start of another.                                     |
  
  +-----------+-------------------------------------------------------+
  
  
  
  The remaining RTP header fields are used as specified in [RFC3550].

  Header from RFC3550 :

  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  
  |V=2|P|X|  CC   |M|     PT      |       sequence number         |
  
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  
  |                           timestamp                           |
  
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  
  |           synchronization source (SSRC) identifier            |
  
  +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
  
  |            contributing source (CSRC) identifiers             |
  
  |                             ....                              |
  
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

  RFC's note about placement of KLV data into RTP packet :

  KLVunits small enough to fit into a single RTP
  packet (RTP packet size is up to the implementation but should
  consider underlying transport/network factors such as MTU
  limitations) are placed directly into the payload of the RTP packet,
  with the first byte of the KLVunit (which is the first byte of a KLV
  Universal Label Key) being the first byte of the RTP packet payload.

  My question is where does FFmpeg keep looking for the DTS ?

  Does it interpret the Timestamp field of the RTP packet header as DTS ? If so, I've verified that the timestamps increase (although at different rates) but are not equal to what FFmpeg prints out :

  8583659665 >= 8583656110