Recherche avancée

Sur d’autres sites (10049)

• "moov atom not found" when using av_interleaved_write_frame but not avio_write

  9 octobre 2017, par icStatic

  I am attempting to put together a class that can take arbitrary frames and construct a video from it using the ffmpeg 3.3.3 API. I’ve been struggling to find a good example for this as the examples still seem to be using deprecated functions, so I’ve attempted to patch this using the documentation in the headers and by referring to a few github repos that seem to be using the new version.

  If I use av_interleaved_write_frame to write the encoded packets to the output then ffprobe outputs the following :

  [mov,mp4,m4a,3gp,3g2,mj2 @ 0000000002760120] moov atom not found0
  
  X:\Diagnostics.mp4: Invalid data found when processing input

  ffplay is unable to play the file generated using this method.

  If I instead swap it out for a call to avio_write, ffprobe instead outputs :

  Input #0, h264, from 'X:\Diagnostics.mp4':
  
    Duration: N/A, bitrate: N/A
  
      Stream #0:0: Video: h264 (Main), yuv420p(progressive), 672x380 [SAR 1:1 DAR 168:95], 25 fps, 25 tbr, 1200k tbn, 50 tbc

  ffplay can mostly play this file until it gets towards the end, when it outputs :

  Input #0, h264, from 'X:\Diagnostics.mp4':    0KB sq=    0B f=0/0
  
    Duration: N/A, bitrate: N/A
  
      Stream #0:0: Video: h264 (Main), yuv420p(progressive), 672x380 [SAR 1:1 DAR 168:95], 25 fps, 25 tbr, 1200k tbn, 50 tbc
  
  [h264 @ 000000000254ef80] error while decoding MB 31 22, bytestream -65
  
  [h264 @ 000000000254ef80] concealing 102 DC, 102 AC, 102 MV errors in I frame
  
      nan M-V:    nan fd=   1 aq=    0KB vq=    0KB sq=    0B f=0/0

  VLC cannot play files from either method. The second method’s file displays a single black frame then hides the video output. The first does not display anything. Neither of them give a video duration.

  Does anyone have any ideas what’s happening here ? I assume my solution is close to working as I’m getting a good chunk of valid frames coming through.

  Code :

  void main()
  
  {
  
      OutputStream Stream( "Output.mp4", 672, 380, 25, true );
  
      Stream.Initialize();
  
  
  
      int i = 100;
  
      while( i-- )
  
      {
  
          //... Generate a frame
  
  
  
          Stream.WriteFrame( Frame );
  
      }
  
      Stream.CloseFile();
  
  }
  
  
  
  OutputStream::OutputStream( const std::string& Path, unsigned int Width, unsigned int Height, int Framerate, bool IsBGR )
  
  : Stream()
  
  , FrameIndex( 0 )
  
  {
  
      auto& ID = *m_InternalData;
  
  
  
      ID.Path = Path;
  
  
  
      ID.Width = Width;
  
      ID.Height= Height;
  
      ID.Framerate.num = Framerate;
  
      ID.Framerate.den = 1;
  
  
  
      ID.PixelFormat = IsBGR ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_RGB24;
  
      ID.CodecID = AV_CODEC_ID_H264;
  
      ID.CodecTag = 0;
  
  
  
      ID.AspectRatio.num = 1;
  
      ID.AspectRatio.den = 1;
  
  }
  
  
  
  CameraStreamError OutputStream::Initialize()
  
  {
  
      av_log_set_callback( &InputStream::LogCallback );
  
      av_register_all();
  
      avformat_network_init();
  
  
  
      auto& ID = *m_InternalData;
  
  
  
      av_init_packet( &ID.Packet );
  
  
  
      int Result = avformat_alloc_output_context2( &ID.FormatContext, nullptr, nullptr, ID.Path.c_str() );
  
      if( Result < 0 || !ID.FormatContext )
  
      {
  
          STREAM_ERROR( UnknownError );
  
      }
  
  
  
      AVCodec* Encoder = avcodec_find_encoder( ID.CodecID );
  
  
  
      if( !Encoder )
  
      {
  
          STREAM_ERROR( NoH264Support );
  
      }
  
  
  
      AVStream* OutStream = avformat_new_stream( ID.FormatContext, Encoder );
  
      if( !OutStream )
  
      {
  
          STREAM_ERROR( UnknownError );
  
      }
  
  
  
      ID.CodecContext = avcodec_alloc_context3( Encoder );
  
      if( !ID.CodecContext )
  
      {
  
          STREAM_ERROR( NoH264Support );
  
      }
  
  
  
      ID.CodecContext->time_base = av_inv_q(ID.Framerate);
  
  
  
      {
  
          AVCodecParameters* CodecParams = OutStream->codecpar;
  
  
  
          CodecParams->width = ID.Width;
  
          CodecParams->height = ID.Height;
  
          CodecParams->format = AV_PIX_FMT_YUV420P;
  
          CodecParams->codec_id = ID.CodecID;
  
          CodecParams->codec_type = AVMEDIA_TYPE_VIDEO;
  
          CodecParams->profile = FF_PROFILE_H264_MAIN;
  
          CodecParams->level = 40;
  
  
  
          Result = avcodec_parameters_to_context( ID.CodecContext, CodecParams );
  
          if( Result < 0 )
  
          {
  
              STREAM_ERROR( EncoderCreationError );
  
          }
  
      }
  
  
  
      if( ID.IsVideo )
  
      {
  
          ID.CodecContext->width = ID.Width;
  
          ID.CodecContext->height = ID.Height;
  
          ID.CodecContext->sample_aspect_ratio = ID.AspectRatio;
  
          ID.CodecContext->time_base = av_inv_q(ID.Framerate);
  
  
  
          if( Encoder->pix_fmts )
  
          {
  
              ID.CodecContext->pix_fmt = Encoder->pix_fmts[0];
  
          }
  
          else
  
          {
  
              ID.CodecContext->pix_fmt = ID.PixelFormat;
  
          }
  
      }
  
      //Snip
  
  
  
      Result = avcodec_open2( ID.CodecContext, Encoder, nullptr );
  
      if( Result < 0 )
  
      {
  
          STREAM_ERROR( EncoderCreationError );
  
      }
  
  
  
      Result = avcodec_parameters_from_context( OutStream->codecpar, ID.CodecContext );
  
      if( Result < 0 )
  
      {
  
          STREAM_ERROR( EncoderCreationError );
  
      }
  
  
  
      if( ID.FormatContext->oformat->flags & AVFMT_GLOBALHEADER )
  
      {
  
          ID.CodecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
  
      }
  
  
  
      OutStream->time_base = ID.CodecContext->time_base;
  
      OutStream->avg_frame_rate= av_inv_q(OutStream->time_base);
  
  
  
      if( !( ID.FormatContext->oformat->flags & AVFMT_NOFILE ) )
  
      {
  
          Result = avio_open( &ID.FormatContext->pb, ID.Path.c_str(), AVIO_FLAG_WRITE );
  
          if( Result < 0 )
  
          {
  
              STREAM_ERROR( FileNotWriteable );
  
          }
  
      }
  
  
  
      Result = avformat_write_header( ID.FormatContext, nullptr );
  
      if( Result < 0 )
  
      {
  
          STREAM_ERROR( WriteFailed );
  
      }
  
  
  
      ID.Output = std::make_unique( ID.CodecContext->width, ID.CodecContext->height, ID.CodecContext->pix_fmt );
  
  
  
      ID.ConversionContext = sws_getCachedContext(
  
          ID.ConversionContext,
  
          ID.Width,
  
          ID.Height,
  
          ID.PixelFormat,
  
          ID.CodecContext->width,
  
          ID.CodecContext->height,
  
          ID.CodecContext->pix_fmt,
  
          SWS_BICUBIC,
  
          NULL,
  
          NULL,
  
          NULL );
  
  
  
      return CameraStreamError::Success;
  
  }
  
  
  
  CameraStreamError OutputStream::WriteFrame( FFMPEG::Frame* Frame )
  
  {
  
      auto& ID = *m_InternalData;
  
  
  
      ID.Output->Prepare();
  
  
  
      int OutputSliceSize = sws_scale( m_InternalData->ConversionContext, Frame->GetFrame()->data, Frame->GetFrame()->linesize, 0, Frame->GetHeight(), ID.Output->GetFrame()->data, ID.Output->GetFrame()->linesize );
  
  
  
      ID.Output->GetFrame()->pts = ID.CodecContext->frame_number;
  
  
  
      int Result = avcodec_send_frame( GetData().CodecContext, ID.Output->GetFrame() );
  
      if( Result == AVERROR(EAGAIN) )
  
      {
  
          CameraStreamError ResultErr = SendAll();
  
          if( ResultErr != CameraStreamError::Success )
  
          {
  
              return ResultErr;
  
          }
  
          Result = avcodec_send_frame( GetData().CodecContext, ID.Output->GetFrame() );
  
      }
  
  
  
      if( Result == 0 )
  
      {
  
          CameraStreamError ResultErr = SendAll();
  
          if( ResultErr != CameraStreamError::Success )
  
          {
  
              return ResultErr;
  
          }
  
      }
  
  
  
      FrameIndex++;
  
  
  
      return CameraStreamError::Success;
  
  }
  
  
  
  CameraStreamError OutputStream::SendAll( void )
  
  {
  
      auto& ID = *m_InternalData;
  
  
  
      int Result;
  
      do 
  
      {
  
          AVPacket TempPacket = {};
  
          av_init_packet( &TempPacket );
  
  
  
          Result = avcodec_receive_packet( GetData().CodecContext, &TempPacket );
  
          if( Result == 0 )
  
          {
  
              av_packet_rescale_ts( &TempPacket, ID.CodecContext->time_base, ID.FormatContext->streams[0]->time_base );
  
  
  
              TempPacket.stream_index = ID.FormatContext->streams[0]->index;
  
  
  
              //avio_write( ID.FormatContext->pb, TempPacket.data, TempPacket.size );
  
              Result = av_interleaved_write_frame( ID.FormatContext, &TempPacket );
  
              if( Result < 0 )
  
              {
  
                  STREAM_ERROR( WriteFailed );
  
              }
  
  
  
              av_packet_unref( &TempPacket );
  
          }
  
          else if( Result != AVERROR(EAGAIN) )
  
          {
  
              continue;
  
          }
  
          else if( Result != AVERROR_EOF )
  
          {
  
              break;
  
          }
  
          else if( Result < 0 )
  
          {
  
              STREAM_ERROR( WriteFailed );
  
          }
  
      } while ( Result == 0);
  
  
  
      return CameraStreamError::Success;
  
  }
  
  
  
  CameraStreamError OutputStream::CloseFile()
  
  {
  
      auto& ID = *m_InternalData;
  
  
  
      while( true )
  
      {
  
          //Flush
  
          int Result = avcodec_send_frame( ID.CodecContext, nullptr );
  
          if( Result == 0 )
  
          {
  
              CameraStreamError StrError = SendAll();
  
              if( StrError != CameraStreamError::Success )
  
              {
  
                  return StrError;
  
              }
  
          }
  
          else if( Result == AVERROR_EOF )
  
          {
  
              break;
  
          }
  
          else
  
          {
  
              STREAM_ERROR( WriteFailed );
  
          }
  
      }
  
  
  
      int Result = av_write_trailer( ID.FormatContext );
  
      if( Result < 0 )
  
      {
  
          STREAM_ERROR( WriteFailed );
  
      }
  
  
  
      if( !(ID.FormatContext->oformat->flags& AVFMT_NOFILE) )
  
      {
  
          Result = avio_close( ID.FormatContext->pb );
  
          if( Result < 0 )
  
          {
  
              STREAM_ERROR( WriteFailed );
  
          }
  
      }
  
  
  
      return CameraStreamError::Success;
  
  }

  Note I’ve simplified a few things and inlined a few bits that were elsewhere. I’ve also removed all the shutdown code as anything that happens after the file is closed is irrelevant.

  Full repo here : https://github.com/IanNorris/Witness If you clone this the issue is with the ’Diagnostics’ output, the Output file is fine. There are two hardcoded paths to X :.

