k
/
FFmpegAndroid
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add volume filter

Browse Source
dev
xufuji456 3 years ago
parent d17ecf27e4
commit 394971436c
1 changed files with 141 additions and 9 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 150
      app/src/main/cpp/audio_player.cpp

150
app/src/main/cpp/audio_player.cpp
Unescape View File

@ -4,7 +4,6 @@
#include <jni.h>
#include <stdlib.h>
#include <unistd.h>
#include <android/log.h>
#ifdef __cplusplus
extern "C" {
@ -14,6 +13,10 @@ extern "C" {
#include "libavcodec/avcodec.h"
#include "libswscale/swscale.h"
#include "libswresample/swresample.h"
#include "libavfilter/buffersink.h"
#include "libavfilter/buffersrc.h"
#include "libavfilter/avfiltergraph.h"
#include "libavutil/opt.h"
#include "ffmpeg_jni_define.h"
#ifdef __cplusplus
@ -21,10 +24,114 @@ extern "C" {
#endif
#define TAG "AudioPlayer"
#define VOLUME_VAL 0.50
#define SLEEP_TIME 1000 * 16
#define MAX_AUDIO_FRAME_SIZE 48000 * 4
int init_filter_graph(AVFilterGraph **graph, AVFilterContext **src, AVFilterContext **sink,
uint64_t channel_layout, AVSampleFormat inputFormat, int sample_rate) {
AVFilterGraph *filter_graph;
AVFilterContext *abuffer_ctx;
const AVFilter *abuffer;
AVFilterContext *volume_ctx;
const AVFilter *volume;
AVFilterContext *abuffersink_ctx;
const AVFilter *abuffersink;
AVDictionary *options_dict = NULL;
uint8_t ch_layout[64];
int err;
/* Create a new filter graph, which will contain all the filters. */
filter_graph = avfilter_graph_alloc();
if (!filter_graph) {
LOGE(TAG, "Unable to create filter graph:%d", stderr);
return AVERROR(ENOMEM);
}
/* Create the abuffer filter: feed data into the graph. */
abuffer = avfilter_get_by_name("abuffer");
if (!abuffer) {
LOGE(TAG, "Could not find the abuffer filter:%d", stderr);
return AVERROR_FILTER_NOT_FOUND;
}
abuffer_ctx = avfilter_graph_alloc_filter(filter_graph, abuffer, "src");
if (!abuffer_ctx) {
LOGE(TAG, "Could not allocate the abuffer instance:%d", stderr);
return AVERROR(ENOMEM);
}
/* Set the filter options through the AVOptions API. */
av_get_channel_layout_string(reinterpret_cast<char *>(ch_layout), sizeof(ch_layout), 0, channel_layout);
av_opt_set (abuffer_ctx, "channel_layout", reinterpret_cast<char *>(ch_layout), AV_OPT_SEARCH_CHILDREN);
av_opt_set (abuffer_ctx, "sample_fmt", av_get_sample_fmt_name(inputFormat), AV_OPT_SEARCH_CHILDREN);
av_opt_set_q (abuffer_ctx, "time_base", (AVRational){ 1, sample_rate }, AV_OPT_SEARCH_CHILDREN);
av_opt_set_int(abuffer_ctx, "sample_rate", sample_rate, AV_OPT_SEARCH_CHILDREN);
err = avfilter_init_str(abuffer_ctx, NULL);
if (err < 0) {
LOGE(TAG, "Could not initialize the abuffer filter:%d", stderr);
return err;
}
/* Create volume filter. */
volume = avfilter_get_by_name("volume");
if (!volume) {
LOGE(TAG, "Could not find the volume filter:%d", stderr);
return AVERROR_FILTER_NOT_FOUND;
}
volume_ctx = avfilter_graph_alloc_filter(filter_graph, volume, "volume");
if (!volume_ctx) {
LOGE(TAG, "Could not allocate the volume instance:%d", stderr);
return AVERROR(ENOMEM);
}
/* Passing the options is as key/value pairs in a dictionary. */
av_dict_set(&options_dict, "volume", AV_STRINGIFY(VOLUME_VAL), 0);
err = avfilter_init_dict(volume_ctx, &options_dict);
av_dict_free(&options_dict);
if (err < 0) {
LOGE(TAG, "Could not initialize the volume filter:%d", stderr);
return err;
}
/* Create the abuffersink filter: get the filtered data from graph. */
abuffersink = avfilter_get_by_name("abuffersink");
if (!abuffersink) {
LOGE(TAG, "Could not find the abuffersink filter:%d", stderr);
return AVERROR_FILTER_NOT_FOUND;
}
abuffersink_ctx = avfilter_graph_alloc_filter(filter_graph, abuffersink, "sink");
if (!abuffersink_ctx) {
LOGE(TAG, "Could not allocate the abuffersink instance:%d", stderr);
return AVERROR(ENOMEM);
}
err = avfilter_init_str(abuffersink_ctx, NULL);
if (err < 0) {
LOGE(TAG, "Could not initialize the abuffersink instance:%d", stderr);
return err;
}
/* Connect the filters */
err = avfilter_link(abuffer_ctx, 0, volume_ctx, 0);
if (err >= 0)
err = avfilter_link(volume_ctx, 0, abuffersink_ctx, 0);
if (err < 0) {
LOGE(TAG, "Error connecting filters:%d", stderr);
return err;
}
/* Configure the graph. */
err = avfilter_graph_config(filter_graph, NULL);
if (err < 0) {
LOGE(TAG, "Error configuring the filter graph:%d", err);
return err;
}
*graph = filter_graph;
*src = abuffer_ctx;
*sink = abuffersink_ctx;
return 0;
}
AUDIO_PLAYER_FUNC(void, play, jstring input_jstr) {
int got_frame = 0, ret = 0;
AVFilterGraph *audioFilterGraph;
AVFilterContext *audioSrcContext;
AVFilterContext *audioSinkContext;
const char *input_cstr = env->GetStringUTFChars(input_jstr, NULL);
LOGI(TAG, "input url=%s", input_cstr);
//register all modules
@ -114,7 +221,15 @@ AUDIO_PLAYER_FUNC(void, play, jstring input_jstr) {
uint8_t *out_buffer = (uint8_t *) av_malloc(MAX_AUDIO_FRAME_SIZE);
int got_frame = 0, ret = 0;
/* Set up the filter graph. */
AVFrame *filter_frame = av_frame_alloc();
ret = init_filter_graph(&audioFilterGraph, &audioSrcContext, &audioSinkContext,
in_ch_layout, in_sample_fmt, in_sample_rate);
if (ret < 0) {
LOGE(TAG, "Unable to init filter graph:%d", stderr);
goto end;
}
//read audio frame
while (av_read_frame(pFormatCtx, packet) >= 0) {
//is audio stream index
@ -126,12 +241,26 @@ AUDIO_PLAYER_FUNC(void, play, jstring input_jstr) {
}
//decode success
if (got_frame > 0) {
ret = av_buffersrc_add_frame(audioSrcContext, frame);
if (ret < 0) {
LOGE(TAG, "Error add the frame to the filter graph:%d", stderr);
}
/* Get all the filtered output that is available. */
ret = av_buffersink_get_frame(audioSinkContext, filter_frame);
if (ret == AVERROR(EAGAIN)) {
LOGE(TAG, "get filter frame again...");
continue;
}
if (ret < 0) {
LOGE(TAG, "Error get the frame from the filter graph:%d", stderr);
goto end;
}
//convert audio format
swr_convert(swrCtx, &out_buffer, MAX_AUDIO_FRAME_SIZE,
(const uint8_t **) frame->data, frame->nb_samples);
(const uint8_t **) /*frame*/filter_frame->data, /*frame*/filter_frame->nb_samples);
int out_buffer_size = av_samples_get_buffer_size(NULL, out_channel_nb,
frame->nb_samples, out_sample_fmt,
1);
/*frame*/filter_frame->nb_samples, out_sample_fmt, 1);
jbyteArray audio_sample_array = env->NewByteArray(out_buffer_size);
jbyte *sample_byte_array = env->GetByteArrayElements(audio_sample_array, NULL);
@ -144,17 +273,20 @@ AUDIO_PLAYER_FUNC(void, play, jstring input_jstr) {
audio_sample_array, 0, out_buffer_size);
//delete local reference
env->DeleteLocalRef(audio_sample_array);
usleep(1000 * 16);
av_frame_unref(filter_frame);
usleep(SLEEP_TIME);
}
}
av_packet_unref(packet);
}
LOGI(TAG, "decode audio finish");
end:
av_packet_free(&packet);
av_frame_free(&frame);
av_frame_free(&filter_frame);
av_free(out_buffer);
swr_free(&swrCtx);
avcodec_close(codecCtx);
avfilter_graph_free(&audioFilterGraph);
avcodec_free_context(&codecCtx);
avformat_close_input(&pFormatCtx);
env->ReleaseStringUTFChars(input_jstr, input_cstr);

Write Preview
Loading…
Cancel
Save