J & J - 정성태의 닷넷 이야기

사용자

메뉴

최근 덧글

[정성태] VT sequences to "CONOUT$" vs. STD_O...[정성태] NetCoreDbg is a managed code debugg...[정성태] Evaluating tail call elimination in...[정성태] What’s new in System.Text.Json in ....[정성태] What's new in .NET 9: Cryptography ...[정성태] 아... 제시해 주신 "https://akrzemi1.wordp...[정성태] 다시 질문을 정리할 필요가 있을 것 같습니다. 제가 본문에...[이승준] 완전히 잘못 짚었습니다. 댓글 지우고 싶네요. 검색을 해보...[정성태] 우선 답글 감사합니다. ^^ 그런데, 사실 저 예제는 (g...[이승준] 수정이 안되어서... byteArray는 BYTE* 타입입니다...

글쓰기

제목

이름

암호

전자우편

HTML

홈페이지

유형

내용

<div style='display: inline'>
<h1 style='font-family: Malgun Gothic, Consolas; font-size: 20pt; color: #006699; text-align: center; font-weight: bold'>C# - ffmpeg(FFmpeg.AutoGen)를 이용한 오디오 필터 예제(filter_audio.c)</h1>
<p>
지난 예제에 이어,<br />
<br />
<pre style='margin: 10px 0px 10px 10px; padding: 10px 0px 10px 10px; background-color: #fbedbb; overflow: auto; font-family: Consolas, Verdana;' >
C# - ffmpeg(FFmpeg.AutoGen)를 이용한 오디오 필터링 예제(filtering_audio.c)
; <a target='tab' href='https://www.sysnet.pe.kr/2/0/12951'>https://www.sysnet.pe.kr/2/0/12951</a>
</pre>
<br />
이번에는 <a target='tab' href='https://ffmpeg.org/doxygen/trunk/examples.html'>ffmpeg 예제</a> 중 "<a target='tab' href='https://ffmpeg.org/doxygen/trunk/filter_audio_8c-example.html'>filter_audio.c</a>" 파일을 FFmpeg.AutoGen으로 포팅하겠습니다.<br />
<br />
<pre style='margin: 10px 0px 10px 10px; padding: 10px 0px 10px 10px; background-color: #fbedbb; overflow: auto; font-family: Consolas, Verdana;' >
using FFmpeg.AutoGen;
using FFmpeg.AutoGen.Example;
using System;
using System.Runtime.InteropServices;
using System.Security.Cryptography;

