Recherche avancée

Sur d’autres sites (6353)

• Duplicate a signal with FFmpeg library [on hold]

  22 septembre 2016, par Meugiwara

  I’m using the FFmpeg library to develop a program in C/C++. At this time, my aim is to duplicate the signal when I open an audio file. My scheme is the next : read an audio file, transform the stereo signal in mono signal and duplicate this mono signal to get two mono signal exactly the same.

  I watched in the Doxygen documentation on the official website, but I don’t find something interesting. Do someone know a good way to do this ?

  Here’s what I have so far :

  #include 
  
  #include 
  
  #include 
  
  
  
  #define __STDC_CONSTANT_MACROS
  
  
  
  #ifdef _WIN32
  
  
  
  extern "C" /* Windows */
  
  {
  
      #include "libswresample/swresample.h"
  
      #include "libavformat/avformat.h"
  
      #include "libavcodec/avcodec.h"
  
      #include "SDL2/SDL.h"
  
  };
  
  
  
  #else
  
  
  
  #ifdef __cplusplus
  
  
  
  extern "C" /* Linux */
  
  {
  
      #endif /* __cplusplus */
  
      #include <libswresample></libswresample>swresample.h>
  
      #include <libavformat></libavformat>avformat.h>
  
      #include <libavcodec></libavcodec>avcodec.h>
  
      #include <sdl2></sdl2>SDL.H>
  
      #ifdef __cplusplus
  
  };
  
  
  
  #endif /* __cplusplus */
  
  
  
  #endif /* _WIN32 */
  
  
  
  #define MAX_AUDIO_FRAME_SIZE 192000 /* 1 second of 48 kHz 32 bits audio*/
  
  #define OUTPUT_PCM 1 /* Output PCM */
  
  #define USE_SDL 1 /* Use SDL */
  
  
  
  /* Les incrémentations */
  
  static Uint32 audio_len;
  
  static Uint8 *audio_chunk;
  
  static Uint8 *audio_pos;
  
  
  
  void    fill_audio(void *udata, Uint8 *stream, int len)
  
  {
  
      SDL_memset(stream, 0, len); /* SDL 2.0 */
  
      if (audio_len == 0)
  
          return;
  
      len = (len > audio_len ? audio_len : len);
  
      SDL_MixAudio(stream, audio_pos, len, SDL_MIX_MAXVOLUME);
  
      audio_pos = audio_pos + len;
  
      audio_len = audio_len - len;
  
  }
  
  
  
  int     reading_sound(char *str)
  
  {
  
      SDL_AudioSpec       wanted_spec;
  
      AVFormatContext     *pFormatCtx;
  
      AVCodecContext      *pCodecCtx;
  
      AVSampleFormat      out_sample_fmt;
  
      AVPacket            *packet;
  
      AVFrame             *pFrame;
  
      AVCodec             *pCodec;
  
      uint64_t            out_channel_layout;
  
      uint8_t             *out_buffer;
  
      int64_t             in_channel_layout;
  
      struct SwrContext   *au_convert_ctx;
  
      int                 out_sample_rate;
  
      int                 out_buffer_size;
  
      int                 out_nb_samples;
  
      int                 out_channels;
  
      int                 audioStream;
  
      int                 got_picture;
  
      int                 index = 0;
  
      int                 ret;
  
      int                 i;
  
      FILE                *pFile = NULL;
  
      /*
  
      //char              *sound = "WavinFlag.aac";
  
      */
  
  
  
      av_register_all();
  
      avformat_network_init();
  
      pFormatCtx = avformat_alloc_context();
  
      if (avformat_open_input(&amp;pFormatCtx, str, NULL, NULL) != 0) /* Ouverture du fichier */
  
      {
  
          fprintf(stderr, "%s\n", "Couldn't open input stream");
  
          return (-1);
  
      }
  
      if (avformat_find_stream_info(pFormatCtx, NULL) &lt; 0) /* Récupérer les informations */
  
      {
  
          fprintf(stderr, "Couldn't find stream information\n");
  
          return (-1);
  
      }
  
      av_dump_format(pFormatCtx, 0, str, false); /* Envoyer les informations utiles sur la sortie d'erreur */
  
      audioStream = -1;
  
      for (i = 0; i &lt; pFormatCtx->nb_streams; i++) /* Trouver le début du son */
  
          if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
  
          {
  
              audioStream = i;
  
              break;
  
          }
  
      if (audioStream == -1)
  
      {
  
          fprintf(stderr, "%s\n", "Didn't find an audio stream");
  
          return (-1);
  
      }
  
      pCodecCtx = pFormatCtx->streams[audioStream]->codec;
  
      pCodec = avcodec_find_decoder(pCodecCtx->codec_id); /* Trouver le décodeur du fichier (.aac, .mp3, ...) */
  
      if (pCodec == NULL)
  
      {
  
          fprintf(stderr, "%s\n", "Codec not found");
  
          return (-1);
  
      }
  
      if (avcodec_open2(pCodecCtx, pCodec, NULL) &lt; 0) /* Ouvrir le décodeur du fichier */
  
      {
  
          fprintf(stderr, "%s\n", "Couldn't open codec");
  
          return (-1);
  
      }
  
  
  
      #if OUTPUT_PCM
  
  
  
          pFile = fopen("output.pcm", "wb"); /* Créer et écrire tout ce qui se passe dans ce fichier */
  
  
  
      #endif /* OUTPUT_PCM */
  
  
  
      packet = (AVPacket *)av_malloc(sizeof(AVPacket)); /* Allouer taille */
  
      av_init_packet(packet);
  
      out_channel_layout = AV_CH_LAYOUT_MONO; /* Canaux de sortie */
  
      out_nb_samples = pCodecCtx->frame_size; /* L'échantillonnage - Le nombre de samples*/
  
      out_sample_fmt = AV_SAMPLE_FMT_S16; /* Format */
  
      out_sample_rate = 44100; /* Fréquence */
  
      out_channels = av_get_channel_layout_nb_channels(out_channel_layout); /* Récupérer le nombre de canaux */
  
      /*
  
      // printf("%d\n", out_channels);
  
      // system("PAUSE");
  
      */
  
      out_buffer_size = av_samples_get_buffer_size(NULL, out_channels, out_nb_samples, out_sample_fmt, 1); /* Taille du buffer */
  
      out_buffer = (uint8_t *)av_malloc(MAX_AUDIO_FRAME_SIZE * 2); /* Allouer taille */
  
      pFrame = av_frame_alloc(); /* Allouer taille */
  
  
  
      #if USE_SDL
  
  
  
          if (SDL_Init(SDL_INIT_VIDEO |SDL_INIT_AUDIO | SDL_INIT_TIMER)) /* Initialiser SDL */
  
          {
  
              fprintf(stderr, "%s - %s\n", "Couldn't initialize SDL", SDL_GetError());
  
              return (-1);
  
          }
  
          /*
  
          // Attribution des valeurs avec les variables au-dessus
  
          */
  
          wanted_spec.freq = out_sample_rate;
  
          wanted_spec.format = AUDIO_S16SYS;
  
          wanted_spec.channels = out_channels;
  
          wanted_spec.silence = 0;
  
          wanted_spec.samples = out_nb_samples;
  
          wanted_spec.callback = fill_audio;
  
          wanted_spec.userdata = pCodecCtx;
  
          if (SDL_OpenAudio(&amp;wanted_spec, NULL) &lt; 0)
  
          {
  
              fprintf(stderr, "%s\n", "Can't open audio");
  
              return (-1);
  
          }
  
  
  
      #endif /* USE_SDL */
  
  
  
      in_channel_layout = av_get_default_channel_layout(pCodecCtx->channels);
  
      au_convert_ctx = swr_alloc();
  
      au_convert_ctx = swr_alloc_set_opts(au_convert_ctx, out_channel_layout, out_sample_fmt, out_sample_rate,
  
      in_channel_layout, pCodecCtx->sample_fmt, pCodecCtx->sample_rate, 0, NULL);
  
      swr_init(au_convert_ctx);
  
      while (av_read_frame(pFormatCtx, packet) >= 0) /* Lecture du fichier */
  
      {
  
          if (packet->stream_index == audioStream)
  
          {
  
              ret = avcodec_decode_audio4(pCodecCtx, pFrame, &amp;got_picture, packet); /* Décoder les packets */
  
              if (ret &lt; 0)
  
              {
  
                  fprintf(stderr, "%s\n", "Error in decoding audio frame");
  
                  return (-1);
  
              }
  
              if (got_picture > 0)
  
              {
  
                  swr_convert(au_convert_ctx, &amp;out_buffer, MAX_AUDIO_FRAME_SIZE, (const uint8_t **)pFrame->data, pFrame->nb_samples);
  
  
  
      #if 1
  
  
  
                  printf("Index : %5d\t Points : %lld\t Packet size : %d\n", index, packet->pts, packet->size); /* Affichage des informations sur la console */
  
  
  
      #endif /* 1 */
  
  
  
      #if OUTPUT_PCM
  
  
  
                  fwrite(out_buffer, 1, out_buffer_size, pFile); /* Faire l'écriture dans le fichier */
  
  
  
      #endif /* OUTPUT_PCM */
  
  
  
                  index = index + 1;
  
              }
  
  
  
      #if USE_SDL
  
  
  
              while (audio_len > 0)
  
                  SDL_Delay(1);
  
              audio_chunk = (Uint8 *)out_buffer;
  
              audio_len = out_buffer_size;
  
              audio_pos = audio_chunk;
  
              SDL_PauseAudio(0);
  
  
  
      #endif /* USE_SDL */
  
  
  
          }
  
          av_free_packet(packet); /* Libérer les packets */
  
      }
  
      swr_free(&amp;au_convert_ctx); /* Libérer la taille de conversion */
  
  
  
      #if USE_SDL
  
  
  
      SDL_CloseAudio(); /* Arrêter le son dans SDL */
  
      SDL_Quit(); /* Quitter SDL */
  
  
  
      #endif /* USE_SDL */
  
  
  
      #if OUTPUT_PCM
  
  
  
      fclose(pFile); /* Fermer le fichier d'écriture */
  
  
  
      #endif /* OUTPUT_PCM */
  
  
  
      av_free(out_buffer);
  
      avcodec_close(pCodecCtx); /* Fermer le décodeur */
  
      avformat_close_input(&amp;pFormatCtx); /* Fermer le fichier lu */
  
      return (0);
  
  }
  
  
  
  int     main(int argc, char **argv)
  
  {
  
  
  
      if (argc != 2)
  
      {
  
          fprintf(stderr, "%s\n", "Usage : ./BASELFI [File]");
  
          system("PAUSE");
  
          return (-1);
  
      }
  
      else
  
      {
  
          reading_sound(argv[1]);
  
          return (0);
  
      }
  
      return (0);
  
  }

