Recherche avancée

Sur d’autres sites (8658)

• avutil : Add NV24 and NV42 pixel formats

  7 mai 2019, par Philip Langdale

  avutil : Add NV24 and NV42 pixel formats
  These are the 4:4:4 variants of the semi-planar NV12/NV21 formats.
  These formats are not used much, so we've never had a reason to add
  
  them until now. VDPAU recently added support HEVC 4:4:4 content
  
  and when you use the OpenGL interop, the returned surfaces are in
  
  NV24 format, so we need the pixel format for media players, even
  
  if there's no direct use within ffmpeg.
  Separately, there are apparently webcams that use NV24, but I've
  
  never seen one.
  

  • [DH] libavutil/pixdesc.c
  • [DH] libavutil/pixfmt.h
  • [DH] libavutil/tests/pixfmt_best.c
  • [DH] libavutil/version.h
  • [DH] tests/ref/fate/pixfmt_best

• Incorrect duration and bitrate in ffmpeg-encoded audio

  30 mai 2019, par Timmy K

  I am encoding raw data on Android using ffmpeg libraries. The native code reads the audio data from an external device and encodes it into AAC format in an mp4 container. I am finding that the audio data is successfully encoded (I can play it with Groove Music, my default Windows audio player). But the metadata, as reported by ffprobe, has an incorrect duration of 0.05 secs - it’s actually several seconds long. Also the bitrate is reported wrongly as around 65kbps even though I specified 192kbps.

  I’ve tried recordings of various durations but the result is always similar - the (very small) duration and bitrate. I’ve tried various other audio players such as Quicktime but they play only the first 0.05 secs or so of the audio.

  I’ve removed error-checking from the following. The actual code checks every call and no problems are reported.

  Initialisation :

  void AudioWriter::initialise( const char *filePath )
  
  {
  
      AVCodecID avCodecID = AVCodecID::AV_CODEC_ID_AAC;
  
      int bitRate = 192000;
  
      char *containerFormat = "mp4";
  
      int sampleRate = 48000;
  
      int nChannels = 2;
  
  
  
      mAvCodec = avcodec_find_encoder(avCodecID);
  
      mAvCodecContext = avcodec_alloc_context3(mAvCodec);
  
      mAvCodecContext->codec_id = avCodecID;
  
      mAvCodecContext->codec_type = AVMEDIA_TYPE_AUDIO;
  
      mAvCodecContext->sample_fmt = AV_SAMPLE_FMT_FLTP;
  
      mAvCodecContext->bit_rate = bitRate;
  
      mAvCodecContext->sample_rate = sampleRate;
  
      mAvCodecContext->channels = nChannels; 
  
      mAvCodecContext->channel_layout = AV_CH_LAYOUT_STEREO;
  
  
  
      avcodec_open2( mAvCodecContext, mAvCodec, nullptr );
  
  
  
      mAvFormatContext = avformat_alloc_context();
  
  
  
      avformat_alloc_output_context2(&mAvFormatContext, nullptr, containerFormat, nullptr);
  
      mAvFormatContext->audio_codec = mAvCodec;
  
      mAvFormatContext->audio_codec_id = avCodecID;
  
      mAvOutputStream = avformat_new_stream(mAvFormatContext, mAvCodec);
  
      avcodec_parameters_from_context(mAvOutputStream->codecpar, mAvCodecContext);
  
      if (!(mAvFormatContext->oformat->flags & AVFMT_NOFILE))
  
      {
  
          avio_open(&mAvFormatContext->pb, filePath, AVIO_FLAG_WRITE);
  
      }
  
  
  
      if ( mAvFormatContext->oformat->flags & AVFMT_GLOBALHEADER )
  
      {
  
          mAvCodecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
  
      }
  
  
  
      avformat_write_header(mAvFormatContext, NULL);
  
  
  
      mAvAudioFrame = av_frame_alloc();
  
      mAvAudioFrame->nb_samples = mAvCodecContext->frame_size;
  
      mAvAudioFrame->format = mAvCodecContext->sample_fmt;
  
      mAvAudioFrame->channel_layout = mAvCodecContext->channel_layout;
  
  
  
      av_samples_get_buffer_size(NULL, mAvCodecContext->channels, mAvCodecContext->frame_size,
  
                                                   mAvCodecContext->sample_fmt, 0);
  
      av_frame_get_buffer(mAvAudioFrame, 0);
  
      av_frame_make_writable(mAvAudioFrame);
  
      mAvPacket = av_packet_alloc();
  
    }

  Encoding :

  // SoundRecording is a custom class with the raw samples to be encoded
  
  bool AudioWriter::encodeToContainer( SoundRecording *soundRecording )
  
  {
  
      int ret;
  
      int frameCount = mAvCodecContext->frame_size;
  
      int nChannels = mAvCodecContext->channels;
  
      float *buf = new float[frameCount*nChannels];
  
  
  
      while ( soundRecording->hasReadableData() )
  
      {
  
          //Populate the frame
  
          int samplesRead = soundRecording->read( buf, frameCount*nChannels );
  
          // Planar data
  
          int nFrames = samplesRead/nChannels;
  
          for ( int i = 0; i < nFrames; ++i )
  
          {
  
              for (int c = 0; c < nChannels; ++c )
  
              {
  
                  samples[c][i] = buf[nChannels*i +c];
  
              }
  
          }
  
          // Fill a gap at the end with silence
  
          if ( samplesRead < frameCount*nChannels )
  
          {
  
              for ( int i = samplesRead; i < frameCount*nChannels; ++i )
  
              {
  
                  for (int c = 0; c < nChannels; ++c )
  
                  {
  
                      samples[c][i] = 0.0;
  
                  }
  
              }
  
          }
  
  
  
      encodeFrame( mAvAudioFrame ) )
  
      }
  
  
  
      finish();
  
   }
  
  
  
  bool AudioWriter::encodeFrame( AVFrame *frame )
  
  {
  
      //send the frame for encoding
  
      int ret;
  
  
  
      if ( frame != nullptr )
  
      {
  
          frame->pts = mAudFrameCounter++;
  
      }
  
      avcodec_send_frame(mAvCodecContext, frame );
  
  
  
      while (ret >= 0)
  
      {
  
          ret = avcodec_receive_packet(mAvCodecContext, mAvPacket);
  
          if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF )
  
          {
  
              break;
  
          }
  
          else
  
              if (ret < 0) {
  
               return false;
  
          }
  
          av_packet_rescale_ts(mAvPacket, mAvCodecContext->time_base, mAvOutputStream->time_base);
  
          mAvPacket->stream_index = mAvOutputStream->index;
  
  
  
          av_interleaved_write_frame(mAvFormatContext, mAvPacket);
  
           av_packet_unref(mAvPacket);
  
      }
  
  
  
      return true;
  
  }
  
  
  
  void AudioWriter::finish()
  
  {
  
      // Flush by sending a null frame
  
      encodeFrame( nullptr );
  
  
  
      av_write_trailer(mAvFormatContext);
  
  }

  Since the resultant file contains the recorded music, the code to manipulate the audio data seems to be correct (unless I am overwriting other memory somehow).

  The inaccurate duration and bitrate suggest that information concerning time is not being properly managed. I set the pts of the frames using a simple increasing integer. I’m unclear what the code that sets the timestamp and stream index achieves - and whether it’s even necessary : I copied it from supposedly working code but I’ve seen other code without it.

  Can anyone see what I’m doing wrong ?

