Recherche avancée

Sur d’autres sites (12765)

• How to open a .sw file using libav library in c language ?

  29 août 2018, par volatile

  I created a .sw(16 bit pcm) file by passing an audio file. Now I am trying to get back the original audio(.mp3) by passing the .sw file as an input to the following file.

  How can I read the .sw file content so that I can get back the mp3 file. Below is the code,

  #include 
  
  #include 
  
  #include 
  
  
  
  #include <libavcodec></libavcodec>avcodec.h>
  
  #include <libavformat></libavformat>avformat.h>
  
  
  
  #include <libavutil></libavutil>channel_layout.h>
  
  #include <libavutil></libavutil>common.h>
  
  #include <libavutil></libavutil>frame.h>
  
  #include <libavutil></libavutil>samplefmt.h>
  
  
  
  /* check that a given sample format is supported by the encoder */
  
  static int check_sample_fmt(const AVCodec *codec, enum AVSampleFormat sample_fmt)
  
  {
  
      const enum AVSampleFormat *p = codec->sample_fmts;
  
  
  
      while (*p != AV_SAMPLE_FMT_NONE) {
  
          if (*p == sample_fmt)
  
              return 1; 
  
          p++;
  
      }
  
      return 0;
  
  }
  
  
  
  /* just pick the highest supported samplerate */
  
  static int select_sample_rate(const AVCodec *codec)
  
  {
  
      const int *p;
  
      int best_samplerate = 0;
  
  
  
      if (!codec->supported_samplerates)
  
          return 44100;
  
  
  
      p = codec->supported_samplerates;
  
      while (*p) {
  
          if (!best_samplerate || abs(44100 - *p) &lt; abs(44100 - best_samplerate))
  
              best_samplerate = *p;
  
          p++;
  
      }
  
      return best_samplerate;
  
  }
  
  
  
  /* select layout with the highest channel count */
  
  static int select_channel_layout(const AVCodec *codec)
  
  {
  
      const uint64_t *p;
  
      uint64_t best_ch_layout = 0;
  
      int best_nb_channels   = 0;
  
  
  
      if (!codec->channel_layouts)
  
          return AV_CH_LAYOUT_STEREO;
  
  
  
      p = codec->channel_layouts;
  
      while (*p) {
  
          int nb_channels = av_get_channel_layout_nb_channels(*p);
  
  
  
          if (nb_channels > best_nb_channels) {
  
              best_ch_layout    = *p;
  
              best_nb_channels = nb_channels;
  
          }
  
          p++;
  
      }
  
      return best_ch_layout;
  
  }
  
  
  
  static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt,
  
                     FILE *output)
  
  {
  
      int ret;
  
  
  
     /* send the frame for encoding */
  
     ret = avcodec_send_frame(ctx, frame);
  
     if (ret &lt; 0) {
  
         fprintf(stderr, "Error sending the frame to the encoder\n");
  
         exit(1);
  
     }
  
  
  
     /* read all the available output packets (in general there may be any
  
      * number of them */
  
     while (ret >= 0) {
  
         ret = avcodec_receive_packet(ctx, pkt);
  
         if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
  
             return;
  
         else if (ret &lt; 0) {
  
             fprintf(stderr, "Error encoding audio frame\n");
  
             exit(1);
  
         }
  
  
  
         fwrite(pkt->data, 1, pkt->size, output);
  
         av_packet_unref(pkt);
  
     }
  
  }
  
  
  
  int main(int argc, char **argv)
  
  {
  
     const char *filename;
  
     const AVCodec *codec;
  
     AVCodecContext *c= NULL;
  
     AVFrame *frame;
  
     AVPacket *pkt;
  
     int i, j, k, ret;
  
     FILE *f;
  
     uint16_t *samples;
  
     float t, tincr;
  
  
  
     av_register_all();
  
     avcodec_register_all();
  
  
  
     if (argc &lt;= 1) {
  
         fprintf(stderr, "Usage: %s <output file="file">\n", argv[0]);
  
         return 0;
  
     }
  
     filename = argv[1];
  
  
  
     /* find the MP2 encoder */
  
     codec = avcodec_find_encoder(AV_CODEC_ID_MP3);
  
     if (!codec) {
  
         fprintf(stderr, "Codec not found\n");
  
         exit(1);
  
     }
  
  
  
     c = avcodec_alloc_context3(codec);
  
     if (!c) {
  
         fprintf(stderr, "Could not allocate audio codec context\n");
  
         exit(1);
  
     }
  
  
  
     /* put sample parameters */
  
     c->bit_rate = 64000;
  
  
  
     /* check that the encoder supports s16 pcm input */
  
     c->sample_fmt = AV_SAMPLE_FMT_S16P;
  
     if (!check_sample_fmt(codec, c->sample_fmt)) {
  
         fprintf(stderr, "Encoder does not support sample format %s",
  
                 av_get_sample_fmt_name(c->sample_fmt));
  
         exit(1);
  
     }
  
  
  
     /* select other audio parameters supported by the encoder */
  
     c->sample_rate    = select_sample_rate(codec);
  
     c->channel_layout = select_channel_layout(codec);
  
     c->channels       = av_get_channel_layout_nb_channels(c->channel_layout);
  
  
  
     /* open it */
  
     if (avcodec_open2(c, codec, NULL) &lt; 0) {
  
         fprintf(stderr, "Could not open codec\n");
  
         exit(1);
  
     }
  
  
  
     f = fopen(filename, "wb");
  
     if (!f) {
  
         fprintf(stderr, "Could not open %s\n", filename);
  
         exit(1);
  
     }
  
  
  
     /* packet for holding encoded output */
  
     pkt = av_packet_alloc();
  
     if (!pkt) {
  
         fprintf(stderr, "could not allocate the packet\n");
  
         exit(1);
  
     }
  
  
  
     /* frame containing input raw audio */
  
     frame = av_frame_alloc();
  
     if (!frame) {
  
         fprintf(stderr, "Could not allocate audio frame\n");
  
         exit(1);
  
     }
  
  
  
     frame->nb_samples     = c->frame_size;
  
     frame->format         = c->sample_fmt;
  
     frame->channel_layout = c->channel_layout;
  
  
  
     /* allocate the data buffers */
  
     ret = av_frame_get_buffer(frame, 0);
  
     if (ret &lt; 0) {
  
         fprintf(stderr, "Could not allocate audio data buffers\n");
  
         exit(1);
  
     }
  
  
  
     /* encode a single tone sound */
  
     t = 0;
  
     tincr = 2 * M_PI * 440.0 / c->sample_rate;
  
     for (i = 0; i &lt; 200; i++) {
  
         /* make sure the frame is writable -- makes a copy if the encoder
  
          * kept a reference internally */
  
         ret = av_frame_make_writable(frame);
  
         if (ret &lt; 0)
  
             exit(1);
  
         samples = (uint16_t*)frame->data[0];
  
  
  
         for (j = 0; j &lt; c->frame_size; j++) {
  
             samples[2*j] = (int)(sin(t) * 10000);
  
  
  
             for (k = 1; k &lt; c->channels; k++)
  
                 samples[2*j + k] = samples[2*j];
  
             t += tincr;
  
         }
  
         encode(c, frame, pkt, f);
  
     }
  
  
  
     /* flush the encoder */
  
     encode(c, NULL, pkt, f);
  
  
  
     fclose(f);
  
  
  
     av_frame_free(&amp;frame);
  
     av_packet_free(&amp;pkt);
  
     avcodec_free_context(&amp;c);
  
  
  
     return 0;
  
  }
  
  </output>

  I just want to know, where and how the .sw file is reading in the above audio encoding code ?

• Does FFMPEG support AES128 Sample encryption required for Apple Fairplay DRM ?

  29 avril 2019, par Sathish Rao

  I need to encrypt an MPEG2 Transport stream with Sample AES encryption compatible with Fairplay DRM. Does FFMPEG support Sample AES encryption (just like how it supports Common Encryption for Widevine and Playready DRMs) ?

• Change wave file frequency while retaining sample rate bash

  28 janvier 2019, par q1w2e3r4t5y6

  I am wondering how to change a wave file’s frequency while its retaining sample rate. I have tried :

  ffmpeg -i $1 -filter:a "asetrate=$2" -y $3

  The second argument here changes drastically, by the way. However, this changes the sample rate, making it impossible to concatenate with sox. How can I make the above code so that it changes the frequency while still having the same sample rate ? Thanks !