Recherche avancée

Sur d’autres sites (10132)

• How to collect specific Youtube channel uploaded videos and use FFMPEG to convert to MP3 [on hold]

  6 novembre 2014, par Daniel Kirkby

  I am currently attempting to create a php script that can crawl a Youtube channel’s uploaded videos and parse them through FFMPEG to a mp3.

  .eg (https://www.youtube.com/user/PandoraMuslc/videos) download each .flv then convert to mp3 using a script that can do the whole channel instead of one at a time as there are a few hundred uploads. while I have found scripts that can make FFMPEG convert to mp3 and scripts to show the uploaded videos in XML I kinda just want to figure out how to get each video automaticly, Maybe a script that can be cron’d ?

• ffmpeg save difference between 2 videos to file

  10 août 2020, par 0x-1

  I'm currently trying to learn everything related to videos and encountered a problem that I need help with.

  


  The Question is : How can I save the difference between 2 videos to a seperate file with ffmpeg ?
  
For example here is the ffplay command I'm trying with :
(Source : https://superuser.com/questions/854543/how-to-compare-the-difference-between-2-videos-color-in-ffmpeg)

  


  ffplay -f lavfi "movie=left.mp4,setpts=PTS-STARTPTS,split=3[a0][a1][a2];
            movie=right.mp4,setpts=PTS-STARTPTS,split[b0][b1];
            [a0][b0]blend=c0_mode=difference[y];
            [a1]lutyuv=y=val:u=128:v=128[uv];
            [y][uv]mergeplanes=0x001112:yuv420p,pad=2*iw:ih:0:0[down];
            [a2][b1]hstack[up];[up][down]vstack"


  


  In this case I would want to have the bottom left video saved to a new file.
  
Can someone help me get together the right ffmpeg filter and explain the proccessing of ffmpeg ?

  


• Why do I get a crash only sometimes when closing input file with ffmpeg

  1er mai 2013, par Bradley

  I have a problem where only sometimes when I call avformat_close_input(&pFormatCtx) and it results in malloc check failed and my application crashes.

  I really need to use ffmpeg because I need to grab a thumbnail of a video to show in a list and I cannot find an alternative library.

  Can anybody see something in my code where I am doing something wrong when using this library which may cause this malloc check failed problem ?

  bool MuteCamera::PullFrame(  )
  
  {
  
  
  
  
  
  
  
  pMJPEGCodec  = avcodec_find_encoder(CODEC_ID_MJPEG );
  
  
  
  
  
  bool bRet = false;
  
  int videoStream   = -1;
  
  AVFrame *pFrame=NULL;
  
  AVFrame *pFrameRGB=NULL;
  
  AVPacket packet;
  
  int frameFinished=0;
  
  
  
  //AVDictionary *optionsDict = NULL;
  
  AVInputFormat   *pFormat = NULL;
  
  const char      formatName[] = "mp4";
  
  
  
  if (!(pFormat = av_find_input_format(formatName))) {
  
      printf("can't find input format %s\n", formatName);
  
      return -1;
  
  }
  
  
  
  AVFormatContext *pFormatCtx = NULL;
  
  pFormatCtx=avformat_alloc_context();
  
  
  
  if(pFormatCtx == NULL)
  
  {
  
      printf("\n NULL CONTEXT \n ");
  
      return -1;
  
  }
  
  if(avformat_open_input (&pFormatCtx, capturedUrl.data(), pFormat, NULL) == 0 )
  
  {
  
      for(int i=0; i<(int)pFormatCtx->nb_streams; i++)
  
      {
  
          if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO)
  
          {
  
              videoStream=i;
  
              break;
  
          }
  
      }
  
      if(videoStream >= 0 )
  
      {
  
          AVCodecContext *pCodecCtx = pFormatCtx->streams[videoStream]->codec;
  
          AVCodec *pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
  
          if(pCodec != NULL)
  
          {
  
              if( avcodec_open2(pCodecCtx, pCodec, NULL) >= 0 )
  
              {
  
  
  
                  pFrame=avcodec_alloc_frame();
  
  
  
                  if(pFrame != NULL)
  
                  {
  
  
  
  
  
                      frameFinished = 0;
  
  
  
                      while(av_read_frame(pFormatCtx, &packet)>=0)
  
                      {
  
  
  
  
  
                          if(packet.stream_index==videoStream)
  
                          {
  
  
  
                              avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
  
  
  
                              if(frameFinished)
  
                              {
  
  
  
                                  printf("\n FRAMEFINISHED \n ");
  
                                  QString *uu = new QString(capturedUrl.data());//
  
                                  uu->replace(".mp4", "thumbnail.jpg");
  
                                  WriteJPEG(pCodecCtx, pFrame, uu->toLatin1().data(), PIX_FMT_YUVJ420P);
  
  
  
                                  if(viewingVideos && viewingFromDifferent)
  
                                  {
  
                                      QVariantMap map = QVariantMap();
  
                                      map["title"] = actualFilename;
  
  
  
                                      map["path"] =  actualFilename.replace(".mp4", "thumbnail.jpg");// QString("asset:///white_photo.png");
  
                                      m_listDataModel << map;
  
  
  
                                  }
  
                                  delete uu;
  
                                  av_free_packet(&packet);
  
                                  break;
  
  
  
  
  
  
  
                              }
  
                              else
  
                              {
  
                                  printf("\n FRAMENOTFINISHED \n ");
  
                              }
  
                          }
  
                          av_free_packet(&packet);
  
  
  
                      }
  
  
  
  
  
  
  
  
  
                      av_free(pFrameRGB);
  
  
  
                      av_free(pFrame);
  
  
  
                      avcodec_close(pCodecCtx);
  
                      //av_free(pCodecCtx);
  
                      cout << "\n before free formatctx \n";
  
                      cout.flush();
  
                      if(pFormatCtx)
  
                          avformat_close_input(&pFormatCtx);
  
                      cout << "\n after free formatctx \n";
  
                      cout.flush();
  
  
  
                  }
  
                  else
  
                      bRet = false;
  
  
  
  
  
  
  
  
  
  
  
              }
  
              else
  
                  bRet = false;
  
          }
  
          else
  
              bRet = false;
  
      }
  
      else
  
          bRet = false;
  
  
  
  
  
  
  
  
  
  
  
  }
  
  
  
  
  
  return bRet;
  
  }
  
  
  
  
  
  bool WriteJPEG (AVCodecContext *pCodecCtx, AVFrame *pFrame, char cFileName[], PixelFormat pix)
  
      {
  
  int complete = 0;
  
  bool bRet = false;
  
  int out_buf_size;
  
  uint8_t *out_buf;
  
  
  
  AVCodecContext *pMJPEGCtx = avcodec_alloc_context3(pMJPEGCodec);
  
  if( pMJPEGCtx )
  
  {
  
      pMJPEGCtx->bit_rate = pCodecCtx->bit_rate;
  
      pMJPEGCtx->width = pCodecCtx->width;
  
      pMJPEGCtx->height = pCodecCtx->height;
  
      pMJPEGCtx->pix_fmt = pix;
  
      pMJPEGCtx->codec_id = CODEC_ID_MJPEG;
  
      pMJPEGCtx->codec_type = AVMEDIA_TYPE_VIDEO;
  
      pMJPEGCtx->time_base.num = pCodecCtx->time_base.num;
  
      pMJPEGCtx->time_base.den = pCodecCtx->time_base.den;
  
      pMJPEGCtx->time_base= (AVRational){1,29.7};
  
  
  
  
  
  
  
  
  
      if( pMJPEGCodec && (avcodec_open2( pMJPEGCtx, pMJPEGCodec, NULL) >= 0) )
  
      {
  
  
  
           AVFrame *oframe;
  
          oframe = avcodec_alloc_frame();
  
  
  
          if(oframe == NULL)
  
          {
  
              printf("\n (oframe == NULL");
  
              fflush(stdout);
  
          }
  
  
  
  
  
          /* calculate the bytes needed for the output image and create buffer for the output image */
  
          out_buf_size = avpicture_get_size(pMJPEGCtx->pix_fmt,
  
                  pMJPEGCtx->width,
  
                  pMJPEGCtx->height);
  
          out_buf = (uint8_t *)av_malloc(out_buf_size * sizeof(uint8_t));
  
          if (out_buf == NULL) {
  
              fprintf(stderr, "cannot allocate output data buffer!\n");
  
              //ret = -ENOMEM;
  
  
  
          }
  
  
  
          avpicture_alloc((AVPicture *)oframe, pMJPEGCtx->pix_fmt, pMJPEGCtx->width, pMJPEGCtx->height);
  
  
  
          struct SwsContext *sws;
  
          sws = sws_getContext(pMJPEGCtx->width, pMJPEGCtx->height, pCodecCtx->pix_fmt,
  
                  pMJPEGCtx->width, pMJPEGCtx->height, pMJPEGCtx->pix_fmt, SWS_BILINEAR,
  
                  NULL, NULL, NULL);
  
  
  
          sws_scale(sws, (const uint8_t **)pFrame->data, pFrame->linesize,
  
                  0, pMJPEGCtx->height, &oframe->data[0], &oframe->linesize[0]);
  
          sws_freeContext(sws);
  
  
  
  
  
  
  
  
  
  
  
          AVPacket pp2;
  
          av_init_packet(&pp2);
  
          pp2.data = NULL;
  
          pp2.size = 0;
  
          avcodec_encode_video2(pMJPEGCtx, &pp2,  oframe, &complete);
  
          if(complete)
  
          {
  
              printf("\n packet recieved");
  
              fflush(stdout);
  
          }
  
          else
  
          {
  
              printf("\n packet NOT recieved");
  
              fflush(stdout);
  
          }
  
  
  
          if( SaveFrameJpeg(pp2.size, pp2.data, cFileName ) )
  
              bRet = true;
  
  
  
              av_free(oframe);
  
  
  
  
  
  
  
              avcodec_close(pMJPEGCtx);
  
  
  
          av_free_packet(&pp2);
  
          av_free(out_buf);
  
  
  
              av_free(pMJPEGCtx);
  
  
  
  
  
      }
  
      else
  
      {
  
          printf("\n problem!!");
  
          fflush(stdout);
  
      }
  
  
  
      return bRet;
  
  }
  
  }
  
  
  
  bool SaveFrameJpeg(int nszBuffer, uint8_t *buffer, char cOutFileName[])
  
  {
  
  bool bRet = false;
  
  FILE *pFile;
  
  if( nszBuffer > 0 )
  
  {
  
  
  
      if(0 == 0 )
  
      {
  
          printf("\n start SaveFrameJpeg=%d",nszBuffer );
  
          fflush(stdout);
  
          pFile= fopen(cOutFileName, "wb");
  
          fwrite(buffer, sizeof(uint8_t), nszBuffer, pFile);
  
          bRet = true;
  
          fclose(pFile);
  
          printf("\n end SaveFrameJpeg=%d",nszBuffer );
  
          fflush(stdout);
  
      }
  
  }
  
  return bRet;
  
  }
  
  
  
  
  
  bool newPullFrame(const std::string& capturedUrl)
  
  {
  
  
  
  AVCodec* pMJPEGCodec  = avcodec_find_encoder(CODEC_ID_MJPEG );
  
  
  
  int videoStream   = -1;
  
  
  
  AVDictionary *optionsDict = NULL;
  
  AVInputFormat   *pFormat = NULL;
  
  const char      formatName[] = "mp4";
  
  
  
  if (!(pFormat = av_find_input_format(formatName)))
  
  {
  
      std::cout << "can't find input format " << formatName << "\n";
  
      return false;
  
  }
  
  
  
  AVFormatContextHandle FormatCtx(avformat_alloc_context());
  
  
  
  if(!FormatCtx.is_valid())
  
  {
  
      std::cout << "\n NULL CONTEXT \n ";
  
      return false;
  
  }
  
  
  
  if(avformat_open_input (&FormatCtx, capturedUrl.c_str(), pFormat, NULL))
  
      return false;
  
  
  
  for(int i=0; i<(int)FormatCtx->nb_streams; i++)
  
  {
  
      if(FormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO)
  
      {
  
          videoStream=i;
  
          break;
  
      }
  
  }
  
  if(videoStream < 0 )
  
      return false;
  
  
  
  CodecContextHandle CodecCtx(FormatCtx->streams[videoStream]->codec, avcodec_close);
  
  AVCodec *pCodec = avcodec_find_decoder(CodecCtx->codec_id);
  
  
  
  if(pCodec == NULL)
  
      return false;
  
  
  
  if( avcodec_open2(CodecCtx, pCodec, &optionsDict) < 0 )
  
      return false;
  
  
  
  FrameHandle Frame(avcodec_alloc_frame(), av_free);
  
  
  
  if(!Frame.is_valid())
  
      return false;
  
  
  
  int frameFinished=0;
  
  AVPacket packet;
  
  
  
  while(av_read_frame(FormatCtx, &packet)>=0)
  
  {
  
  
  
      if(packet.stream_index==videoStream)
  
      {
  
          avcodec_decode_video2(CodecCtx, Frame, &frameFinished, &packet);
  
  
  
          if(frameFinished)
  
          {
  
  
  
              std::string uu (capturedUrl);
  
              size_t pos = capturedUrl.rfind(".mp4");
  
              uu.replace(pos, 4, "thumbnail.jpg");
  
              // save the frame to file
  
              int Bytes = avpicture_get_size(PIX_FMT_YUVJ420P, CodecCtx->width, CodecCtx->height);
  
              BufferHandle buffer((uint8_t*)av_malloc(Bytes*sizeof(uint8_t)), av_free);
  
              CodecContextHandle OutContext(avcodec_alloc_context3(NULL), free_context);
  
  
  
              OutContext->bit_rate = CodecCtx->bit_rate;
  
  
  
              OutContext->width = CodecCtx->width;
  
              OutContext->height = CodecCtx->height;
  
              OutContext->pix_fmt = PIX_FMT_YUVJ420P;
  
              OutContext->codec_id = CODEC_ID_MJPEG;
  
              OutContext->codec_type = AVMEDIA_TYPE_VIDEO;
  
              OutContext->time_base.num = CodecCtx->time_base.num;
  
              OutContext->time_base.den = CodecCtx->time_base.den;
  
              OutContext->time_base= (AVRational){1,29.7};
  
              AVCodec *OutCodec = avcodec_find_encoder(OutContext->codec_id);
  
              avcodec_open2(OutContext, OutCodec, NULL);
  
              OutContext->mb_lmin = OutContext->lmin = OutContext->qmin * 118;
  
              OutContext->mb_lmax = OutContext->lmax = OutContext->qmax * 118;
  
              OutContext->flags = 2;
  
              OutContext->global_quality = OutContext->qmin * 118;
  
              Frame->pts = 1;
  
  
  
              Frame->quality = OutContext->global_quality;
  
  
  
              int ActualSize = avcodec_encode_video(OutContext, buffer, Bytes, Frame);
  
  
  
              std::ofstream file(uu.data(), std::ios_base::binary | std::ios_base::out);
  
              file.write((const char*)(uint8_t*)buffer, ActualSize);
  
              file.close();
  
              av_free_packet(&packet);
  
              av_free(Frame);
  
              break;
  
          }
  
          else
  
          {
  
              std::cout << " new pullframe frameNOTfinished\n";
  
                              cout.flush();
  
          }
  
          //if(CodecCtx->refcounted_frames == 1)
  
  
  
              av_free(Frame);
  
  
  
      }
  
      av_free_packet(&packet);
  
  }
  
  
  
  return true;
  
  }