[Libav-user] Bus Error in Audio Encoding

[Ramana Jajula]

Hi, I am trying to get back the original audio mp3 file by audio encoding.
I have got the .bin file by doing the audio decoding(.mp3 file) first. Now
I want to get back the .mp3 file by doing audio encoding. Here is the file
for audio decoding my_audio_decoding.c
<https://codepad.co/snippet/NeHLFtzR>.(took
2 args input file and output file). Now I am doing audio encoding, file
below

my_audio_encoding.c

    #include <stdint.h>
    #include <stdio.h>
    #include <stdlib.h>

    #include <libavcodec/avcodec.h>
    #include <libavformat/avformat.h>

    #include <libavutil/channel_layout.h>
    #include <libavutil/common.h>
    #include <libavutil/frame.h>
    #include <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) < 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 < 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 < 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 <= 1) {
           fprintf(stderr, "Usage: %s <output 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) < 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 < 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 < 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 < 0)
               exit(1);
           samples = (uint16_t*)frame->data[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(c, frame, pkt, f);
       }

       /* flush the encoder */
       encode(c, NULL, pkt, f);

       fclose(f);

       av_frame_free(&frame);
       av_packet_free(&pkt);
       avcodec_free_context(&c);

       return 0;
   }

While I am doing this, I am keep getting bus error, please help me with
this.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://ffmpeg.org/pipermail/libav-user/attachments/20180829/fb4a9d3a/attachment.html>