diff --git a/doc/ffmpeg.texi b/doc/ffmpeg.texi
index 8b08e22..6e6fb97 100644
--- a/doc/ffmpeg.texi
+++ b/doc/ffmpeg.texi
@@ -1276,6 +1276,34 @@ This option is similar to @option{-filter_complex}, the only difference is that
 its argument is the name of the file from which a complex filtergraph
 description is to be read.
 
+@item -sample_rate_fallback @var{method}  (@emph{global})
+Audio sample rate fallback method when no exact match found.
+
+Whenever the filtergraph connects its filters each other, attributes of output link
+on each filter will be compared to ones of input link on the next filter. If an
+attribute on the both sides have been matched exactly, it will be passed through. If
+not, of course, such attribute must be reformated or resampled.
+
+On audio filtergraph, sample format and channel layout are reformated with wider
+ones in such situation. This brings almost good result and less problem. However
+for audio sample rate, there is more than one point of view about a @emph{good} method.
+@table @option
+@item 0, closest
+Audio stream will be resampled to the closest (regardless of higher or lower) one
+of the next filter's available input sample rates. It is the default behavior and
+preferred for saving storage capacity or network bandwidth rather than preserving
+sound quality.
+@item 1, higher
+Resampled to the closest higher one of the next filter's available input
+sample rates.
+@item 2, higher2x
+Similar to @option{higher}, but twice high because of the sampling theorem.
+@item 3, highest
+Resampled to the highest one of the next filter's available input sample rates. It
+may be accepted when bandwidth won't be a problem, such as putting to local DAC
+directly.
+@end table
+
 @item -accurate_seek (@emph{input})
 This option enables or disables accurate seeking in input files with the
 @option{-ss} option. It is enabled by default, so seeking is accurate when
diff --git a/ffmpeg.h b/ffmpeg.h
index 06a1251..13d8e16 100644
--- a/ffmpeg.h
+++ b/ffmpeg.h
@@ -601,6 +601,7 @@ extern char *videotoolbox_pixfmt;
 
 extern int filter_nbthreads;
 extern int filter_complex_nbthreads;
+extern int sample_rate_fallback;
 extern int vstats_version;
 
 extern const AVIOInterruptCB int_cb;
diff --git a/ffmpeg_filter.c b/ffmpeg_filter.c
index 7f249c2..182048b 100644
--- a/ffmpeg_filter.c
+++ b/ffmpeg_filter.c
@@ -1045,6 +1045,7 @@ int configure_filtergraph(FilterGraph *fg)
     } else {
         fg->graph->nb_threads = filter_complex_nbthreads;
     }
+    fg->graph->sample_rate_fallback = sample_rate_fallback;
 
     if ((ret = avfilter_graph_parse2(fg->graph, graph_desc, &inputs, &outputs)) < 0)
         goto fail;
diff --git a/ffmpeg_opt.c b/ffmpeg_opt.c
index e2c0176..d8b8918 100644
--- a/ffmpeg_opt.c
+++ b/ffmpeg_opt.c
@@ -121,6 +121,7 @@ int frame_bits_per_raw_sample = 0;
 float max_error_rate  = 2.0/3;
 int filter_nbthreads = 0;
 int filter_complex_nbthreads = 0;
+int sample_rate_fallback = 0;
 int vstats_version = 2;
 
 
@@ -3088,6 +3089,27 @@ static int opt_filter_complex_script(void *optctx, const char *opt, const char *
     return 0;
 }
 
+static int opt_sample_rate_fallback(void *optctx, const char *opt, const char *arg)
+{
+    static const AVOption opts[] = {
+        { "sample_rate_fallback", NULL, 0, AV_OPT_TYPE_INT,   { .i64 = 0 }, 0, 3, 0, "sample_rate_fallback" },
+        { "closest",              NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, 0, "sample_rate_fallback" },
+        { "higher",               NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, 0, "sample_rate_fallback" },
+        { "higher2x",             NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, 0, 0, 0, "sample_rate_fallback" },
+        { "highest",              NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, 0, 0, 0, "sample_rate_fallback" },
+        { NULL },
+    };
+    static const AVClass class = {
+        .class_name = "",
+        .item_name  = av_default_item_name,
+        .option     = opts,
+        .version    = LIBAVUTIL_VERSION_INT,
+    };
+    const AVClass *pclass = &class;
+
+    return av_opt_eval_int(&pclass, &opts[0], arg, &sample_rate_fallback);
+}
+
 void show_help_default(const char *opt, const char *arg)
 {
     /* per-file options have at least one of those set */
@@ -3434,6 +3456,8 @@ const OptionDef options[] = {
         "create a complex filtergraph", "graph_description" },
     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
         "read complex filtergraph description from a file", "filename" },
+    { "sample_rate_fallback", HAS_ARG | OPT_EXPERT,                  { .func_arg = opt_sample_rate_fallback },
+        "filtergraph's sample rate fallback method when no exact match found", "method" },
     { "stats",          OPT_BOOL,                                    { &print_stats },
         "print progress report during encoding", },
     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
