Recherche avancée

Sur d’autres sites (9254)

• libavformat : calling avformat_open_input 2 times results in decoding white frames

  25 avril 2017, par explodus
  • pre build ffmpeg libs format/util/scale
  • version 57.56.101
  • don’t use any deprecated function
  • use the actual style
    • av_read_frame -> avcodec_send_packet -> avcodec_receive_frame -> sws_scale

  Everything is fine on the first run, but when i wanna load/open another file i only get white frames.

  void video::app::flush_cached_frames() {
  
      if (nullptr == avcontext)
  
          return;
  
      if (nullptr == avpicture)
  
          return;
  
  
  
      // send an empty packet which instructs the codec to start flushing
  
      AVPacket pkt;
  
      av_init_packet(&pkt);
  
      pkt.data = NULL;
  
      pkt.size = 0;
  
      avcodec_send_packet(avcontext, &pkt);
  
  
  
      // drain the codec
  
      while (true) {
  
          int r = avcodec_receive_frame(avcontext, avpicture);
  
          if (r != 0)
  
              break;
  
      }
  
  }
  
  
  
  void video::app::close_avi() {
  
      flush_cached_frames();
  
  
  
      if (avformat && avstream)
  
          seek_to_frame(0);
  
      avstream = nullptr;
  
  
  
      if (avfile)
  
          fclose(avfile);
  
      avfile = nullptr;
  
  
  
      if (avcontext)
  
          avcodec_close(avcontext);
  
      avcontext = nullptr;
  
  
  
      if (avformat)
  
          avformat_free_context(avformat);
  
      avformat = nullptr;
  
  
  
      if (sws_ctx)
  
          sws_freeContext(sws_ctx);
  
      sws_ctx = nullptr;
  
  
  
      if (avparser)
  
          av_parser_close(avparser);
  
      avparser = nullptr;
  
  
  
      if (avinbuf)
  
          av_free(avinbuf);
  
      avinbuf = nullptr;
  
  }

  I think i close anything perfectly. Has anyone an idea ?

  edit1 : init/load

  unsigned video::app::load(const std::string& name) {
  
      _file = name_;
  
  
  
      close_avi();
  
  
  
      av_register_all();
  
      avcodec_register_all();
  
  
  
      av_init_packet(&avpkt);
  
  
  
      AVCodecID codec_id = AV_CODEC_ID_H264;
  
      int64_t duration = 0;
  
      double fps = .0;
  
      int ret = 0;
  
      {
  
          av_log_set_level(1);
  
  
  
          avfile = fopen(name_.c_str(), "rb");
  
  
  
          avformat = avformat_alloc_context();
  
          ret = avformat_open_input(&avformat, name_.c_str(), nullptr, nullptr);
  
          ret = avformat_find_stream_info(avformat, nullptr);
  
          duration = avformat->duration;
  
  
  
          avstream = nullptr;
  
          if (avformat->nb_streams == 1) {
  
              avstream = avformat->streams[0];
  
          } else {
  
              avstream = avformat->streams[av_find_default_stream_index(avformat)];
  
          }
  
  
  
          if (avstream) {
  
              fps = (double(avstream->avg_frame_rate.num) / double(avstream->avg_frame_rate.den));
  
              codec_id = avstream->codecpar->codec_id;
  
              duration = avstream->duration;
  
  
  
              _vid.v_width = avstream->codecpar->width;
  
              _vid.v_height = avstream->codecpar->height;
  
  
  
              _vid.lastframe = duration / fps;
  
              _vid.lastframe = avstream->nb_frames;
  
          }
  
  
  
          avcodec = avcodec_find_decoder(avstream->codecpar->codec_id);
  
          avparser = av_parser_init(avcodec->id);
  
          avcontext = avcodec_alloc_context3(avcodec);
  
  
  
          avcontext->flags |= AVFMT_FLAG_NONBLOCK;
  
          avcontext->flags |= AVFMT_FLAG_FLUSH_PACKETS;
  
          avcontext->flags |= AVFMT_FLAG_DISCARD_CORRUPT;
  
          avcontext->flags |= AVFMT_FLAG_NOBUFFER;
  
  
  
          ret = avcodec_parameters_to_context(avcontext, avstream->codecpar);
  
          ret = avcodec_open2(avcontext, avcodec, nullptr);
  
  
  
  
  
          // Determine required buffer size and allocate buffer
  
          auto numBytes = av_image_get_buffer_size(
  
                AV_PIX_FMT_BGRA
  
              , avcontext->width
  
              , avcontext->height
  
              , 1);
  
          if (avinbuf)
  
              av_free(avinbuf);
  
          avinbuf = nullptr;
  
          avinbuf = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));
  
          ret = av_image_fill_arrays(
  
                avrgb->data
  
              , avrgb->linesize
  
              , avinbuf
  
              , AV_PIX_FMT_BGRA
  
              , avcontext->width
  
              , avcontext->height
  
              , 1);
  
  
  
          sws_ctx = sws_getContext(
  
                  avcontext->width
  
              , avcontext->height
  
              , avcontext->pix_fmt
  
              , avcontext->width
  
              , avcontext->height
  
              , AV_PIX_FMT_BGRA
  
              , SWS_BILINEAR
  
              , nullptr
  
              , nullptr
  
              , nullptr
  
          );
  
      }
  
  
  
      int err = (sws_ctx && avcontext && avformat) ? 0 : 1;
  
      // ...
  
  }

  getting the frame :

  uint8_t * video::app::get_frame(uint32_t frame) {
  
      if (!avcontext)
  
          return nullptr;
  
      if (!avformat)
  
          return nullptr;
  
      if (!avpicture)
  
          return nullptr;
  
      if (!avfile)
  
          return nullptr;
  
  
  
      try {
  
          int ret = 0;
  
  
  
          if (avpicture->data)
  
              av_frame_unref(avpicture);
  
  
  
          while (true) {
  
              if ((ret = av_read_frame(avformat, &avpkt)) < 0)
  
                  break;
  
  
  
              if (avpkt.stream_index == avstream->index) {
  
                  ret = avcodec_send_packet(avcontext, &avpkt);
  
                  if (ret < 0)
  
                      break;
  
  
  
                  while (ret >= 0) {
  
                      ret = avcodec_receive_frame(avcontext, avpicture);
  
                      if (ret == AVERROR_EOF) {
  
                          return nullptr;
  
                      } else if (ret == -11) {
  
                          avpkt.data = nullptr;
  
                          avpkt.size = 0;
  
                          break;
  
                      } else if (ret < 0) {
  
                          return nullptr;
  
                      }
  
  
  
                      if (ret == AVERROR(EAGAIN)) {
  
                          avpkt.data = nullptr;
  
                          avpkt.size = 0;
  
                          break;
  
                      }
  
  
  
                      if (ret >= 0) {
  
                          int linesize[AV_NUM_DATA_POINTERS] = {
  
                                avpicture->linesize[0]
  
                              , avpicture->linesize[1]
  
                              , avpicture->linesize[2]
  
                              , avpicture->linesize[3]
  
                              , avpicture->linesize[4]
  
                              , avpicture->linesize[5]
  
                              , avpicture->linesize[6]
  
                              , avpicture->linesize[7]
  
                          };
  
                          uint8_t * data[AV_NUM_DATA_POINTERS] = {
  
                                avpicture->data[0]
  
                              , avpicture->data[1]
  
                              , avpicture->data[2]
  
                              , avpicture->data[3]
  
                              , avpicture->data[4]
  
                              , avpicture->data[5]
  
                              , avpicture->data[6]
  
                              , avpicture->data[7]
  
                          };
  
  
  
                          {
  
                              // flip the frame, never ever touch this thing again!
  
                              // If the planes in the image are unequal size(e.g.YUV420) you need to adapt the height.
  
                              auto h = avcontext->height;
  
                              for (int i = 0; i < 4; i++) {
  
                                  if (i)
  
                                      data[i] += linesize[i] * ((h >> 1) - 1);
  
                                  else
  
                                      data[i] += linesize[i] * (h - 1);
  
                                  linesize[i] = -linesize[i];
  
                              }
  
                          }
  
  
  
                          ret = sws_scale(
  
                                sws_ctx
  
                              , (uint8_t const * const *)data
  
                              , linesize
  
                              , 0
  
                              , avcontext->height
  
                              , avrgb->data
  
                              , avrgb->linesize);
  
  
  
                          av_packet_unref(&avpkt);
  
  
  
                          currPts = avpkt.dts;
  
                          currPts *= av_q2d(avstream->time_base);
  
  
  
                          usleep(1000000 * (currPts - prevPts));
  
                          prevPts = currPts;
  
  
  
                          return avrgb->data[0];
  
                      }
  
                  }
  
              }
  
              av_packet_unref(&avpkt);
  
          }
  
  
  
      } catch (...) {
  
      }
  
  
  
      return nullptr;
  
  }

