Recherche avancée

Sur d’autres sites (7562)

• ffmpeg - color-grading video material AND display original source as picture-in-picture, using -filter_complex

  5 octobre 2019, par raven

  this is my first post on this forum, so please be gentle in case I accidentally do trip over any forum rules that I would not know of yet :).

  I would like to apply some color-grading to underwater GoPro footage. To quicker gauge the effect of my color settings (trial-and-error, as of yet), would like to see the original input video stream as a PIP (e.g., scaled down to 50% or even 30%), in the bottom-right corner of the converted output movie.

  I have one input movie that is going to be color graded. The PIP should use the original as an input, just a scaled-down version of it.

  I would like to use ffmpeg’s "-filter_complex" option to do the PIP, but all examples I can find on "-filter_complex" would use two already existing movies. Instead, I would like to make the color-corrected stream an on-the-fly input to "-filter_complex", which then renders the PIP.

  Is that doable, all in one go ?

  Both the individual snippets below work fine, I now would like to combine these and skip the creation of an intermediate color-graded TMP output which then gets combined, with the original, in a final PIP creation process.
  Your help combining these two separate steps into one single "-filter_complex" action is greatly appreciated !

  Thanks in advance,
  raven.

  [existing code snippets (M$ batch files)]
  
  
  
  ::declarations/defines::
  
  set "INPUT="
  
  set "TMP="
  
  set "OUTPUT="
  
  set "FFMPG="
  
  set "QU=9" :: quality settings
  
  
  
  set "CONV='"0 -1 0 -1 5 -1 0 -1 0:0 -1 0 -1 5 -1 0 -1 0:0 -1 0 -1 5 -1 
  
  0 -1 0:0 -1 0 -1 5 -1 0 -1 0'"" :: sharpening convolution filter
  
  
  
  ::color-grading part::
  
  %FFMPG% -i %INPUT% -vf convolution=%CONV%,colorbalance=rs=%rs%:gs=%gs%:bs=%bs%:rm=%rm%:gm=%gm%:bm=%bm%:rh=%rh%:gh=%gh%:bh=%bh% -q:v %QU% -codec:v mpeg4 %TMP%
  
  
  
  ::PIP part::
  
  %FFMPG% -i %TMP% -i %INPUT% -filter_complex "[1]scale=iw/3:ih/3 
  
  [pip]; [0][pip] overlay=main_w-overlay_w-10:main_h-overlay_h-10" -q:v 
  
  %QU% -codec:v mpeg4 %OUTPUT%
  
  
  
  [/existing code]

• lavc/videotoolboxdec : fix crop handling when multithreaded

  7 septembre 2019, par Rodger Combs

  lavc/videotoolboxdec : fix crop handling when multithreaded
  This was partially fixed by 233cd89, but it made changes to AVFrame fields
  
  from within end_frame, which doesn't work consistently when multithreading
  
  is enabled. This is what the post_process function is for.
  Signed-off-by : Aman Gupta <aman@tmm1.net>
  

  • [DH] libavcodec/videotoolbox.c