• Live555 : X264 Stream Live source based on "testOnDemandRTSPServer"

  26 octobre 2017, par user2660369

  I am trying to create a rtsp Server that streams the OpenGL output of my program. I had a look at How to write a Live555 FramedSource to allow me to stream H.264 live, but I need the stream to be unicast. So I had a look at testOnDemandRTSPServer. Using the same Code fails. To my understanding I need to provide memory in which I store my h264 frames so the OnDemandServer can read them on Demand.

  H264VideoStreamServerMediaSubsession.cpp

  H264VideoStreamServerMediaSubsession*
  
  H264VideoStreamServerMediaSubsession::createNew(UsageEnvironment& env,
  
                            Boolean reuseFirstSource) {
  
    return new H264VideoStreamServerMediaSubsession(env, reuseFirstSource);
  
  }
  
  
  
  H264VideoStreamServerMediaSubsession::H264VideoStreamServerMediaSubsession(UsageEnvironment& env, Boolean reuseFirstSource)
  
    : OnDemandServerMediaSubsession(env, reuseFirstSource), fAuxSDPLine(NULL), fDoneFlag(0), fDummyRTPSink(NULL) {
  
  }
  
  
  
  H264VideoStreamServerMediaSubsession::~H264VideoStreamServerMediaSubsession() {
  
    delete[] fAuxSDPLine;
  
  }
  
  
  
  static void afterPlayingDummy(void* clientData) {
  
    H264VideoStreamServerMediaSubsession* subsess = (H264VideoStreamServerMediaSubsession*)clientData;
  
    subsess->afterPlayingDummy1();
  
  }
  
  
  
  void H264VideoStreamServerMediaSubsession::afterPlayingDummy1() {
  
    // Unschedule any pending 'checking' task:
  
    envir().taskScheduler().unscheduleDelayedTask(nextTask());
  
    // Signal the event loop that we're done:
  
    setDoneFlag();
  
  }
  
  
  
  static void checkForAuxSDPLine(void* clientData) {
  
    H264VideoStreamServerMediaSubsession* subsess = (H264VideoStreamServerMediaSubsession*)clientData;
  
    subsess->checkForAuxSDPLine1();
  
  }
  
  
  
  void H264VideoStreamServerMediaSubsession::checkForAuxSDPLine1() {
  
    char const* dasl;
  
  
  
    if (fAuxSDPLine != NULL) {
  
      // Signal the event loop that we're done:
  
      setDoneFlag();
  
    } else if (fDummyRTPSink != NULL && (dasl = fDummyRTPSink->auxSDPLine()) != NULL) {
  
      fAuxSDPLine = strDup(dasl);
  
      fDummyRTPSink = NULL;
  
  
  
      // Signal the event loop that we're done:
  
      setDoneFlag();
  
    } else {
  
      // try again after a brief delay:
  
      int uSecsToDelay = 100000; // 100 ms
  
      nextTask() = envir().taskScheduler().scheduleDelayedTask(uSecsToDelay,
  
                    (TaskFunc*)checkForAuxSDPLine, this);
  
    }
  
  }
  
  
  
  char const* H264VideoStreamServerMediaSubsession::getAuxSDPLine(RTPSink* rtpSink, FramedSource* inputSource) {
  
    if (fAuxSDPLine != NULL) return fAuxSDPLine; // it's already been set up (for a previous client)
  
  
  
    if (fDummyRTPSink == NULL) { // we're not already setting it up for another, concurrent stream
  
      // Note: For H264 video files, the 'config' information ("profile-level-id" and "sprop-parameter-sets") isn't known
  
      // until we start reading the file.  This means that "rtpSink"s "auxSDPLine()" will be NULL initially,
  
      // and we need to start reading data from our file until this changes.
  
      fDummyRTPSink = rtpSink;
  
  
  
      // Start reading the file:
  
      fDummyRTPSink->startPlaying(*inputSource, afterPlayingDummy, this);
  
  
  
      // Check whether the sink's 'auxSDPLine()' is ready:
  
      checkForAuxSDPLine(this);
  
    }
  
  
  
    envir().taskScheduler().doEventLoop(&fDoneFlag);
  
  
  
    return fAuxSDPLine;
  
  }
  
  
  
  FramedSource* H264VideoStreamServerMediaSubsession::createNewStreamSource(unsigned /*clientSessionId*/, unsigned& estBitrate) {
  
    estBitrate = 500; // kb
  
    megamol::remotecontrol::View3D_MRC *parent = (megamol::remotecontrol::View3D_MRC*)this->parent;
  
    return H264VideoStreamFramer::createNew(envir(), parent->h264FramedSource);
  
  }
  
  
  
  RTPSink* H264VideoStreamServerMediaSubsession::createNewRTPSink(Groupsock* rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource* /*inputSource*/) {
  
    return H264VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
  
  }

  FramedSource.cpp

  H264FramedSource* H264FramedSource::createNew(UsageEnvironment& env,
  
                                            unsigned preferredFrameSize,
  
                                            unsigned playTimePerFrame)
  
  {
  
      return new H264FramedSource(env, preferredFrameSize, playTimePerFrame);
  
  }
  
  
  
  H264FramedSource::H264FramedSource(UsageEnvironment& env,
  
                                 unsigned preferredFrameSize,
  
                                 unsigned playTimePerFrame)
  
      : FramedSource(env),
  
      fPreferredFrameSize(fMaxSize),
  
      fPlayTimePerFrame(playTimePerFrame),
  
      fLastPlayTime(0),
  
      fCurIndex(0)
  
  {
  
  
  
      x264_param_default_preset(&param, "veryfast", "zerolatency");
  
      param.i_threads = 1;
  
      param.i_width = 1024;
  
      param.i_height = 768;
  
      param.i_fps_num = 30;
  
      param.i_fps_den = 1;
  
      // Intra refres:
  
      param.i_keyint_max = 60;
  
      param.b_intra_refresh = 1;
  
      //Rate control:
  
      param.rc.i_rc_method = X264_RC_CRF;
  
      param.rc.f_rf_constant = 25;
  
      param.rc.f_rf_constant_max = 35;
  
      param.i_sps_id = 7;
  
      //For streaming:
  
      param.b_repeat_headers = 1;
  
      param.b_annexb = 1;
  
      x264_param_apply_profile(&param, "baseline");
  
  
  
      param.i_log_level = X264_LOG_ERROR;
  
  
  
      encoder = x264_encoder_open(&param);
  
      pic_in.i_type            = X264_TYPE_AUTO;
  
      pic_in.i_qpplus1         = 0;
  
      pic_in.img.i_csp         = X264_CSP_I420;
  
      pic_in.img.i_plane       = 3;
  
  
  
  
  
      x264_picture_alloc(&pic_in, X264_CSP_I420, 1024, 768);
  
  
  
      convertCtx = sws_getContext(1024, 768, PIX_FMT_RGBA, 1024, 768, PIX_FMT_YUV420P, SWS_FAST_BILINEAR, NULL, NULL, NULL);
  
      eventTriggerId = envir().taskScheduler().createEventTrigger(deliverFrame0);
  
  }
  
  
  
  H264FramedSource::~H264FramedSource()
  
  {
  
      envir().taskScheduler().deleteEventTrigger(eventTriggerId);
  
      eventTriggerId = 0;
  
  }
  
  
  
  void H264FramedSource::AddToBuffer(uint8_t* buf, int surfaceSizeInBytes)
  
  {
  
      uint8_t* surfaceData = (new uint8_t[surfaceSizeInBytes]);
  
  
  
      memcpy(surfaceData, buf, surfaceSizeInBytes);
  
  
  
      int srcstride = 1024*4;
  
      sws_scale(convertCtx, &surfaceData, &srcstride,0, 768, pic_in.img.plane, pic_in.img.i_stride);
  
      x264_nal_t* nals = NULL;
  
      int i_nals = 0;
  
      int frame_size = -1;
  
  
  
  
  
      frame_size = x264_encoder_encode(encoder, &nals, &i_nals, &pic_in, &pic_out);
  
  
  
      static bool finished = false;
  
  
  
      if (frame_size >= 0)
  
      {
  
      static bool alreadydone = false;
  
      if(!alreadydone)
  
      {
  
  
  
          x264_encoder_headers(encoder, &nals, &i_nals);
  
          alreadydone = true;
  
      }
  
      for(int i = 0; i < i_nals; ++i)
  
      {
  
          m_queue.push(nals[i]);
  
      }
  
      }
  
      delete [] surfaceData;
  
      surfaceData = nullptr;
  
  
  
      envir().taskScheduler().triggerEvent(eventTriggerId, this);
  
  }
  
  
  
  void H264FramedSource::doGetNextFrame()
  
  {
  
      deliverFrame();
  
  }
  
  
  
  void H264FramedSource::deliverFrame0(void* clientData)
  
  {
  
      ((H264FramedSource*)clientData)->deliverFrame();
  
  }
  
  
  
  void H264FramedSource::deliverFrame()
  
  {
  
      x264_nal_t nalToDeliver;
  
  
  
      if (fPlayTimePerFrame > 0 && fPreferredFrameSize > 0) {
  
      if (fPresentationTime.tv_sec == 0 && fPresentationTime.tv_usec == 0) {
  
          // This is the first frame, so use the current time:
  
          gettimeofday(&fPresentationTime, NULL);
  
      } else {
  
          // Increment by the play time of the previous data:
  
          unsigned uSeconds   = fPresentationTime.tv_usec + fLastPlayTime;
  
          fPresentationTime.tv_sec += uSeconds/1000000;
  
          fPresentationTime.tv_usec = uSeconds%1000000;
  
      }
  
  
  
      // Remember the play time of this data:
  
      fLastPlayTime = (fPlayTimePerFrame*fFrameSize)/fPreferredFrameSize;
  
      fDurationInMicroseconds = fLastPlayTime;
  
      } else {
  
      // We don't know a specific play time duration for this data,
  
      // so just record the current time as being the 'presentation time':
  
      gettimeofday(&fPresentationTime, NULL);
  
      }
  
  
  
      if(!m_queue.empty())
  
      {
  
      m_queue.wait_and_pop(nalToDeliver);
  
  
  
      uint8_t* newFrameDataStart = (uint8_t*)0xD15EA5E;
  
  
  
      newFrameDataStart = (uint8_t*)(nalToDeliver.p_payload);
  
      unsigned newFrameSize = nalToDeliver.i_payload;
  
  
  
      // Deliver the data here:
  
      if (newFrameSize > fMaxSize) {
  
          fFrameSize = fMaxSize;
  
          fNumTruncatedBytes = newFrameSize - fMaxSize;
  
      }
  
      else {
  
          fFrameSize = newFrameSize;
  
      }
  
  
  
      memcpy(fTo, nalToDeliver.p_payload, nalToDeliver.i_payload);
  
  
  
      FramedSource::afterGetting(this);
  
      }
  
  }

  Relevant part of the RTSP-Server Therad

    RTSPServer* rtspServer = RTSPServer::createNew(*(parent->env), 8554, NULL);
  
    if (rtspServer == NULL) {
  
      *(parent->env) << "Failed to create RTSP server: " << (parent->env)->getResultMsg() << "\n";
  
      exit(1);
  
    }
  
    char const* streamName = "Stream";
  
    parent->h264FramedSource = H264FramedSource::createNew(*(parent->env), 0, 0);
  
    H264VideoStreamServerMediaSubsession *h264VideoStreamServerMediaSubsession = H264VideoStreamServerMediaSubsession::createNew(*(parent->env), true);
  
    h264VideoStreamServerMediaSubsession->parent = parent;
  
    sms->addSubsession(h264VideoStreamServerMediaSubsession);
  
    rtspServer->addServerMediaSession(sms);
  
  
  
    parent->env->taskScheduler().doEventLoop(); // does not return

  Once a connection exists the render loop calls

  h264FramedSource->AddToBuffer(videoData, 1024*768*4);

• ffmpeg - "Incompatible pixel format 'rgb24' for codec 'gif', auto-selecting format 'rgb8'"

  8 février 2017, par fordprefect

  I’m trying to convert a .webm to .gif at a pretty good quality, so I decided to have a go at ffmpeg (very new to this). I followed some instructions and did some research and after setting everything up figured out what I wanted in the command line :

  ffmpeg -i input.webm -pix_fmt rgb24 -vf scale=-1:720 output.gif

  Whenever I start the conversion it gives me a warning (as seen in the title), and gives me a somewhat low quality gif by using ’rgb8’. I’ve googled around but can’t seem to find an answer, not that my skill level can understand at least.

  Help would be much appreciated ! Thanks :)