• How to track Google AdWords campaigns with Piwik

  19 décembre 2017, par InnoCraft

  In 2016, Google AdWords was the most popular ad service on earth. As a result, it may be your first source for ad spending. Are you interested in knowing whether you are making a profit out of it ? Would you like to know how to track users coming from AdWords with Piwik efficiently ? This is what this article is about.

  

  What you need to know about Google AdWords

  By default, each ad you create in Google AdWords is not tracked. Even worse than that, every click on your ad is identified in Piwik as an organic result coming from Google with the following value : “Keyword not defined”.

  To make it simple, if you do not track your AdWords campaigns both your paid and organic traffic will be biased within your Piwik account. It will be impossible for you to measure your return on investment and it means that you are throwing your money down the drain.

  In order to avoid this, we will show you how to track Google AdWords traffic into Piwik.

  How to track paid Google AdWords campaigns into Piwik

  If you want to analyze Google AdWords campaigns within Piwik properly, you need to add additional tracking parameters to the final URL of each of your ads.

  We recommend using the following tool to add the needed additional tracking parameters : https://piwik.org/docs/tracking-campaigns-url-builder/

  You will then be able to push additional data to Piwik such as :

  • pk_campaign : the name of your ad campaign
  • pk_kwd : the keyword associated to this campaign
  • pk_source : the source of your campaign
  • pk_medium : the type of source, in our case either cpc, cpm, cpa
  • pk_content : the content of your ad

  If your campaign URL looks like this : https://your-website.com/, your campaign URL will then look like this after adding the campaign parameters :

  https://your-website.com/?pk_campaign=Name-Of-Your-Campaign&pk_kwd=Your-Keyword&pk_source=google&pk_medium=cpc&pk_content=My-Ad-Headline

  As each ad URL can be fired by different keywords and can correspond to different campaigns or headlines, you will need to customize the campaign parameters for each URL.

  Customizing all of your URLs individually would take you a lot of time under circumstances. That’s why you should know, that each URL parameter can be filled automatically in AdWords with a feature called “Tracking template”.

  Simplifying the campaign URL parameters with tracking templates

  You can define tracking templates either at the account, campaign or ad group level. For example, by using a tracking template at the account level, all your campaigns will have the same landing page with the URL parameters you defined in the tracking template. By defining it at the campaign level, it means that all your ad groups within the campaign will have the same landing page and so on and so forth. Any tracking template defined in a campaign, will overwrite a tracking template defined at the account level.

  Tracking template at the account level

  To edit the template at the account level, you need to click on “Settings”, then click on the “Account” settings tab and define your tracking template pattern. For example :

  https://your-website.com/?url={lpurl}&pk_campaign=AdWords&pk_kwd=Your-Keyword&pk_source=google&pk_medium=cpc&pk_content=My-Ad-Headline

  

  This will apply to all your URLs within your account. So it is only useful if your website domain is the same across all your ads. The URL parameter is compulsory here.

  It can be limiting to have a static value for “pk_campaign” and “pk_kwd” so Google allows you to use dynamic insertion, such as follows :

  https://your-landing-page.com/?url={lpurl}&pk_campaign={campaignid}&pk_kwd={keyword}&pk_source=google&pk_medium=cpc&pk_content={creative}

  The “keyword” means that the data is automatically replaced with the keyword which fired the ad within your account.

  Visit the following page if you want to know more about the different dynamic tags that AdWords supports : https://support.google.com/adwords/answer/6305348#urlinsertion

  Tracking template at the campaign level

  If you wish to define a tracking template at the campaign level, you will find this option within the “Campaign” settings under the campaign URL options :

  

  Tracking template at the Ad Group level

  You can also set it at the Ad Group level within the “Ad Group” settings :

  

  As Google mentions : “If you set up URL options at the campaign level, ad group level, or ad level, those settings will override the account-level options“.

  Now that your URLs are properly configured, you will be able to analyze AdWords traffic performances within Piwik once a click is coming from those sources.

  

  Did you like this article ? If yes, do not hesitate to share it or give us your feedback about the topic you would like us to write about.