• Problem using ffmpeg in python to decode video stream to yuv stream and send to a pipe

  30 août 2019, par 瓦达所多阿萨德阿萨德

  This command works nice and fast in shell :

  ffmpeg -c:v h264_cuvid -i ./myvideo.mp4 -f null -pix-fmt yuv420p -

  It was about 13x speed or 300 frames/sec.
  Then I tried to send the yuv stream to pipe and catch it the main process using the following code in python :

  cmd = ['ffmpeg', '-c:v', 'h264_cuvid', '-i', './myvideo.mp4', '-f', 'image2pipe', '-pix_fmt', 'yuv420p', '-']
  
  p = subprocess.Popen(cmd, stdout = subprocess.PIPE, stderr=subprocess.PIPE)
  
  size_Y = int(height * width)
  
  size_UV = int(size_Y / 4)
  
  s = time.time()
  
  Y = p.stdout.read(size_Y)
  
  U = p.stdout.read(size_UV)
  
  V = p.stdout.read(size_UV)
  
  print('read time: ', time.time() - s)

  However, this took seconds to read just one yuv frame. What wronged here ? Im not sure what ffmpeg was sending into the pipe, the yuv planar frames or just the pointers to data planes ?

  the console output :

  [('Number of Frames', 61137), ('FPS', 25.0), ('Frame Shape', (1920, 1080))]
  
  --Number of Frames: 61137
  
  --FPS: 25.0
  
  --Frame Shape: (1920, 1080)
  
  cmd:  ['ffmpeg', '-c:v', 'h264_cuvid', '-i', './myvideo.mp4', '-f', 'image2pipe', '-pix_fmt', 'yuv420p', '-']
  
  read time:  5.251002073287964
  
  1/61137 (0.00%)read time:  2.290238618850708
  
  2/61137 (0.00%)read time:  1.2984871864318848
  
  3/61137 (0.00%)read time:  2.2100613117218018
  
  4/61137 (0.01%)read time:  2.3444178104400635