namespace FFmpegApp1
{
    internal unsafe class Program
    {
        const int INPUT_SAMPLERATE = 48000;
        const AVSampleFormat INPUT_FORMAT = AVSampleFormat.AV_SAMPLE_FMT_FLTP;
        const int INPUT_CHANNEL_LAYOUT = ffmpeg.AV_CH_LAYOUT_5POINT0;
        const float VOLUME_VAL = 0.90f;
        const int FRAME_SIZE = 1024;

static int Main(string[] args)
        {
            FFmpegBinariesHelper.RegisterFFmpegBinaries();

#if DEBUG
            Console.WriteLine("Current directory: " + Environment.CurrentDirectory);
            Console.WriteLine("Running in {0}-bit mode.", Environment.Is64BitProcess ? "64" : "32");
            Console.WriteLine($"FFmpeg version info: {ffmpeg.av_version_info()}");
#endif
            Console.WriteLine();

AVFilterGraph* graph;
            AVFilterContext* src;
            AVFilterContext* sink;
            AVFrame* frame;
            byte* errstr = stackalloc byte[1024];
            float duration;
            int err, nb_frames, i;

duration = 20.0f;

nb_frames = (int)(duration * INPUT_SAMPLERATE / FRAME_SIZE);
            if (nb_frames &lt;= 0)
            {
                Console.WriteLine($"Invalid duration: {duration}");
                return 1;
            }

frame = ffmpeg.av_frame_alloc();
            if (frame == null)
            {
                Console.WriteLine("Error allocating the frame");
                return 1;
            }

do
            {
                err = init_filter_graph(&amp;graph, &amp;src, &amp;sink);
                if (err &lt; 0)
                {
                    Console.WriteLine("Unable to init filter graph:");
                    break;
                }

for (i = 0; i &lt; nb_frames; i++)
                {
                    err = get_input(frame, i);
                    if (err &lt; 0)
                    {
                        Console.WriteLine("Error generating input frame:");
                        break;
                    }

err = ffmpeg.av_buffersrc_add_frame(src, frame);
                    if (err &lt; 0)
                    {
                        ffmpeg.av_frame_unref(frame);
                        Console.WriteLine("Error submitting the frame to the filtergraph:");
                        break;
                    }

MD5 md5 = MD5.Create();

while ((err = ffmpeg.av_buffersink_get_frame(sink, frame)) &gt;= 0)
                    {
                        err = process_output(md5, frame);
                        if (err &lt; 0)
                        {
                            Console.WriteLine("Error processing the filtered frame:");
                            break;
                        }

ffmpeg.av_frame_unref(frame);
                    }

if (err == ffmpeg.AVERROR(ffmpeg.EAGAIN))
                    {
                        continue;
                    }
                    else if (err == ffmpeg.AVERROR_EOF)
                    {
                        break;
                    }
                    else if (err &lt; 0)
                    {
                        Console.WriteLine("Error filtering the data:");
                        break;
                    }
                }

} while (false);

if (graph != null)
            {
                ffmpeg.avfilter_graph_free(&amp;graph);
            }

if (frame != null)
            {
                ffmpeg.av_frame_free(&amp;frame);
            }

if (err &lt; 0 &amp;&amp; err != ffmpeg.AVERROR(ffmpeg.EAGAIN))
            {
                ffmpeg.av_strerror(err, errstr, 1024);

string result = Marshal.PtrToStringAnsi(new IntPtr(errstr), getStringSize(errstr, 1024));
                Console.WriteLine(result);
                return 1;
            }

return 0;
        }

private static unsafe int init_filter_graph(AVFilterGraph** graph, AVFilterContext** src, AVFilterContext** sink)
        {
            AVFilterGraph* filter_graph;
            AVFilterContext* abuffer_ctx = null;
            AVFilter* abuffer = null;
            AVFilterContext* volume_ctx = null;
            AVFilter* volume = null;
            AVFilterContext* aformat_ctx = null;
            AVFilter* aformat = null;
            AVFilterContext* abuffersink_ctx = null;
            AVFilter* abuffersink = null;

AVDictionary* options_dict = null;
            byte* ch_layout = stackalloc byte[64];

int err = 0;

filter_graph = ffmpeg.avfilter_graph_alloc();
            if (filter_graph == null)
            {
                Console.WriteLine("Unable to create filter graph.");
                return ffmpeg.AVERROR(ffmpeg.ENOMEM);
            }

abuffer = ffmpeg.avfilter_get_by_name("abuffer");
            if (abuffer == null)
            {
                Console.WriteLine("Could not find the abuffer filter.");
                return ffmpeg.AVERROR_FILTER_NOT_FOUND;
            }

abuffer_ctx = ffmpeg.avfilter_graph_alloc_filter(filter_graph, abuffer, "src");
            if (abuffer_ctx == null)
            {
                Console.WriteLine("Could not allocate the abuffer instance.");
                return ffmpeg.AVERROR(ffmpeg.ENOMEM);
            }

ffmpeg.av_get_channel_layout_string(ch_layout, 64, 0, INPUT_CHANNEL_LAYOUT);

string ch_layout_value = Marshal.PtrToStringAnsi(new IntPtr(ch_layout), getStringSize(ch_layout, 64));
            err = ffmpeg.av_opt_set(abuffer_ctx, "channel_layout", ch_layout_value, ffmpeg.AV_OPT_SEARCH_CHILDREN);
            err = ffmpeg.av_opt_set(abuffer_ctx, "sample_fmt", ffmpeg.av_get_sample_fmt_name(INPUT_FORMAT), ffmpeg.AV_OPT_SEARCH_CHILDREN);
            err = ffmpeg.av_opt_set_q(abuffer_ctx, "time_base", new AVRational { num = 1, den = INPUT_SAMPLERATE }, ffmpeg.AV_OPT_SEARCH_CHILDREN);
            err = ffmpeg.av_opt_set_int(abuffer_ctx, "sample_rate", INPUT_SAMPLERATE, ffmpeg.AV_OPT_SEARCH_CHILDREN);

err = ffmpeg.avfilter_init_str(abuffer_ctx, null);
            if (err &lt; 0)
            {
                Console.WriteLine("Could not initialze the abuffer filter.");
                return err;
            }

volume = ffmpeg.avfilter_get_by_name("volume");
            if (volume == null)
            {
                Console.WriteLine("Could not find the volume filter.");
                return ffmpeg.AVERROR_FILTER_NOT_FOUND;
            }

volume_ctx = ffmpeg.avfilter_graph_alloc_filter(filter_graph, volume, "volume");
            if (volume_ctx == null)
            {
                Console.WriteLine("Could not allocate the volume instance.");
                return ffmpeg.AVERROR(ffmpeg.ENOMEM);
            }

ffmpeg.av_dict_set(&amp;options_dict, "volume", $"{VOLUME_VAL:F}", 0);
            err = ffmpeg.avfilter_init_dict(volume_ctx, &amp;options_dict);
            ffmpeg.av_dict_free(&amp;options_dict);
            if (err &lt; 0)
            {
                Console.WriteLine("Could not initialze the volume filter.");
                return err;
            }

aformat = ffmpeg.avfilter_get_by_name("aformat");
            if (aformat == null)
            {
                Console.WriteLine("Could not find the aformat filter.");
                return ffmpeg.AVERROR_FILTER_NOT_FOUND;
            }

aformat_ctx = ffmpeg.avfilter_graph_alloc_filter(filter_graph, aformat, "aformat");
            if (aformat_ctx == null)
            {
                Console.WriteLine("Could not allocate the aformat instance.");
                return ffmpeg.AVERROR(ffmpeg.ENOMEM);
            }

string options_str = $"sample_fmts={ffmpeg.av_get_sample_fmt_name(AVSampleFormat.AV_SAMPLE_FMT_S16)}:sample_rates=44100:channel_layouts=0x{ffmpeg.AV_CH_LAYOUT_STEREO:x}";
            err = ffmpeg.avfilter_init_str(aformat_ctx, options_str);
            if (err &lt; 0)
            {
                ffmpeg.av_log(null, ffmpeg.AV_LOG_ERROR, "Could not initialize the aformat filter.");
                return err;
            }

abuffersink = ffmpeg.avfilter_get_by_name("abuffersink");
            if (abuffersink == null)
            {
                Console.WriteLine("Could not allocate the abuffersink instance.");
                return ffmpeg.AVERROR(ffmpeg.ENOMEM);
            }

abuffersink_ctx = ffmpeg.avfilter_graph_alloc_filter(filter_graph, abuffersink, "sink");
            if (abuffersink_ctx == null)
            {
                Console.WriteLine("Could not initialize the abuffersink instance.");
                return err;
            }

err = ffmpeg.avfilter_init_str(abuffersink_ctx, null);
            if (err &lt; 0)
            {
                Console.WriteLine("Could not initialize the abuffersink instance.");
                return err;
            }

err = ffmpeg.avfilter_link(abuffer_ctx, 0, volume_ctx, 0);
            if (err &gt;= 0)
            {
                err = ffmpeg.avfilter_link(volume_ctx, 0, aformat_ctx, 0);
            }

if (err &gt;= 0)
            {
                err = ffmpeg.avfilter_link(aformat_ctx, 0, abuffersink_ctx, 0);
            }

if (err &lt; 0)
            {
                Console.WriteLine("Error connecting filters.");
                return err;
            }

err = ffmpeg.avfilter_graph_config(filter_graph, null);
            if (err &lt; 0)
            {
                ffmpeg.av_log(null, ffmpeg.AV_LOG_ERROR, "Error configuring the filter graph");
                return err;
            }

*graph = filter_graph;
            *src = abuffer_ctx;
            *sink = abuffersink_ctx;

return 0;
        }

private static int getStringSize(byte* buffer, int length)
        {
            for (int i = 0; i &lt; length; i++)
            {
                if (buffer[i] == 0)
                {
                    return i;
                }
            }

return 0;
        }

static unsafe int process_output(MD5 md5, AVFrame* frame)
        {
            int planar = ffmpeg.av_sample_fmt_is_planar((AVSampleFormat)frame-&gt;format);
            int channels = ffmpeg.av_get_channel_layout_nb_channels(frame-&gt;channel_layout);
            int planes = planar != 0 ? channels : 1;
            int bps = ffmpeg.av_get_bytes_per_sample((AVSampleFormat)frame-&gt;format);
            int plane_size = bps * frame-&gt;nb_samples * (planar != 0 ? 1 : channels);
            int i;

for (i = 0; i &lt; planes; i++)
            {
                Span&lt;byte&gt; buffer = new Span&lt;byte&gt;(frame-&gt;extended_data[i], plane_size);
                byte[] computed = md5.ComputeHash(buffer.ToArray()); // ToArray: copy overhead

Console.WriteLine(BitConverter.ToString(computed).Replace("-", ""));
            }
            
            return 0;
        }

static unsafe int get_input(AVFrame* frame, int frame_num)
        {
            int err, i, j;

frame-&gt;sample_rate = INPUT_SAMPLERATE;
            frame-&gt;format = (int)INPUT_FORMAT;
            frame-&gt;channel_layout = INPUT_CHANNEL_LAYOUT;
            frame-&gt;nb_samples = FRAME_SIZE;
            frame-&gt;pts = frame_num * FRAME_SIZE;

err = ffmpeg.av_frame_get_buffer(frame, 0);
            if (err &lt; 0)
            {
                return err;
            }

for (i = 0; i &lt; 5; i++)
            {
                float* data = (float*)frame-&gt;extended_data[i];

for (j = 0; j &lt; frame-&gt;nb_samples; j++)
                {
                    data[j] = (float)Math.Sin(2 * Math.PI * (frame_num + j) * (i + 1) / FRAME_SIZE);
                }
            }

return 0;
        }
    }
}
</pre>
<br />
위의 코드를 실행하면 get_input으로 사인파 데이터를 생성해 필터를 통과하면서 process_output에 의해 md5 checksum 데이터를 출력합니다.<br />
<br />
아직 제 수준에서는 이런 예제까지는 필요 없는 것 같습니다. ^^<br />
<br />
(<a target='tab' href='https://www.sysnet.pe.kr/bbs/DownloadAttachment.aspx?fid=1895&boardid=331301885'>첨부 파일은 이 글의 예제 코드를 포함</a>합니다.)<br />
(<a target='tab' href='https://github.com/stjeong/ffmpeg_autogen_cs/tree/master/filter_audio'>이 글의 소스 코드는 github에 올려</a>져 있습니다.)
</p><br />

<br /><hr /><span style='color: Maroon'>[이 글에 대해서 여러분들과 의견을 공유하고 싶습니다. 틀리거나 미흡한 부분 또는 의문 사항이 있으시면 언제든 댓글 남겨주십시오.]</span>

</div>

첨부파일

스팸 방지용 인증 번호

2060 (왼쪽의 숫자를 입력해야 합니다.)