• Frozen video clips when concatenating mp4 videos using ffmpeg via nodje.js fluent-ffmpeg

  21 novembre 2023, par Rasmus Puls

  I'm trying to write a simple js application that takes all video files in a directory and the produce one single video consisting of all the clips combined one after another into one timeline.

  


  To test the application I have download for random short stock video clips from pexels :

Shown in order : clip 1, clip 2, clip 3, clip 4

  


  Each of the clips plays perfectly in vlc on windows (no broken or frozen frames)

  


  I use the following script to concat the clips :

  


    const ffmpeg = require('fluent-ffmpeg');

  ffmpeg()
    .input(concatFilePath)
    .inputOptions(['-f concat', '-safe 0'])
    .outputOptions(['-c copy', '-c:v libx264', '-b:v 5M', '-r 30', '-preset', 'slow'])
    .on('end', () => {
      console.log('Video clips concatenated successfully.');
    })
    .on('error', (err) => {
      console.error('Error concatenating video clips:', err);

      // Cleanup: Delete the output folder
      console.log('Cleaning up...');
      deleteOutputFolder(outputDir);
    })
    .save(outputPath);


  


  The contect of my concatFilePath (concat.txt) file looks like this :

  


  file src\input\d69de4a3-2b72-462c-be70-f8b8287b45e0\pexels-fred-c-19065853 (Original).mp4
file src\input\d69de4a3-2b72-462c-be70-f8b8287b45e0\pexels-imad-clicks-16270463 (2160p).mp4
file src\input\d69de4a3-2b72-462c-be70-f8b8287b45e0\pexels-peter-fowler-9683061 (2160p).mp4
file src\input\d69de4a3-2b72-462c-be70-f8b8287b45e0\pexels-sascha-5799767 (1080p).mp4


  


  The problem

  


  When I run the program it takes about 15 seconds to render the output video.
The first clip looks as the stock clip, but when I get to the 2nd clip it just sits frozen at the first fram of that video, and only runs for 3-4 seconds despite the stock clip is 8 seconds long. It then transitions into the 3rd clip which is renderd correctly but the rest of the video is frozen on the last frame of clip 3 instead of showing clip 4.

  


  I'm assuming that my input options are to blame for the result of the output, I have tried various other input options suggested from github thread and other sources, but none of them have produces a reasonable result.