• Ffmpeg set output format C++

  7 septembre 2022, par Turgut

  I made a program that encodes a video and I want to specify the format as h264 but I can't figure out how to do it. It automatically sets the format to mpeg4 and I can't change it. I got my code from ffmpegs official examples muxing.c and slightly edited it to fit my code (I haven't changed much especially did not touch the parts where it sets the format)

  


  Here is my code so for (I have trimmed down the code slightly, removing redundant parts)

  


  video_encoder.cpp :

  


  
video_encoder::video_encoder(int w, int h, float fps, unsigned int duration) 
 :width(w), height(h), STREAM_FRAME_RATE(fps), STREAM_DURATION(duration)
{
    std::string as_str = "./output/video.mp4";

    char* filename = const_cast(as_str.c_str());
    enc_inf.video_st, enc_inf.audio_st = (struct OutputStream) { 0 };
    enc_inf.video_st.next_pts = 1; 
    enc_inf.audio_st.next_pts = 1;
    enc_inf.encode_audio, enc_inf.encode_video = 0;
    int ret;
    int i;

    /* allocate the output media context */
    avformat_alloc_output_context2(&enc_inf.oc, NULL, NULL, filename);

    if (!enc_inf.oc) {
        std::cout << "FAILED" << std::endl;
        avformat_alloc_output_context2(&enc_inf.oc, NULL, "mpeg", filename);
    }

    enc_inf.fmt = enc_inf.oc->oformat;

    /* Add the audio and video streams using the default format codecs
     * and initialize the codecs. */
    if (enc_inf.fmt->video_codec != AV_CODEC_ID_NONE) {
        add_stream(&enc_inf.video_st, enc_inf.oc, &video_codec, enc_inf.fmt->video_codec);
        enc_inf.have_video = 1;
        enc_inf.encode_video = 1;
    }
    if (enc_inf.fmt->audio_codec != AV_CODEC_ID_NONE) {
        add_stream(&enc_inf.audio_st, enc_inf.oc, &audio_codec, enc_inf.fmt->audio_codec);
        enc_inf.have_audio = 1;
        enc_inf.encode_audio = 1;
    }

    /* Now that all the parameters are set, we can open the audio and
     * video codecs and allocate the necessary encode buffers. */
    if (enc_inf.have_video)
        open_video(enc_inf.oc, video_codec, &enc_inf.video_st, opt);

    if (enc_inf.have_audio)
        open_audio(enc_inf.oc, audio_codec, &enc_inf.audio_st, opt);
    av_dump_format(enc_inf.oc, 0, filename, 1);

    /* open the output file, if needed */
    if (!(enc_inf.fmt->flags & AVFMT_NOFILE)) {
        ret = avio_open(&enc_inf.oc->pb, filename, AVIO_FLAG_WRITE);
        if (ret < 0) {
            //VI_ERROR("Could not open '%s': %s\n", filename, ret);
            //return 1;
        }
    }

    /* Write the stream header, if any. */
    ret = avformat_write_header(enc_inf.oc, &opt);
    if (ret < 0) {
        VI_ERROR("Error occurred when opening output file:");
        //return 1;
    }
    
    //return 0;
}


/* Add an output stream. */
void video_encoder::add_stream(OutputStream *ost, AVFormatContext *oc,
                       const AVCodec **codec,
                       enum AVCodecID codec_id)
{
    AVCodecContext *c;
    int i;

    /* find the encoder */
    *codec = avcodec_find_encoder(codec_id);
    
    if (!(*codec)) {
        fprintf(stderr, "Could not find encoder for '%s'\n",
                avcodec_get_name(codec_id));
        exit(1);
    }

    ost->tmp_pkt = av_packet_alloc();

    if (!ost->tmp_pkt) {
        fprintf(stderr, "Could not allocate AVPacket\n");
        exit(1);
    }

    ost->st = avformat_new_stream(oc, NULL);
    if (!ost->st) {
        fprintf(stderr, "Could not allocate stream\n");
        exit(1);
    }
    ost->st->id = oc->nb_streams-1;
    c = avcodec_alloc_context3(*codec);
    if (!c) {
        fprintf(stderr, "Could not alloc an encoding context\n");
        exit(1);
    }
    ost->enc = c;


    switch ((*codec)->type) {
    case AVMEDIA_TYPE_AUDIO:
        ...
        break;
    case AVMEDIA_TYPE_VIDEO:
        c->codec_id = codec_id;

        c->bit_rate = 10000;
        /* Resolution must be a multiple of two. */
        c->width    = width;
        c->height   = height;
        /* timebase: This is the fundamental unit of time (in seconds) in terms
         * of which frame timestamps are represented. For fixed-fps content,
         * timebase should be 1/framerate and timestamp increments should be
         * identical to 1. */
        ost->st->time_base = (AVRational){ 1, STREAM_FRAME_RATE }; // *frame_rate
        c->time_base       = ost->st->time_base;

        c->gop_size      = 7; /* emit one intra frame every twelve frames at most */
        //c->codec_id      = AV_CODEC_ID_H264;
        c->pix_fmt       = STREAM_PIX_FMT;
        //if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) 
        //    c->max_b_frames = 2;
        if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
            /* Needed to avoid using macroblocks in which some coeffs overflow.
             * This does not happen with normal video, it just happens here as
             * the motion of the chroma plane does not match the luma plane. */
            c->mb_decision = 2;
        }

        if ((*codec)->pix_fmts){
            //c->pix_fmt = (*codec)->pix_fmts[0];
            std::cout << "NEW FORMAT : " << c->pix_fmt << std::endl;
        }

        break;
    }
     

    /* Some formats want stream headers to be separate. */
    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
        c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
}


  


  video_encoder.h

  


  
