Recherche avancée

Sur d’autres sites (8598)

• FFMPEG convert an mp3 into multi-part

  8 juin 2012, par HotHeadMartin

  I'm trying to find out is it possible to use ffmpeg to converter an audio file into multi-part audio file E.G i have a 3 min mp3 audio track i want to 12, 15 second MP3's

  I know i can do it though lots of different called E.G

   ffmpeg -f mp3 -i /path/to/file.mp3 -t  00:00:15[.000] -ss 00:00:00[.000] -y /path/to/save.mp3
  
   ffmpeg -f mp3 -i /path/to/file.mp3 -t  00:00:15[.000] -ss 00:00:15[.000] -y /path/to/save.mp3
  
   ...

  But im trying to find a single command line to do it if not does any one know of any Open Source application that can do it for me ?

  The other problem with the above is that i'm wanting to run this from within a c# application with different files and different sizes and i dont want my application to be doing math to calculate the different points i need to run the code from

• Converting AVI vid with ffmpeg results in readable but corrupt output

  28 janvier 2019, par sam smith

  Using the NReco.VideoConverter which uses FFMPEG, i’m trying to convert an AVI video to a WEBM video.
  The output video plays, but the image is wrong. The best way i can describe is that luminance/detail data is correct, but the colour data is vertically stretched. The result is very odd.
  I’ve tried this with and without my output settings (below), the only thing applied.

  CustomOutputArgs = "-c:v libvpx-vp9 -crf 20 -b:v 0 -b:a 128k -c:a libopus"

  The input file type is determined by the file extension of the input file. In this case, the input file type is AVI.
  This converter is tested working with mp4 format.

  illustrative crop of video

• conversion from cv::mat to avframe

  14 novembre 2014, par danics

  i create a method for converting between cv::mat to avframe with PIX_FMT_YUV420P format (oframe format) but _convCtx always return null, whats wrong ? thanks in advance !

  void processToFrame(cv::Mat* _mat, AVFrame* oframe)
  
    {
  
        // Create and allocate the conversion frame.
  
        if (_oframe == nullptr) {
  
            _oframe = avcodec_alloc_frame();  
  
            if (_oframe == nullptr)
  
                throw std::runtime_error("Matrix Converter: Could not allocate the output frame.");
  
  
  
            avpicture_alloc(reinterpret_cast(_oframe), 
  
                PIX_FMT_BGR24, _mat->cols, _mat->rows);             
  
        }
  
  
  
        avpicture_fill(reinterpret_cast(_oframe),
  
            (uint8_t *)_mat->data,
  
            AV_PIX_FMT_BGR24,
  
            _mat->cols,
  
            _mat->rows);
  
  
  
        // Convert the image from its native format to BGR.
  
        if (_convCtx == nullptr) {
  
            _convCtx = sws_getContext(
  
                oframe->width, oframe->height, (enum AVPixelFormat) oframe->format, 
  
                _oframe->width, _oframe->height, PIX_FMT_BGR24, 
  
                SWS_BICUBIC, nullptr, nullptr, nullptr);
  
        }
  
        if (_convCtx == nullptr)
  
            throw std::runtime_error("Matrix Converter: Unable to initialize the conversion context.");   
  
  
  
        // Scales the source data according to our SwsContext settings.
  
        if (sws_scale(_convCtx,
  
            _oframe->data, _oframe->linesize, 0, _oframe->height,
  
            oframe->data, oframe->linesize) < 0)
  
            throw std::runtime_error("Matrix Converter: Pixel format conversion not supported.");
  
    }

  edit : create oframe

  void createVideoFile(const char* filename, int w, int h, int codec_id, int fps)
  
    {
  
        /* find the mpeg1 video encoder */
  
        if(codec == nullptr) 
  
        {
  
            /* find the mpeg1 video encoder */
  
            codec = avcodec_find_encoder((AVCodecID)codec_id);
  
            if (!codec) {
  
                throw std::runtime_error("codec not found\n");
  
            }
  
        }
  
  
  
        if(c == nullptr)
  
        {
  
            c = avcodec_alloc_context3(codec);
  
            if(!c)
  
            {
  
                throw std::runtime_error("Could not allocate video codec context\n");
  
            }
  
            /* put sample parameters */
  
            c->bit_rate = 400000;
  
            /* resolution must be a multiple of two */
  
            c->width = 2 * (w / 2);
  
            c->height = 2 * (h / 2);
  
            /* frames per second */
  
            AVRational ar;
  
            ar.den = 1;
  
            ar.num = fps;
  
  
  
            c->time_base= ar; //(AVRational){1,25};
  
            c->gop_size = 10; /* emit one intra frame every ten frames */
  
            c->max_b_frames=1;
  
            c->pix_fmt = PIX_FMT_YUV420P;
  
  
  
            if(codec_id == AV_CODEC_ID_H264)
  
                av_opt_set(c->priv_data, "preset", "slow", 0);
  
  
  
            /* open it */
  
            if (avcodec_open2(c, codec, NULL) < 0) {
  
                throw std::runtime_error("Could not open codec\n");
  
            }
  
  
  
            f = fopen(filename, "wb");
  
            if (!f) {
  
                throw std::runtime_error("could not open file\n");
  
            }
  
  
  
            frame = avcodec_alloc_frame();
  
            if (!frame) {
  
                throw std::runtime_error("Could not allocate video frame\n");
  
            }
  
            frame->format = c->pix_fmt;
  
            frame->width  = c->width;
  
            frame->height = c->height;
  
  
  
            /* the image can be allocated by any means and av_image_alloc() is
  
             * just the most convenient way if av_malloc() is to be used */
  
  
  
            int ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height, c->pix_fmt, 32);
  
  
  
            if (ret < 0) {
  
                throw std::runtime_error("Could not allocate raw picture buffer\n");
  
            }
  
        }
  
  }

  read mat images

  void video_encode_example(const cv::Mat& fin)
  
  {
  
      AVPacket pkt;
  
      /* encode 1 second of video */
  
      av_init_packet(&pkt);
  
      pkt.data = NULL;    // packet data will be allocated by the encoder
  
      pkt.size = 0;
  
  
  
      fflush(stdout);
  
  
  
      cv::Mat res;
  
      cv::resize(fin, res, cv::Size(c->width, c->height));
  
  
  
      processToFrame(&res, frame);
  
      frame->pts = i;
  
  
  
      /* encode the image */
  
      int ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
  
      if (ret < 0) {
  
      throw std::runtime_error("Error encoding frame\n");
  
      }
  
  
  
      if (got_output) {
  
          printf("Write frame %3d (size=%5d)\n", i, pkt.size);
  
          fwrite(pkt.data, 1, pkt.size, f);
  
          av_free_packet(&pkt);
  
      }
  
      i++;
  
      /* get the delayed frames */
  
      /*for (got_output = 1; got_output; i++) {
  
          fflush(stdout);
  
  
  
          ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
  
          if (ret < 0) {
  
              throw std::runtime_error("Error encoding frame\n");
  
          }
  
  
  
          if (got_output) {
  
              printf("Write frame %3d (size=%5d)\n", i, pkt.size);
  
              fwrite(pkt.data, 1, pkt.size, f);
  
              av_free_packet(&pkt);
  
          }
  
      }*/
  
  }