Recherche avancée

Sur d’autres sites (7077)

• How we can open /dev/video0 or any v4l2 node with ffmpeg for capture raw frames and encode it in jpeg format ?

  19 mars 2016, par satinder

  I am new in video domain . I am working now on ffmpeg , I use ffmpeg command line but there is very big issue and challenge for use ffmpeg in my own c code .So I read some tutorials like dranger.com etc . But I am not able to capture v4l2 or my laptop /dev/video0 node . I want capture raw video stream and overlay it with some text and then compress it in jpeg format . I have a little idea and that is in following code that code is working for ant .mp4 format or encoded file but not work on /dev/video0 node format . so please any one help me . Thanks in advance !!

  please see following code snapshot that is a tutorial1.c from dranger.com :

  #include <libavcodec></libavcodec>avcodec.h>
  
  #include <libavformat></libavformat>avformat.h>
  
  #include <libswscale></libswscale>swscale.h>
  
  
  
  #include 
  
  
  
  void SaveFrame(AVFrame *pFrame, int width, int height, int iFrame) {
  
    FILE *pFile;
  
    char szFilename[32];
  
    int  y;
  
  
  
    // Open file
  
    sprintf(szFilename, "frame%d.ppm", iFrame);
  
    pFile=fopen(szFilename, "wb");
  
    if(pFile==NULL)
  
      return;
  
  
  
    // Write header
  
    fprintf(pFile, "P6\n%d %d\n255\n", width, height);
  
  
  
    // Write pixel data
  
    for(y=0; ydata[0]+y*pFrame->linesize[0], 1, width*3, pFile);
  
  
  
    // Close file
  
    fclose(pFile);
  
  }
  
  
  
  int main(int argc, char *argv[]) {
  
    AVFormatContext *pFormatCtx = NULL;
  
    int             i, videoStream;
  
    AVCodecContext  *pCodecCtx = NULL;
  
    AVCodec         *pCodec = NULL;
  
    AVFrame         *pFrame = NULL; 
  
    AVFrame         *pFrameRGB = NULL;
  
    AVPacket        packet;
  
    int             frameFinished;
  
    int             numBytes;
  
    uint8_t         *buffer = NULL;
  
  
  
    AVDictionary    *optionsDict = NULL;
  
    struct SwsContext      *sws_ctx = NULL;
  
  
  
    if(argc &lt; 2) {
  
      printf("Please provide a movie file\n");
  
      return -1;
  
    }
  
    // Register all formats and codecs
  
    av_register_all();
  
  
  
    // Open video file
  
    if(avformat_open_input(&amp;pFormatCtx, argv[1], NULL, NULL)!=0)
  
      return -1; // Couldn't open file
  
  
  
    // Retrieve stream information
  
    if(avformat_find_stream_info(pFormatCtx, NULL)&lt;0)
  
      return -1; // Couldn't find stream information
  
  
  
    // Dump information about file onto standard error
  
    av_dump_format(pFormatCtx, 0, argv[1], 0);
  
  
  
    // Find the first video stream
  
    videoStream=-1;
  
    for(i=0; inb_streams; i++)
  
      if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO) {
  
        videoStream=i;
  
        break;
  
      }
  
    if(videoStream==-1)
  
      return -1; // Didn't find a video stream
  
  
  
    // Get a pointer to the codec context for the video stream
  
    pCodecCtx=pFormatCtx->streams[videoStream]->codec;
  
  
  
    // Find the decoder for the video stream
  
    pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
  
    if(pCodec==NULL) {
  
      fprintf(stderr, "Unsupported codec!\n");
  
      return -1; // Codec not found
  
    }
  
    // Open codec
  
    if(avcodec_open2(pCodecCtx, pCodec, &amp;optionsDict)&lt;0)
  
      return -1; // Could not open codec
  
  
  
    // Allocate video frame
  
    pFrame=av_frame_alloc();
  
  
  
    // Allocate an AVFrame structure
  
    pFrameRGB=av_frame_alloc();
  
    if(pFrameRGB==NULL)
  
      return -1;
  
  
  
    // Determine required buffer size and allocate buffer
  
    numBytes=avpicture_get_size(AV_PIX_FMT_RGB24, pCodecCtx->width,
  
                    pCodecCtx->height);
  
    buffer=(uint8_t *)av_malloc(numBytes*sizeof(uint8_t));
  
  
  
    sws_ctx =
  
      sws_getContext
  
      (
  
          pCodecCtx->width,
  
          pCodecCtx->height,
  
          pCodecCtx->pix_fmt,
  
          pCodecCtx->width,
  
          pCodecCtx->height,
  
          AV_PIX_FMT_RGB24,
  
          SWS_BILINEAR,
  
          NULL,
  
          NULL,
  
          NULL
  
      );
  
  
  
    // Assign appropriate parts of buffer to image planes in pFrameRGB
  
    // Note that pFrameRGB is an AVFrame, but AVFrame is a superset
  
    // of AVPicture
  
    avpicture_fill((AVPicture *)pFrameRGB, buffer, AV_PIX_FMT_RGB24,
  
           pCodecCtx->width, pCodecCtx->height);
  
  
  
    // Read frames and save first five frames to disk
  
    i=0;
  
    while(av_read_frame(pFormatCtx, &amp;packet)>=0) {
  
      // Is this a packet from the video stream?
  
      if(packet.stream_index==videoStream) {
  
        // Decode video frame
  
        avcodec_decode_video2(pCodecCtx, pFrame, &amp;frameFinished, 
  
                 &amp;packet);
  
  
  
        // Did we get a video frame?
  
        if(frameFinished) {
  
      // Convert the image from its native format to RGB
  
          sws_scale
  
          (
  
              sws_ctx,
  
              (uint8_t const * const *)pFrame->data,
  
              pFrame->linesize,
  
              0,
  
              pCodecCtx->height,
  
              pFrameRGB->data,
  
              pFrameRGB->linesize
  
          );
  
  
  
      // Save the frame to disk
  
      if(++i&lt;=5)
  
        SaveFrame(pFrameRGB, pCodecCtx->width, pCodecCtx->height, 
  
              i);
  
        }
  
      }
  
  
  
      // Free the packet that was allocated by av_read_frame
  
      av_free_packet(&amp;packet);
  
    }
  
  
  
    // Free the RGB image
  
    av_free(buffer);
  
    av_free(pFrameRGB);
  
  
  
    // Free the YUV frame
  
    av_free(pFrame);
  
  
  
    // Close the codec
  
    avcodec_close(pCodecCtx);
  
  
  
    // Close the video file
  
    avformat_close_input(&amp;pFormatCtx);
  
  
  
    return 0;
  
  }