typedef struct OutputStream {
    AVStream *st;
    AVCodecContext *enc;

    /* pts of the next frame that will be generated */
    int64_t next_pts;
    int samples_count;

    AVFrame *frame;
    AVFrame *tmp_frame;

    AVPacket *tmp_pkt;

    float t, tincr, tincr2;

    struct SwsContext *sws_ctx;
    struct SwrContext *swr_ctx;
} OutputStream;

class video_encoder{
    private:
        typedef struct {
            OutputStream video_st, audio_st;
            const AVOutputFormat *fmt;
            AVFormatContext *oc;
            int have_video, have_audio, encode_video, encode_audio;
            std::string name;
        } encode_info;
    public:
        encode_info enc_inf;
        video_encoder(int w, int h, float fps, unsigned int duration);
        ~video_encoder();  
        ...
    private:
        ...
        void add_stream(OutputStream *ost, AVFormatContext *oc,
                       const AVCodec **codec,
                       enum AVCodecID codec_id);


  


  I'm thinking that the example sets the codec at avformat_alloc_output_context2(&enc_inf.oc, NULL, NULL, filename) but I'm not quite sure how to set it to h264.

  


  I've tried something like this avformat_alloc_output_context2(&enc_inf.oc, enc_inf.fmt, "h264", filename)

  


