Recherche avancée

Sur d’autres sites (7384)

• 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);
  
  }

• Evolution #3071 : Performance boucle DATA sur CSV

  15 octobre 2013, par esj -

  De l’utilité de faire "svn cp" et non une copie dans éditeur perso pour que l’historique d’un code soit facile à retrouver.

  Ce code est apparu en 2007 dans r10948 qui répondait à une difficulté signalée dans Spip-contrib, à laquelle il fut répondu par un code, documenté sur spipnet comme il se doit :
  http://contrib.spip.net/Creer-de-grands-tableaux-dans-SPIP,9#forum401060

  Cette fonction faisait alors 3 lignes, c’était plus rapide à écrire que de regarder si PHP avait l’équivalent en magasin.
  Ensuite, il y a eu quantités de signalements de problèmes, ce format propriétaire à l’origine ayant un RFC tardif et imprécis dont tout le monde se fout,
  d’où un code qui n’a pas cessé de croître avec les années (r11111, r11113, r13859, r14013 surtout). Au vu du commentaire dans la doc PHP de fgetcsv, ce code semble toujours d’actualité. En tout cas il y a intérêt à vérifier que les cas signalés dans les logs des commit ci-dessous sont bien pris en compte par cette fonction avant de mettre le code des autres à la poubelle sans chercher à comprendre, marque de fabrique de SPIP3.

• FFmpeg transcode GIF into Mp4 and Mp4 to AVI using GPU

  9 octobre 2023, par Cristian

  I'm trying to convert GIF animated to mp4 and mp4 to AVI with FFmpeg.

  


  I started to use just the CPU, but I have to process millions of GIFs/mp4 content pieces. So, I started to have a lot of errors processing them, and it ended as a bottleneck. Therefore, I'm trying to use GPU to process the videos.

  


  Converting GIF to mp4 with CPU, I run the following command :

  


  ffmpeg -i animated.gif -movflags faststart -pix_fmt yuv420p -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" video.mp4


  


  Using the GPU I'm trying the following :

  


  ffmpeg
  -y
  -hwaccel nvdec
  -hwaccel_output_format cuda
  -i gifInputPath
  -threads 1
  -filter_threads 1
  -c:v h264_nvenc
  -vf hwupload_cuda,scale_cuda=-2:320:240:format=yuv420p
  -gpu 0
   mp4VideoPath


  


  The above command generates an exit status 1.

  


  The following is the dmesg command log

  


  Converting mp4 videos to AVI videos I'm running the following command

  


  ffmpeg
-i videoInputPath
-vcodec rawvideo
-pix_fmt yuv420p
-acodec pcm_s16le
-ar 44100
-ac 2
-s 320x240
-r 4
-f avi
aviOutputVideoPath


  


  For GPU I tried :

  


  ffmpeg
 -y
 -hwaccel cuda
 -hwaccel_output_format cuda
 -i videoInputPath
 -threads 1
 -filter_threads 1
 -c:a pcm_s16le
 -ac 2
 -ar 44100
 -c:v h264_nvenc
 -vf hwupload_cudascale_cuda=-2:320:240:format=yuv420p
 -r 4
 -f avi
 -gpu 0
 aviOutputVideoPath


  


  The following is the dmseg output is log

  


  


  1. What should be the best command for converting the GIF into Mp4 and Mp4 into AVI based on CPU configuration using the GPU(Amazon Nvidia t4) for best performance, low CPU, and moderated GPU consumption ?

     


  


  2. What are the best suggestions to Process these content pieces concurrently using GPU ?

     


  


  


  Note : I'm using Golang to execute the FFmpeg commands.