Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2010 Nicolas George
  3.  * Copyright (c) 2011 Stefano Sabatini
  4.  * Copyright (c) 2012 Clément Bœsch
  5.  *
  6.  * Permission is hereby granted, free of charge, to any person obtaining a copy
  7.  * of this software and associated documentation files (the "Software"), to deal
  8.  * in the Software without restriction, including without limitation the rights
  9.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10.  * copies of the Software, and to permit persons to whom the Software is
  11.  * furnished to do so, subject to the following conditions:
  12.  *
  13.  * The above copyright notice and this permission notice shall be included in
  14.  * all copies or substantial portions of the Software.
  15.  *
  16.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22.  * THE SOFTWARE.
  23.  */
  24.  
  25. /**
  26.  * @file
  27.  * API example for audio decoding and filtering
  28.  * @example doc/examples/filtering_audio.c
  29.  */
  30.  
  31. #include <unistd.h>
  32.  
  33. #include <libavcodec/avcodec.h>
  34. #include <libavformat/avformat.h>
  35. #include <libavfilter/avfiltergraph.h>
  36. #include <libavfilter/avcodec.h>
  37. #include <libavfilter/buffersink.h>
  38. #include <libavfilter/buffersrc.h>
  39. #include <libavutil/opt.h>
  40.  
  41. static const char *filter_descr = "aresample=8000,aformat=sample_fmts=s16:channel_layouts=mono";
  42. static const char *player       = "ffplay -f s16le -ar 8000 -ac 1 -";
  43.  
  44. static AVFormatContext *fmt_ctx;
  45. static AVCodecContext *dec_ctx;
  46. AVFilterContext *buffersink_ctx;
  47. AVFilterContext *buffersrc_ctx;
  48. AVFilterGraph *filter_graph;
  49. static int audio_stream_index = -1;
  50.  
  51. static int open_input_file(const char *filename)
  52. {
  53.     int ret;
  54.     AVCodec *dec;
  55.  
  56.     if ((ret = avformat_open_input(&fmt_ctx, filename, NULL, NULL)) < 0) {
  57.         av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
  58.         return ret;
  59.     }
  60.  
  61.     if ((ret = avformat_find_stream_info(fmt_ctx, NULL)) < 0) {
  62.         av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
  63.         return ret;
  64.     }
  65.  
  66.     /* select the audio stream */
  67.     ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, &dec, 0);
  68.     if (ret < 0) {
  69.         av_log(NULL, AV_LOG_ERROR, "Cannot find a audio stream in the input file\n");
  70.         return ret;
  71.     }
  72.     audio_stream_index = ret;
  73.     dec_ctx = fmt_ctx->streams[audio_stream_index]->codec;
  74.     av_opt_set_int(dec_ctx, "refcounted_frames", 1, 0);
  75.  
  76.     /* init the audio decoder */
  77.     if ((ret = avcodec_open2(dec_ctx, dec, NULL)) < 0) {
  78.         av_log(NULL, AV_LOG_ERROR, "Cannot open audio decoder\n");
  79.         return ret;
  80.     }
  81.  
  82.     return 0;
  83. }
  84.  
  85. static int init_filters(const char *filters_descr)
  86. {
  87.     char args[512];
  88.     int ret;
  89.     AVFilter *abuffersrc  = avfilter_get_by_name("abuffer");
  90.     AVFilter *abuffersink = avfilter_get_by_name("abuffersink");
  91.     AVFilterInOut *outputs = avfilter_inout_alloc();
  92.     AVFilterInOut *inputs  = avfilter_inout_alloc();
  93.     static const enum AVSampleFormat out_sample_fmts[] = { AV_SAMPLE_FMT_S16, -1 };
  94.     static const int64_t out_channel_layouts[] = { AV_CH_LAYOUT_MONO, -1 };
  95.     static const int out_sample_rates[] = { 8000, -1 };
  96.     const AVFilterLink *outlink;
  97.     AVRational time_base = fmt_ctx->streams[audio_stream_index]->time_base;
  98.  
  99.     filter_graph = avfilter_graph_alloc();
  100.  
  101.     /* buffer audio source: the decoded frames from the decoder will be inserted here. */
  102.     if (!dec_ctx->channel_layout)
  103.         dec_ctx->channel_layout = av_get_default_channel_layout(dec_ctx->channels);
  104.     snprintf(args, sizeof(args),
  105.             "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,
  106.              time_base.num, time_base.den, dec_ctx->sample_rate,
  107.              av_get_sample_fmt_name(dec_ctx->sample_fmt), dec_ctx->channel_layout);
  108.     ret = avfilter_graph_create_filter(&buffersrc_ctx, abuffersrc, "in",
  109.                                        args, NULL, filter_graph);
  110.     if (ret < 0) {
  111.         av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");
  112.         return ret;
  113.     }
  114.  
  115.     /* buffer audio sink: to terminate the filter chain. */
  116.     ret = avfilter_graph_create_filter(&buffersink_ctx, abuffersink, "out",
  117.                                        NULL, NULL, filter_graph);
  118.     if (ret < 0) {
  119.         av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");
  120.         return ret;
  121.     }
  122.  
  123.     ret = av_opt_set_int_list(buffersink_ctx, "sample_fmts", out_sample_fmts, -1,
  124.                               AV_OPT_SEARCH_CHILDREN);
  125.     if (ret < 0) {
  126.         av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
  127.         return ret;
  128.     }
  129.  
  130.     ret = av_opt_set_int_list(buffersink_ctx, "channel_layouts", out_channel_layouts, -1,
  131.                               AV_OPT_SEARCH_CHILDREN);
  132.     if (ret < 0) {
  133.         av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
  134.         return ret;
  135.     }
  136.  
  137.     ret = av_opt_set_int_list(buffersink_ctx, "sample_rates", out_sample_rates, -1,
  138.                               AV_OPT_SEARCH_CHILDREN);
  139.     if (ret < 0) {
  140.         av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
  141.         return ret;
  142.     }
  143.  
  144.     /* Endpoints for the filter graph. */
  145.     outputs->name       = av_strdup("in");
  146.     outputs->filter_ctx = buffersrc_ctx;
  147.     outputs->pad_idx    = 0;
  148.     outputs->next       = NULL;
  149.  
  150.     inputs->name       = av_strdup("out");
  151.     inputs->filter_ctx = buffersink_ctx;
  152.     inputs->pad_idx    = 0;
  153.     inputs->next       = NULL;
  154.  
  155.     if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
  156.                                     &inputs, &outputs, NULL)) < 0)
  157.         return ret;
  158.  
  159.     if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
  160.         return ret;
  161.  
  162.     /* Print summary of the sink buffer
  163.      * Note: args buffer is reused to store channel layout string */
  164.     outlink = buffersink_ctx->inputs[0];
  165.     av_get_channel_layout_string(args, sizeof(args), -1, outlink->channel_layout);
  166.     av_log(NULL, AV_LOG_INFO, "Output: srate:%dHz fmt:%s chlayout:%s\n",
  167.            (int)outlink->sample_rate,
  168.            (char *)av_x_if_null(av_get_sample_fmt_name(outlink->format), "?"),
  169.            args);
  170.  
  171.     return 0;
  172. }
  173.  
  174. static void print_frame(const AVFrame *frame)
  175. {
  176.     const int n = frame->nb_samples * av_get_channel_layout_nb_channels(av_frame_get_channel_layout(frame));
  177.     const uint16_t *p     = (uint16_t*)frame->data[0];
  178.     const uint16_t *p_end = p + n;
  179.  
  180.     while (p < p_end) {
  181.         fputc(*p    & 0xff, stdout);
  182.         fputc(*p>>8 & 0xff, stdout);
  183.         p++;
  184.     }
  185.     fflush(stdout);
  186. }
  187.  
  188. int main(int argc, char **argv)
  189. {
  190.     int ret;
  191.     AVPacket packet;
  192.     AVFrame *frame = av_frame_alloc();
  193.     AVFrame *filt_frame = av_frame_alloc();
  194.     int got_frame;
  195.  
  196.     if (!frame || !filt_frame) {
  197.         perror("Could not allocate frame");
  198.         exit(1);
  199.     }
  200.     if (argc != 2) {
  201.         fprintf(stderr, "Usage: %s file | %s\n", argv[0], player);
  202.         exit(1);
  203.     }
  204.  
  205.     avcodec_register_all();
  206.     av_register_all();
  207.     avfilter_register_all();
  208.  
  209.     if ((ret = open_input_file(argv[1])) < 0)
  210.         goto end;
  211.     if ((ret = init_filters(filter_descr)) < 0)
  212.         goto end;
  213.  
  214.     /* read all packets */
  215.     while (1) {
  216.         if ((ret = av_read_frame(fmt_ctx, &packet)) < 0)
  217.             break;
  218.  
  219.         if (packet.stream_index == audio_stream_index) {
  220.             avcodec_get_frame_defaults(frame);
  221.             got_frame = 0;
  222.             ret = avcodec_decode_audio4(dec_ctx, frame, &got_frame, &packet);
  223.             if (ret < 0) {
  224.                 av_log(NULL, AV_LOG_ERROR, "Error decoding audio\n");
  225.                 continue;
  226.             }
  227.  
  228.             if (got_frame) {
  229.                 /* push the audio data from decoded frame into the filtergraph */
  230.                 if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, 0) < 0) {
  231.                     av_log(NULL, AV_LOG_ERROR, "Error while feeding the audio filtergraph\n");
  232.                     break;
  233.                 }
  234.  
  235.                 /* pull filtered audio from the filtergraph */
  236.                 while (1) {
  237.                     ret = av_buffersink_get_frame(buffersink_ctx, filt_frame);
  238.                     if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
  239.                         break;
  240.                     if(ret < 0)
  241.                         goto end;
  242.                     print_frame(filt_frame);
  243.                     av_frame_unref(filt_frame);
  244.                 }
  245.             }
  246.         }
  247.         av_free_packet(&packet);
  248.     }
  249. end:
  250.     avfilter_graph_free(&filter_graph);
  251.     if (dec_ctx)
  252.         avcodec_close(dec_ctx);
  253.     avformat_close_input(&fmt_ctx);
  254.     av_frame_free(&frame);
  255.     av_frame_free(&filt_frame);
  256.  
  257.     if (ret < 0 && ret != AVERROR_EOF) {
  258.         char buf[1024];
  259.         av_strerror(ret, buf, sizeof(buf));
  260.         fprintf(stderr, "Error occurred: %s\n", buf);
  261.         exit(1);
  262.     }
  263.  
  264.     exit(0);
  265. }
  266.