  But it just gives a seg fault. What am I supposed to do ?

  


  Edit : I've tried adding these two lines to video_encoder::video_encoder by deleting avformat_alloc_output_context2(&enc_inf.oc, NULL, NULL, filename); :

  


  
    video_codec = avcodec_find_encoder(AV_CODEC_ID_H264);
    enc_inf.video_st.enc = avcodec_alloc_context3(video_codec);



  


  But it resulted in these errors :
It says this every frame (A bunch of times)

  


  [mpeg @ 0x56057c465480] buffer underflow st=0 bufi=26822 size=31816


  


  Says this once when the frame encoding loop is over :

  


  [mpeg @ 0x5565ac4a04c0] start time for stream 0 is not set in estimate_timings_from_pts
[mpeg @ 0x5565ac4a04c0] stream 0 : no TS found at start of file, duration not set
[mpeg @ 0x5565ac4a04c0] Could not find codec parameters for stream 0 (Video: mpeg2video, none): unspecified size
Consider increasing the value for the 'analyzeduration' (0) and 'probesize' (5000000) options


  


• France rules Google Analytics non-compliant with GDPR

  11 février 2022, par Erin — Privacy

  Breaking news : The French Data Protection Agency, CNIL (Commission nationale de l’informatique et des libertés), has concluded that the use of Google Analytics is illegal under GDPR. The CNIL has begun issuing formal notices to website managers using Google Analytics.