diff --git a/libavfilter/avfilter.h b/libavfilter/avfilter.h
index b56615c..f5d47de 100644
--- a/libavfilter/avfilter.h
+++ b/libavfilter/avfilter.h
@@ -891,6 +891,7 @@ typedef struct AVFilterGraph {
     avfilter_execute_func *execute;
 
     char *aresample_swr_opts; ///< swr options to use for the auto-inserted aresample filters, Access ONLY through AVOptions
+    int sample_rate_fallback; ///< sample rate fallback method when no exact match found
 
     /**
      * Private fields
diff --git a/libavfilter/avfiltergraph.c b/libavfilter/avfiltergraph.c
index 534c670..4e856c6 100644
--- a/libavfilter/avfiltergraph.c
+++ b/libavfilter/avfiltergraph.c
@@ -44,15 +44,26 @@
 #define OFFSET(x) offsetof(AVFilterGraph, x)
 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 static const AVOption filtergraph_options[] = {
-    { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
-        { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
-        { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" },
-    { "threads",     "Maximum number of threads", OFFSET(nb_threads),
-        AV_OPT_TYPE_INT,   { .i64 = 0 }, 0, INT_MAX, FLAGS },
-    {"scale_sws_opts"       , "default scale filter options"        , OFFSET(scale_sws_opts)        ,
-        AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
-    {"aresample_swr_opts"   , "default aresample filter options"    , OFFSET(aresample_swr_opts)    ,
-        AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
+    { "thread_type",          "Allowed thread types",                                  OFFSET(thread_type),
+        AV_OPT_TYPE_FLAGS,  { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
+    { "slice",                NULL,                                                    0,
+        AV_OPT_TYPE_CONST,  { .i64 = AVFILTER_THREAD_SLICE }, 0, 0,       FLAGS, "thread_type" },
+    { "threads",              "Maximum number of threads",                             OFFSET(nb_threads),
+        AV_OPT_TYPE_INT,    { .i64 = 0 },                     0, INT_MAX, FLAGS },
+    { "scale_sws_opts",       "default scale filter options",                          OFFSET(scale_sws_opts),
+        AV_OPT_TYPE_STRING, {.str = NULL},                    0, 0,       FLAGS },
+    { "aresample_swr_opts",   "default aresample filter options",                      OFFSET(aresample_swr_opts),
+        AV_OPT_TYPE_STRING, {.str = NULL},                    0, 0,       FLAGS },
+    { "sample_rate_fallback", "sample rate fallback method when no exact match found", OFFSET(sample_rate_fallback),
+        AV_OPT_TYPE_INT,    { .i64 = 0 },                     0, 3,       FLAGS, "sample_rate_fallback" },
+    { "closest",              "to the closest sample rate",                            0,
+        AV_OPT_TYPE_CONST,  { .i64 = 0 },                     0, 0,       FLAGS, "sample_rate_fallback" },
+    { "higher",               "to the closest higher sample rate",                     0,
+        AV_OPT_TYPE_CONST,  { .i64 = 1 },                     0, 0,       FLAGS, "sample_rate_fallback" },
+    { "higher2x",             "similar to 'higher', but twice high",                   0,
+        AV_OPT_TYPE_CONST,  { .i64 = 2 },                     0, 0,       FLAGS, "sample_rate_fallback" },
+    { "highest",              "to the highest sample rate",                            0,
+        AV_OPT_TYPE_CONST,  { .i64 = 3 },                     0, 0,       FLAGS, "sample_rate_fallback" },
     { NULL },
 };
 
@@ -874,7 +885,28 @@ static void swap_samplerates_on_filter(AVFilterContext *filter)
             continue;
 
         for (j = 0; j < outlink->in_samplerates->nb_formats; j++) {
-            int diff = abs(sample_rate - outlink->in_samplerates->formats[j]);
+            int diff;
+            switch (filter->graph->sample_rate_fallback) {
+            default:
+                diff = abs(sample_rate - outlink->in_samplerates->formats[j]);
+                break;
+            case 1:
+                if ((diff = outlink->in_samplerates->formats[j] - sample_rate) < 0)
+                    goto reverse_tail;
+                break;
+            case 2:
+                if ((diff = sample_rate - outlink->in_samplerates->formats[j]) == 0)
+                    break;
+                if ((diff = outlink->in_samplerates->formats[j] - sample_rate * 2) < 0)
+                    goto reverse_tail;
+                break;
+            case 3:
+                if ((diff = sample_rate - outlink->in_samplerates->formats[j]) == 0)
+                    break;
+reverse_tail:
+                diff = INT_MAX - outlink->in_samplerates->formats[j];
+                break;
+            }
 
             av_assert0(diff < INT_MAX); // This would lead to the use of uninitialized best_diff but is only possible with invalid sample rates
 