• Connection reset by peer, ffmpeg

  18 août 2016, par Johnnylin

  I have tried several ways and done a lot of search. I just cannot figure out why this happens.

  This is the thread. I did almost the same thing.

  https://ffmpeg.org/pipermail/libav-user/2014-March/006356.html

  When you use ffmpeg command line together with ffserver, it works. But when you use sample code. It just does not work.

  What is missing ?

  EDIT

  Hi all,

  I took the muxing.c example and modified it in order to send a stream
  through a network socket. I only made few modifications :

  main function now looks like :

  int main()
  
  {
  
      AVOutputFormat *fmt;
  
      AVFormatContext *oc;
  
      AVStream *audio_st, *video_st;
  
      AVCodec *audio_codec, *video_codec;
  
      double audio_time, video_time;
  
      int flush, ret;
  
  
  
      /* Initialize libavcodec, and register all codecs and formats. */
  
      av_register_all();
  
      avformat_network_init();
  
  
  
      /* allocate the output media context */
  
      avformat_alloc_output_context2(&oc, NULL, "mpegts", NULL);
  
      if (!oc) {
  
          printf("Could not deduce output format from file extension: using
  
  MPEG.\n");
  
          avformat_alloc_output_context2(&oc, NULL, "mpegts", NULL);
  
      }
  
      if (!oc)
  
          return 1;
  
  
  
      fmt = oc->oformat;
  
      //fmt->video_codec = AV_CODEC_ID_MPEG2VIDEO;
  
      //fmt->audio_codec = AV_CODEC_ID_MP3;
  
  
  
      /* Add the audio and video streams using the default format codecs
  
       * and initialize the codecs. */
  
      video_st = NULL;
  
      audio_st = NULL;
  
  
  
      if (fmt->video_codec != AV_CODEC_ID_NONE)
  
          video_st = add_stream(oc, &video_codec, fmt->video_codec);
  
      if (fmt->audio_codec != AV_CODEC_ID_NONE)
  
          audio_st = add_stream(oc, &audio_codec, fmt->audio_codec);
  
  
  
      /* Now that all the parameters are set, we can open the audio and
  
       * video codecs and allocate the necessary encode buffers. */
  
      if (video_st)
  
          open_video(oc, video_codec, video_st);
  
      if (audio_st)
  
          open_audio(oc, audio_codec, audio_st);
  
  
  
     av_dump_format(oc, 0, "http://localhost:8090/feed1.ffm", 1);
  
  
  
      /* open the output file, if needed */
  
      if (!(fmt->flags & AVFMT_NOFILE)) {
  
          ret = avio_open(&oc->pb, "http://localhost:8090/feed1.ffm",
  
  AVIO_FLAG_WRITE);
  
          if (ret < 0) {
  
              fprintf(stderr, "Could not open '%s': %s\n", "
  
  http://localhost:8090/feed1.ffm",
  
                      av_err2str(ret));
  
              return 1;
  
          }
  
      }
  
  
  
      /* Write the stream header, if any. */
  
      ret = avformat_write_header(oc, NULL);
  
      if (ret < 0) {
  
          fprintf(stderr, "Error occurred when opening output file: %s\n",
  
                  av_err2str(ret));
  
          return 1;
  
      }
  
  
  
      flush = 0;
  
      while ((video_st && !video_is_eof) || (audio_st && !audio_is_eof)) {
  
          /* Compute current audio and video time. */
  
          audio_time = (audio_st && !audio_is_eof) ? audio_st->pts.val *
  
  av_q2d(audio_st->time_base) : INFINITY;
  
          video_time = (video_st && !video_is_eof) ? video_st->pts.val *
  
  av_q2d(video_st->time_base) : INFINITY;
  
  
  
          if (!flush &&
  
              (!audio_st || audio_time >= STREAM_DURATION) &&
  
              (!video_st || video_time >= STREAM_DURATION)) {
  
              flush = 1;
  
          }
  
  
  
          /* write interleaved audio and video frames */
  
          if (audio_st && !audio_is_eof && audio_time <= video_time) {
  
              write_audio_frame(oc, audio_st, flush);
  
          } else if (video_st && !video_is_eof && video_time < audio_time) {
  
              write_video_frame(oc, video_st, flush);
  
          }
  
      }
  
  
  
      /* Write the trailer, if any. The trailer must be written before you
  
       * close the CodecContexts open when you wrote the header; otherwise
  
       * av_write_trailer() may try to use memory that was freed on
  
       * av_codec_close(). */
  
      av_write_trailer(oc);
  
  
  
      /* Close each codec. */
  
      if (video_st)
  
          close_video(oc, video_st);
  
      if (audio_st)
  
          close_audio(oc, audio_st);
  
  
  
      if (!(fmt->flags & AVFMT_NOFILE))
  
          /* Close the output file. */
  
          avio_close(oc->pb);
  
  
  
      /* free the stream */
  
      avformat_free_context(oc);
  
  
  
      return 0;
  
  }  

  and, in order to avoid a warning about channel layout not specified, I
  added :

  c->channel_layout = av_get_default_channel_layout(c->channels);
  
  
  
  in function AVStream *add_stream(AVFormatContext *oc, AVCodec **codec,
  
                          enum AVCodecID codec_id)

  just under the row c->channels = 2 ;

  I also raised a ffserver with the following configuration (showing only
  feed lines) :

  <feed>
  
          File /tmp/feed1.ffm
  
          FileMaxSize 1GB
  
          ACL allow 127.0.0.1
  
          ACL allow 192.168.0.0 192.168.255.255
  
  </feed>

  ffserver is working fine if I feed it with a ffmpeg commandline, e.g :

  ffmpeg -r 25 -i movie.mp4 -acodec libfdk_aac  -ab 128k -vcodec libx264 -fpre libx264-fast.ffpreset http://localhost:8090/feed1.ffm

  But with my example, I can write only few frames and after that may muxing
  modified program ends with :

  Error while writing video frame : Connection reset by peer

  I tried also different codecs (h264) and format (flv), turning out in a
  different number of frames written, but eventually I got the same error
  above.

  ffserver do not reports errors at all, only write:
  
  Tue Mar  4 12:55:10 2014 127.0.0.1 - - [POST] "/feed1.ffm HTTP/1.1" 200 4096
  
  confirming that the communication socket was open

  What am i missing ??

  Thanks

• libav : encoding/decoding error : get_buffer() failed

  17 août 2015, par MarkB

  I am trying to edit the given Audio encoding/decoding examples of the libav located in libav-11.4/doc/examples/avcodec.c.

  I simply want to encode a .wav file into aac and then decode back to .wav

  But in the decoding step I allways get the following error :

  [aac @ 0x...] get_buffer() failed
  
  Error while decoding

  The Edited example code :

  #include 
  
  #include 
  
  #include 
  
  
  
  #ifdef HAVE_AV_CONFIG_H
  
  #undef HAVE_AV_CONFIG_H
  
  #endif
  
  
  
  #include "libavcodec/avcodec.h"
  
  #include "libavutil/channel_layout.h"
  
  #include "libavutil/common.h"
  
  #include "libavutil/imgutils.h"
  
  #include "libavutil/mathematics.h"
  
  #include "libavutil/samplefmt.h"
  
  
  
  
  
  #define INBUF_SIZE 4096
  
  #define AUDIO_INBUF_SIZE 20480
  
  #define AUDIO_REFILL_THRESH 4096
  
  
  
  /* check that a given sample format is supported by the encoder */
  
  static int check_sample_fmt(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(AVCodec *codec)
  
  {
  
      const int *p;
  
      int best_samplerate = 0;
  
  
  
      if (!codec->supported_samplerates)
  
          return 44100;
  
  
  
      p = codec->supported_samplerates;
  
      while (*p) {
  
          best_samplerate = FFMAX(*p, best_samplerate);
  
          p++;
  
      }
  
      return best_samplerate;
  
  }
  
  
  
  /* select layout with the highest channel count */
  
  static int select_channel_layout(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;
  
  }
  
  
  
  /*
  
   * Audio encoding example
  
   */
  
  static void audio_encode_example(const char *outfilename, const char *filename)
  
  {
  
      AVCodec *codec;
  
      AVCodecContext *c= NULL;
  
      AVFrame *frame;
  
      AVPacket pkt;
  
      int i, j, k, ret, got_output;
  
      int buffer_size;
  
      FILE *f, *outfile;
  
      uint16_t *samples;
  
      float t, tincr;
  
  
  
      printf("Audio encoding\n");
  
  
  
      /* find the MP2 encoder */
  
      codec = avcodec_find_encoder(AV_CODEC_ID_AAC);
  
      if (!codec) {
  
          fprintf(stderr, "codec not found\n");
  
          exit(1);
  
      }
  
  
  
      c = avcodec_alloc_context3(codec);
  
  
  
      /* put sample parameters */
  
      c->bit_rate = 64000;
  
  
  
      /* check that the encoder supports s16 pcm input */
  
      c->sample_fmt = AV_SAMPLE_FMT_S16;
  
      if (!check_sample_fmt(codec, c->sample_fmt)) {
  
          fprintf(stderr, "encoder does not support %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) < 0) {
  
          fprintf(stderr, "could not open codec\n");
  
          exit(1);
  
      }
  
  
  
      f = fopen(filename, "rb");
  
      if (!f) {
  
          fprintf(stderr, "could not open %s\n", filename);
  
          exit(1);
  
      }
  
  
  
      outfile = fopen(outfilename, "wb");
  
      if (!outfile) {
  
          fprintf(stderr, "could not open %s\n", filename);
  
          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;
  
  
  
      /* the codec gives us the frame size, in samples,
  
       * we calculate the size of the samples buffer in bytes */
  
      buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,
  
                                               c->sample_fmt, 0);
  
      samples = av_malloc(buffer_size);
  
      if (!samples) {
  
          fprintf(stderr, "could not allocate %d bytes for samples buffer\n",
  
                  buffer_size);
  
          exit(1);
  
      }
  
      /* setup the data pointers in the AVFrame */
  
      ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
  
                                     (const uint8_t*)samples, buffer_size, 0);
  
      if (ret < 0) {
  
          fprintf(stderr, "could not setup audio frame\n");
  
          exit(1);
  
      }
  
  
  
      /* encode a single tone sound */
  
      t = 0;
  
      tincr = 2 * M_PI * 440.0 / c->sample_rate;
  
      for(i=0;i<200;i++) {
  
          av_init_packet(&pkt);
  
          pkt.data = NULL; // packet data will be allocated by the encoder
  
          pkt.size = 0;
  
  
  
          for (j = 0; j < c->frame_size; j++) {
  
              samples[2*j] = (int)(sin(t) * 10000);
  
  
  
              for (k = 1; k < c->channels; k++)
  
                  samples[2*j + k] = samples[2*j];
  
              t += tincr;
  
          }
  
          /* encode the samples */
  
          ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
  
          if (ret < 0) {
  
              fprintf(stderr, "error encoding audio frame\n");
  
              exit(1);
  
          }
  
          if (got_output) {
  
              fwrite(pkt.data, 1, pkt.size, outfile);
  
              av_free_packet(&pkt);
  
          }
  
      }
  
      fclose(f);
  
      fclose(outfile);
  
  
  
      av_freep(&samples);
  
      av_frame_free(&frame);
  
      avcodec_close(c);
  
      av_free(c);
  
  }
  
  
  
  /*
  
   * Audio decoding.
  
   */
  
  static void audio_decode_example(const char *outfilename, const char *filename)
  
  {
  
      AVCodec *codec;
  
      AVCodecContext *c= NULL;
  
      int len;
  
      FILE *f, *outfile;
  
      uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
  
      AVPacket avpkt;
  
      AVFrame *decoded_frame = NULL;
  
  
  
      av_init_packet(&avpkt);
  
  
  
      printf("Audio decoding\n");
  
  
  
      /* find the mpeg audio decoder */
  
      codec = avcodec_find_decoder(AV_CODEC_ID_AAC);
  
      if (!codec) {
  
          fprintf(stderr, "codec not found\n");
  
          exit(1);
  
      }
  
  
  
      c = avcodec_alloc_context3(codec);
  
  
  
      /* open it */
  
      if (avcodec_open2(c, codec, NULL) < 0) {
  
          fprintf(stderr, "could not open codec\n");
  
          exit(1);
  
      }
  
  
  
      f = fopen(filename, "rb");
  
      if (!f) {
  
          fprintf(stderr, "could not open %s\n", filename);
  
          exit(1);
  
      }
  
      outfile = fopen(outfilename, "wb");
  
      if (!outfile) {
  
          av_free(c);
  
          exit(1);
  
      }
  
  
  
      /* decode until eof */
  
      avpkt.data = inbuf;
  
      avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
  
  
  
      while (avpkt.size > 0) {
  
          int got_frame = 0;
  
  
  
          if (!decoded_frame) {
  
              if (!(decoded_frame = av_frame_alloc())) {
  
                  fprintf(stderr, "out of memory\n");
  
                  exit(1);
  
              }
  
          }
  
  
  
          len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
  
          if (len < 0) {
  
              fprintf(stderr, "Error while decoding\n");
  
              exit(1);
  
          }
  
          if (got_frame) {
  
              /* if a frame has been decoded, output it */
  
              int data_size = av_samples_get_buffer_size(NULL, c->channels,
  
                                                         decoded_frame->nb_samples,
  
                                                         c->sample_fmt, 1);
  
              fwrite(decoded_frame->data[0], 1, data_size, outfile);
  
          }
  
          avpkt.size -= len;
  
          avpkt.data += len;
  
          if (avpkt.size < AUDIO_REFILL_THRESH) {
  
              /* Refill the input buffer, to avoid trying to decode
  
               * incomplete frames. Instead of this, one could also use
  
               * a parser, or use a proper container format through
  
               * libavformat. */
  
              memmove(inbuf, avpkt.data, avpkt.size);
  
              avpkt.data = inbuf;
  
              len = fread(avpkt.data + avpkt.size, 1,
  
                          AUDIO_INBUF_SIZE - avpkt.size, f);
  
              if (len > 0)
  
                  avpkt.size += len;
  
          }
  
      }
  
  
  
      fclose(outfile);
  
      fclose(f);
  
  
  
      avcodec_close(c);
  
      av_free(c);
  
      av_frame_free(&decoded_frame);
  
  }
  
  
  
  int main(int argc, char **argv)
  
  {
  
      const char *filename;
  
  
  
      /* register all the codecs */
  
      avcodec_register_all();
  
  
  
  
  
     filename = argv[1];
  
  
  
  
  
      audio_encode_example("test.aac", filename);
  
      audio_decode_example("out.wav", "test.aac");
  
  
  
      return 0;
  
  }

  EDIT :

  #include 
  
  #include 
  
  #include 
  
  
  
  #ifdef HAVE_AV_CONFIG_H
  
  #undef HAVE_AV_CONFIG_H
  
  #endif
  
  
  
  #include "libavcodec/avcodec.h"
  
  #include "libavutil/channel_layout.h"
  
  #include "libavutil/common.h"
  
  #include "libavutil/imgutils.h"
  
  #include "libavutil/mathematics.h"
  
  #include "libavutil/samplefmt.h"
  
  
  
  #include "libavformat/avformat.h"
  
  
  
  
  
  #define INBUF_SIZE 4096
  
  #define AUDIO_INBUF_SIZE 20480
  
  #define AUDIO_REFILL_THRESH 4096
  
  
  
  /* check that a given sample format is supported by the encoder */
  
  static int check_sample_fmt(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(AVCodec *codec)
  
  {
  
      const int *p;
  
      int best_samplerate = 0;
  
  
  
      if (!codec->supported_samplerates)
  
          return 44100;
  
  
  
      p = codec->supported_samplerates;
  
      while (*p) {
  
          best_samplerate = FFMAX(*p, best_samplerate);
  
          p++;
  
      }
  
      return best_samplerate;
  
  }
  
  
  
  /* select layout with the highest channel count */
  
  static int select_channel_layout(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;
  
  }
  
  
  
  /*
  
   * Audio encoding example
  
   */
  
  static void audio_encode_example(const char *outfilename, const char *filename)
  
  {
  
      AVCodec *codec;
  
      AVCodecContext *c= NULL;
  
      AVFrame *frame;
  
      AVPacket pkt;
  
      int i, j, k, ret, got_output;
  
      int buffer_size;
  
      FILE *f, *outfile;
  
      uint16_t *samples;
  
      float t, tincr;
  
  
  
      printf("Audio encoding\n");
  
  
  
      /* find the MP2 encoder */
  
      codec = avcodec_find_encoder(AV_CODEC_ID_AAC);
  
      if (!codec) {
  
          fprintf(stderr, "codec not found\n");
  
          exit(1);
  
      }
  
  
  
      c = avcodec_alloc_context3(codec);
  
  
  
      /* put sample parameters */
  
      c->bit_rate = 64000;
  
  
  
      /* check that the encoder supports s16 pcm input */
  
      c->sample_fmt = AV_SAMPLE_FMT_S16;
  
      if (!check_sample_fmt(codec, c->sample_fmt)) {
  
          fprintf(stderr, "encoder does not support %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) < 0) {
  
          fprintf(stderr, "could not open codec\n");
  
          exit(1);
  
      }
  
  
  
      f = fopen(filename, "rb");
  
      if (!f) {
  
          fprintf(stderr, "could not open %s\n", filename);
  
          exit(1);
  
      }
  
  
  
      outfile = fopen(outfilename, "wb");
  
      if (!outfile) {
  
          fprintf(stderr, "could not open %s\n", filename);
  
          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;
  
  
  
      /* the codec gives us the frame size, in samples,
  
       * we calculate the size of the samples buffer in bytes */
  
      buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,
  
                                               c->sample_fmt, 0);
  
      samples = av_malloc(buffer_size);
  
      if (!samples) {
  
          fprintf(stderr, "could not allocate %d bytes for samples buffer\n",
  
                  buffer_size);
  
          exit(1);
  
      }
  
      /* setup the data pointers in the AVFrame */
  
      ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
  
                                     (const uint8_t*)samples, buffer_size, 0);
  
      if (ret < 0) {
  
          fprintf(stderr, "could not setup audio frame\n");
  
          exit(1);
  
      }
  
  
  
      /* encode a single tone sound */
  
      t = 0;
  
      tincr = 2 * M_PI * 440.0 / c->sample_rate;
  
      for(i=0;i<200;i++) {
  
          av_init_packet(&pkt);
  
          pkt.data = NULL; // packet data will be allocated by the encoder
  
          pkt.size = 0;
  
  
  
          for (j = 0; j < c->frame_size; j++) {
  
              samples[2*j] = (int)(sin(t) * 10000);
  
  
  
              for (k = 1; k < c->channels; k++)
  
                  samples[2*j + k] = samples[2*j];
  
              t += tincr;
  
          }
  
          /* encode the samples */
  
          ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
  
          if (ret < 0) {
  
              fprintf(stderr, "error encoding audio frame\n");
  
              exit(1);
  
          }
  
          if (got_output) {
  
              fwrite(pkt.data, 1, pkt.size, outfile);
  
              av_free_packet(&pkt);
  
          }
  
      }
  
      fclose(f);
  
      fclose(outfile);
  
  
  
      av_freep(&samples);
  
      av_frame_free(&frame);
  
      avcodec_close(c);
  
      av_free(c);
  
  }
  
  
  
  /*
  
   * Audio decoding.
  
   */
  
  static void audio_decode_example(const char *outfilename, const char *filename)
  
  {
  
      AVCodec *codec;
  
      AVCodecContext *c= NULL;
  
      int len;
  
      FILE *f, *outfile;
  
      uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
  
      AVPacket avpkt;
  
      AVFrame *decoded_frame = NULL;
  
  
  
      av_init_packet(&avpkt);
  
  
  
      printf("Audio decoding\n");
  
  
  
      /* find the mpeg audio decoder */
  
      codec = avcodec_find_decoder(AV_CODEC_ID_AAC);
  
      if (!codec) {
  
          fprintf(stderr, "codec not found\n");
  
          exit(1);
  
      }
  
  
  
      c = avcodec_alloc_context3(codec);
  
  
  
      /* open it */
  
      if (avcodec_open2(c, codec, NULL) < 0) {
  
          fprintf(stderr, "could not open codec\n");
  
          exit(1);
  
      }
  
  
  
      /*
  
      f = fopen(filename, "rb");
  
      if (!f) {
  
          fprintf(stderr, "could not open %s\n", filename);
  
          exit(1);
  
      }
  
      */
  
  
  
  
  
      AVFormatContext *s = avformat_alloc_context();
  
      int ret = avformat_open_input(&s, filename, NULL, NULL);
  
      if (ret != 0)
  
      {
  
          abort();
  
      }
  
  
  
      // Retrieve stream information
  
      printf("sdfsdf\n");
  
  
  
      if(avformat_find_stream_info(s, NULL)<0)
  
      {
  
          printf("Could not find stream info");// Couldn't find stream information
  
      }
  
      // Dump information about file into standard error
  
      av_dump_format(s, 0, filename, 0);
  
  
  
  
  
      outfile = fopen(outfilename, "wb");
  
      if (!outfile) {
  
          av_free(c);
  
          exit(1);
  
      }
  
  
  
      /* decode until eof */
  
      //avpkt.data = inbuf;
  
      //avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
  
  
  
      int read_ok = av_read_frame(s,&avpkt);
  
  
  
      while (read_ok) 
  
      {
  
  read_ok = av_read_frame(s,&avpkt);
  
          int got_frame = 0;
  
  
  
          if (!decoded_frame) {
  
              if (!(decoded_frame = av_frame_alloc())) {
  
                  fprintf(stderr, "out of memory\n");
  
                  exit(1);
  
              }
  
          }
  
  
  
          len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
  
          if (len < 0) {
  
              fprintf(stderr, "Error while decoding\n");
  
              exit(1);
  
          }
  
          if (got_frame) {
  
              /* if a frame has been decoded, output it */
  
              int data_size = av_samples_get_buffer_size(NULL, c->channels,
  
                                                         decoded_frame->nb_samples,
  
                                                         c->sample_fmt, 1);
  
              fwrite(decoded_frame->data[0], 1, data_size, outfile);
  
          }
  
  
  
          /*
  
          avpkt.size -= len;
  
          avpkt.data += len;
  
          if (avpkt.size < AUDIO_REFILL_THRESH) {
  
  
  
              memmove(inbuf, avpkt.data, avpkt.size);
  
              avpkt.data = inbuf;
  
  
  
              len = fread(avpkt.data + avpkt.size, 1,
  
                          AUDIO_INBUF_SIZE - avpkt.size, f);
  
              if (len > 0)
  
                  avpkt.size += len;
  
          }*/
  
      }
  
  
  
      fclose(outfile);
  
     // fclose(f);
  
  
  
      avcodec_close(c);
  
      av_free(c);
  
      av_frame_free(&decoded_frame);
  
  }
  
  
  
  int main(int argc, char **argv)
  
  {
  
      const char *filename;
  
  
  
      /* register all the codecs */
  
      avcodec_register_all();
  
      av_register_all();
  
  
  
  
  
  
  
  
  
     filename = argv[1];
  
  
  
  
  
      audio_encode_example("test.aac", filename);
  
      audio_decode_example("out.wav", "test.aac");
  
  
  
      return 0;
  
  }