  This follows the January 2022 Austrian Data Protection Authority’s decision to declare Google Analytics illegal to use under GDPR.

  Google Analytics GDPR breaches continue to spread through the EU

  Since the invalidation of the Privacy Shield framework, an agreement between the EU and US that allowed the transfer of data to certified US companies, the CNIL and other EU data protection authorities have received numerous complaints regarding data transfers collected during visits to websites using Google Analytics.

  "It’s interesting to see that the different European Data Protection Authorities all come to the same conclusion : the use of Google Analytics is illegal. There is a European task force and we assume that this action is coordinated and other authorities will decide similarly."

  About the CNIL’s decision

  In this model case, the CNIL has found that an unnamed website’s use of Google Analytics is non-compliant with GDPR because it had breached Article 44 which prohibits the transfer of personal data beyond the EU, unless the recipient country can prove adequate data protection. 

  Under the GDPR, personal data covers a range of identifiers including email address, race, gender, phone number to name a few, but the less obvious identifiers include IP addresses or cookie IDs, for instance. 

  The CNIL’s decision was based on the fact that the US does not meet GDPR sufficient levels of data protection as a result of US surveillance laws. Therefore, the unnamed website’s use of Google Analytics created risks for their website visitors when their personal data was exported to the US. 

  At the time of writing, it is unknown if the CNIL has issued a fine for the GDPR breach. However, the website manager of the unnamed website has been ordered by the CNIL to comply with the GDPR and, if necessary, stop using Google Analytics under the current conditions.