• RTMP streaming using FFMPEG and HLS conversion in NGINX

  1er mai 2019, par Jonathan Piat

  i have some ffmpeg code in c++ that generates a RTMP stream from H264 NALU and audio samples encoded in AAC. I’am using NGINX to take the RTMP stream and forwards to clients and it is working fine. My issue is that when i use NGINX to convert the RTMP stream to HLS, there is no HLS chunks and playlist generated. I use ffmpeg to copy the RTMP stream and generate a new stream to NGINX, the HLS conversion works.

  Here is what i get when i do the stream copy using FFMPEG :

  Input #0, flv, from 'rtmp://127.0.0.1/live/beam_0'
  
  Metadata:
  
  Server          : NGINX RTMP (github.com/sergey-dryabzhinsky/nginx-rtmp-module)
  
  displayWidth    : 1920
  
  displayHeight   : 1080
  
  fps             : 30
  
  profile         : 
  
  level           : 
  
  Duration: 00:00:00.00, start: 5.019000, bitrate: N/A
  
  Stream #0:0: Audio: aac, 44100 Hz, mono, fltp, 128 kb/s
  
  Stream #0:1: Video: h264 (High), 1 reference frame, yuv420p(progressive, left), 1920x1080 (1920x1088), 8000 kb/s, 30 fps, 30.30 tbr, 1k tbn, 60 tbc
  
  
  
  Output #0, flv, to 'rtmp://localhost/live/copy_stream':
  
  Metadata:
  
  Server          : NGINX RTMP (github.com/sergey-dryabzhinsky/nginx-rtmp-module)
  
  displayWidth    : 1920
  
  displayHeight   : 1080
  
  fps             : 30
  
  profile         : 
  
  level           : 
  
  encoder         : Lavf57.83.100
  
  Stream #0:0: Video: h264 (High), 1 reference frame ([7][0][0][0] / 0x0007), yuv420p(progressive, left), 1920x1080 (0x0), q=2-31, 8000 kb/s, 30 fps, 30.30 tbr, 1k tbn, 1k tbc
  
  Stream #0:1: Audio: aac ([10][0][0][0] / 0x000A), 44100 Hz, mono, fltp, 128 kb/s

  There are not much differences between the two streams, so i don’t really get what is going wrong and what i should change in my C++ code. One very weird issue i see is that my audio stream is 48kHz when i publish it, but here it is recognized as 44100Hz :

  Output #0, flv, to 'rtmp://127.0.0.1/live/beam_0':
  
  Stream #0:0, 0, 1/1000: Video: h264 (libx264), 1 reference frame, yuv420p, 1920x1080, 0/1, q=-1--1, 8000 kb/s, 30 fps, 1k tbn, 1k tbc
  
  Stream #0:1, 0, 1/1000: Audio: aac, 48000 Hz, 1 channels, fltp, 128 kb/s

  UPDATE 1 :

  The output context is created using the following code :

  pOutputFormatContext->oformat = av_guess_format("flv", url.toStdString().c_str(), nullptr);
  
  memcpy(pOutputFormatContext->filename, url.toStdString().c_str(), url.length());
  
  avio_open(&pOutputFormatContext->pb,  url.toStdString().c_str(), AVIO_FLAG_WRITE));
  
  pOutputFormatContext->oformat->video_codec = AV_CODEC_ID_H264 ;
  
  pOutputFormatContext->oformat->audio_codec = AV_CODEC_ID_AAC ;

  The audio stream is created with :

  AVDictionary *opts = nullptr;
  
  //pAudioCodec = avcodec_find_encoder(AV_CODEC_ID_VORBIS);
  
  pAudioCodec = avcodec_find_encoder(AV_CODEC_ID_AAC);
  
  
  
  pAudioCodecContext = avcodec_alloc_context3(pAudioCodec);
  
  
  
  pAudioCodecContext->thread_count = 1;
  
  pAudioFrame = av_frame_alloc();
  
  
  
  av_dict_set(&opts, "strict", "experimental", 0);
  
  pAudioCodecContext->bit_rate = 128000;
  
  pAudioCodecContext->sample_fmt = AV_SAMPLE_FMT_FLTP;
  
  pAudioCodecContext->sample_rate = static_cast<int>(sample_rate) ;
  
  pAudioCodecContext->channels = nb_channels ;
  
  pAudioCodecContext->time_base.num = 1;
  
  pAudioCodecContext->time_base.den = 1000 ;
  
  
  
  //pAudioCodecContext->time_base.den = static_cast<int>(sample_rate) ;
  
  
  
  pAudioCodecContext->codec_type = AVMEDIA_TYPE_AUDIO;
  
  avcodec_open2(pAudioCodecContext, pAudioCodec, &amp;opts);
  
  
  
  
  
  pAudioFrame->nb_samples     = pAudioCodecContext->frame_size;
  
  pAudioFrame->format         = pAudioCodecContext->sample_fmt;
  
  pAudioFrame->channel_layout = pAudioCodecContext->channel_layout;
  
  mAudioSamplesBufferSize = av_samples_get_buffer_size(nullptr, pAudioCodecContext->channels, pAudioCodecContext->frame_size, pAudioCodecContext->sample_fmt, 0);
  
  
  
  avcodec_fill_audio_frame(pAudioFrame, pAudioCodecContext->channels, pAudioCodecContext->sample_fmt, (const uint8_t*) pAudioSamples, mAudioSamplesBufferSize, 0);
  
  
  
  if( pOutputFormatContext->oformat->flags &amp; AVFMT_GLOBALHEADER )
  
      pAudioCodecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
  
  
  
  pAudioStream = avformat_new_stream(pOutputFormatContext, 0);
  
  
  
  pAudioStream->codec = pAudioCodecContext ;
  
  pAudioStream->id =  pOutputFormatContext->nb_streams-1;;
  
  pAudioStream->time_base.den = pAudioStream->pts.den =  pAudioCodecContext->time_base.den;
  
  pAudioStream->time_base.num = pAudioStream->pts.num =  pAudioCodecContext->time_base.num;
  
  
  
  mAudioPacketTs = 0 ;
  
  </int></int>

  The video stream is created with :

  pVideoCodec = avcodec_find_encoder(AV_CODEC_ID_H264);
  
  
  
  pVideoCodecContext = avcodec_alloc_context3(pVideoCodec);
  
  
  
  pVideoCodecContext->codec_type = AVMEDIA_TYPE_VIDEO ;
  
  pVideoCodecContext->thread_count = 1 ;
  
  pVideoCodecContext->width = width;
  
  pVideoCodecContext->height = height;
  
  pVideoCodecContext->bit_rate = 8000000 ;
  
  pVideoCodecContext->time_base.den = 1000 ;
  
  pVideoCodecContext->time_base.num = 1 ;
  
  pVideoCodecContext->gop_size = 10;
  
  pVideoCodecContext->pix_fmt = AV_PIX_FMT_YUV420P;
  
  pVideoCodecContext->flags = 0x0007 ;
  
  
  
  pVideoCodecContext->extradata_size = sizeof(extra_data_buffer);
  
  pVideoCodecContext->extradata = (uint8_t *) av_malloc ( sizeof(extra_data_buffer) );
  
  memcpy ( pVideoCodecContext->extradata, extra_data_buffer, sizeof(extra_data_buffer));
  
  
  
  avcodec_open2(pVideoCodecContext,pVideoCodec,0);
  
  
  
  pVideoFrame = av_frame_alloc();
  
  
  
  AVDictionary *opts = nullptr;
  
  av_dict_set(&opts, "strict", "experimental", 0);
  
  memcpy(pOutputFormatContext->filename, this->mStreamUrl.toStdString().c_str(), this->mStreamUrl.length());
  
  pOutputFormatContext->oformat->video_codec = AV_CODEC_ID_H264 ;
  
  
  
  if( pOutputFormatContext->oformat->flags & AVFMT_GLOBALHEADER )
  
      pVideoCodecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
  
  
  
  pVideoStream = avformat_new_stream(pOutputFormatContext, pVideoCodec);
  
  
  
  
  
  //This following section is because AVFormat complains about parameters being passed throught the context and not CodecPar
  
  pVideoStream->codec = pVideoCodecContext ;
  
  pVideoStream->id = pOutputFormatContext->nb_streams-1;
  
  pVideoStream->time_base.den = pVideoStream->pts.den =  pVideoCodecContext->time_base.den;
  
  pVideoStream->time_base.num = pVideoStream->pts.num =  pVideoCodecContext->time_base.num;
  
  pVideoStream->avg_frame_rate.num = fps ;
  
  pVideoStream->avg_frame_rate.den = 1 ;
  
  pVideoStream->codec->gop_size = 10 ;
  
  
  
  mVideoPacketTs = 0 ;

  Then each video packet and audio packet is pushed with correct scaled pts/dts. I have corrected the 48kHz issue. It was because i was configuring the stream through the codec context and the through the codec parameters (because of waarning at runtime).

  This RTMP stream still does not work for HLS conversion by NGINX, but if i just use FFMPEG to take the RTMP stream from NGINX and re-publish it with copy codec then it works.