  "One thing we’re certain of is that these decisions will continue to roll out throughout the EU and potentially beyond.

  Other countries are imposing their own privacy regulations that closely mirror the GDPR like Brazil’s General Data Protection Law (LGPD), India’s Data Protection Bill, New Zealand’s Privacy Act and Canada’s Personal Information Protection and Electronic Documents Act (PIPEDA) to name a few.”

  The CNIL offers an evaluation programme to help website managers determine whether web analytics solutions are exempt from collecting data prior to users’ agreement to opt-in through consent screens. Matomo, for instance, is a leading Google Analytics alternative that has been recommended by CNIL and is exempt from tracking consent. 

  

  English translation : “This is why I anticipated this announcement, gradually moving the analytics of my sites to @matomo_org since several weeks !

  “The @CNIL believes that the use of @googleanalytics is a violation of #GDPR”

  Immediate action required for Google Analytics users

  The CNIL and other EU-based data protection authorities have made their stance on Google Analytics clear and inaction will likely result in fines, which under the GDPR, can be up to €20 million or 4% of the organisation’s global turnover – whichever is higher.

  Based on the CNIL’s formal notice to the model case’s website manager, Google Analytics users should take immediate action to remove any chances of personal data being transferred to the US or find a Google Analytics alternative that is GDPR compliant. 

  

  English translation : “The CNIL considers that the use of Google Analytics is a violation of the GDPR. I use @matomo_org and I welcome it *winking face* It will squeal tires among growthackers who are slaughtering. Opportunity to look at alternative tools”

  Ready to begin your journey to GDPR compliance with Matomo ? Start your 21-day free trial now (no credit card required) and take advantage of our Google Analytics importer so you don’t lose any of your historical data. 

  Try 21-day free Cloud trial

  What does this mean for Matomo users ?

  As the GDPR continues to evolve, our users can rest assured that Matomo will be at the forefront of these changes. With Matomo Cloud, all data is stored in the EU or in your country of choice when you self-host on your own servers with Matomo On-Premise.

  Conclusion

  Google is in the EU’s crosshairs and organisations that continue to use their tools will be the one’s left to clean up the mess – not Google. Now is the time to act. Search for a Google Analytics alternative and close your compliance gaps today. 

  Join over 1 million other websites using Matomo now. Give Matomo a try with a 21-day free trial – no credit card required. 

  Try 21-day free Cloud trial

  We’d like to also bring attention to the privacy-fighting efforts from noyb and Max Schrems, as this should not go unnoticed. noyb is an independent, non-profit organisation that relies on the support of individuals. Support privacy by supporting noyb – donate or become a member now. 

  Contact details for media :

  For quotes or interviews, please email marketing@matomo.org