Microsoft MVP성태의 닷넷 이야기
글쓴 사람
정성태 (techsharer at outlook.com)
홈페이지
첨부 파일

C# - ffmpeg(FFmpeg.AutoGen)를 이용해 오디오(mp2) 인코딩하는 예제(encode_audio.c)

지난 예제에 이어,

C# - ffmpeg(FFmpeg.AutoGen)를 이용해 멀티미디어 파일의 메타데이터를 보여주는 예제(metadata.c)
; https://www.sysnet.pe.kr/2/0/12936

이번에는 ffmpeg 예제 중 "encode_audio.c" 파일을 FFmpeg.AutoGen으로 포팅하겠습니다.

using FFmpeg.AutoGen;
using FFmpeg.AutoGen.Example;
using System;
using System.IO;

namespace FFmpegApp1
{
    internal unsafe class Program
    {
        static void 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();

            Console.WriteLine($"LIBAVFORMAT Version: {ffmpeg.LIBAVFORMAT_VERSION_MAJOR}.{ffmpeg.LIBAVFORMAT_VERSION_MINOR}");

            encode_audio(@"C:\temp\output\test.mp2");
        }

        private static void encode_audio(string filename)
        {
            AVCodec* codec;
            AVCodecContext* c = null;
            AVFrame* frame = null;
            AVPacket* pkt = null;
            int i, j, k, ret;
            short* samples;
            float t, tincr;

            /* find the MP2 encoder */
            codec = ffmpeg.avcodec_find_encoder(AVCodecID.AV_CODEC_ID_MP2);
            if (codec == null)
            {
                Console.WriteLine("Codec not found");
                return;
            }

            do
            {
                c = ffmpeg.avcodec_alloc_context3(codec);
                if (c == null)
                {
                    Console.WriteLine("Could not allocate audio codec context");
                    break;
                }

                /* put sample parameters */
                c->bit_rate = 64000;

                /* check that the encoder supports s16 pcm input */
                c->sample_fmt = AVSampleFormat.AV_SAMPLE_FMT_S16;
                if (check_sample_fmt(codec, c->sample_fmt) == 0)
                {
                    Console.WriteLine($"Encoder does not support sample format {ffmpeg.av_get_sample_fmt_name(c->sample_fmt)}");
                    break;
                }

                /* select other audio parameters supported by the encoder */
                c->sample_rate = select_sample_rate(codec);
                c->channel_layout = select_channel_layout(codec);
                c->channels = ffmpeg.av_get_channel_layout_nb_channels(c->channel_layout);

                /* open it */
                if (ffmpeg.avcodec_open2(c, codec, null) < 0)
                {
                    Console.WriteLine("Could not open codec");
                    break;
                }

                using FileStream f = System.IO.File.OpenWrite(filename);

                /* packet for holding encoded output */
                pkt = ffmpeg.av_packet_alloc();
                if (pkt == null)
                {
                    Console.WriteLine( "could not allocate the packet");
                    break;
                }

                /* frame containing input raw audio */
                frame = ffmpeg.av_frame_alloc();
                if (frame == null)
                {
                    Console.WriteLine("Could not allocate audio frame");
                    break;
                }

                frame->nb_samples = c->frame_size;
                frame->format = (int)c->sample_fmt;
                frame->channel_layout = c->channel_layout;

                /* allocate the data buffers */
                ret = ffmpeg.av_frame_get_buffer(frame, 0);
                if (ret < 0)
                {
                    Console.WriteLine("Could not allocate audio data buffers");
                    break;
                }

                /* encode a single tone sound */
                t = 0;
                tincr = (float)(2 * Math.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 = ffmpeg.av_frame_make_writable(frame);
                    if (ret < 0)
                    {
                        break;
                    }

                    samples = (short *)frame->data[0];

                    for (j = 0; j < c->frame_size; j++)
                    {
                        samples[2 * j] = (short)(Math.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);

            } while (false);

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

            if (pkt != null)
            {
                ffmpeg.av_packet_free(&pkt);
            }

            if (c != null)
            {
                ffmpeg.avcodec_free_context(&c);
            }
        }

        /* check that a given sample format is supported by the encoder */
        static unsafe int check_sample_fmt(AVCodec* codec, AVSampleFormat sample_fmt)
        {
            AVSampleFormat* p = codec->sample_fmts;

            while (*p != AVSampleFormat.AV_SAMPLE_FMT_NONE)
            {
                if (*p == sample_fmt)
                {
                    return 1;
                }

                p++;
            }

            return 0;
        }

        /* just pick the highest supported samplerate */
        static unsafe int select_sample_rate(AVCodec* codec)
        {
            int* p;
            int best_samplerate = 0;

            if (codec->supported_samplerates == null)
            {
                return 44100;
            }

            p = codec->supported_samplerates;
            while (*p != 0)
            {
                if (best_samplerate == 0 || Math.Abs(44100 - *p) < Math.Abs(44100 - best_samplerate))
                {
                    best_samplerate = *p;
                }

                p++;
            }

            return best_samplerate;
        }

        /* select layout with the highest channel count */
        static unsafe ulong select_channel_layout(AVCodec* codec)
        {
            ulong* p;
            ulong best_ch_layout = 0;
            int best_nb_channels = 0;

            if (codec->channel_layouts == null)
            {
                return ffmpeg.AV_CH_LAYOUT_STEREO;
            }
 
            p = codec->channel_layouts;
            while (*p != 0) 
            {
                int nb_channels = ffmpeg.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 bool encode(AVCodecContext* ctx, AVFrame* frame, AVPacket* pkt, FileStream output)
        {
            int ret;

            /* send the frame for encoding */
            ret = ffmpeg.avcodec_send_frame(ctx, frame);
            if (ret < 0)
            {
                Console.WriteLine("Error sending the frame to the encoder");
                return false;
            }

            /* read all the available output packets (in general there may be any
             * number of them */
            while (ret >= 0)
            {
                ret = ffmpeg.avcodec_receive_packet(ctx, pkt);
                if (ret == ffmpeg.AVERROR(ffmpeg.EAGAIN) || ret == ffmpeg.AVERROR_EOF)
                {
                    return true;
                }
                else if (ret < 0)
                {
                    Console.WriteLine("Error encoding audio frame");
                    return false;
                }

                ReadOnlySpan<byte> buffer = new ReadOnlySpan<byte>(pkt->data, pkt->size);
                output.Write(buffer);
                ffmpeg.av_packet_unref(pkt);
            }

            return true;
        }
    }
}

위의 코드를 실행하면 mp2 포맷의 오디오 파일이 생성됩니다. 그 파일의 포맷을 검사하면,

C:\temp\output> ffprobe test.mp2
ffprobe version 4.4.1 Copyright (c) 2007-2021 the FFmpeg developers
  built with Microsoft (R) C/C++ Optimizing Compiler Version 19.30.30705 for x64
  configuration: ...[생략]... --extra-cxxflags=-MD
  libavutil      56. 70.100 / 56. 70.100
  ...[생략]...
  libpostproc    55.  9.100 / 55.  9.100
[mp3 @ 0000022DD9812140] Estimating duration from bitrate, this may be inaccurate
Input #0, mp3, from 'test.mp2':
  Duration: 00:00:05.22, start: 0.000000, bitrate: 64 kb/s
  Stream #0:0: Audio: mp2, 44100 Hz, stereo, fltp, 64 kb/s

mp2라고 나오고, 실제로 미디어 플레이어를 이용해 재생하면 "뚜~~~" 소리가 5.22초 동안 재생됩니다.

(첨부 파일은 이 글의 예제 코드를 포함합니다.)
(이 글의 소스 코드는 github에 올려져 있습니다.)




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

[연관 글]






[최초 등록일: ]
[최종 수정일: 3/13/2022]

Creative Commons License
이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.
by SeongTae Jeong, mailto:techsharer at outlook.com

비밀번호

댓글 작성자
 




1  2  3  4  5  [6]  7  8  9  10  11  12  13  14  15  ...
NoWriterDateCnt.TitleFile(s)
12965정성태2/13/2022836.NET Framework: 1154. "Hanja Hangul Project v1.01 (파이썬)"의 C# 버전
12964정성태2/11/2022679.NET Framework: 1153. C# - ffmpeg(FFmpeg.AutoGen)를 이용한 avio_reading.c 예제 포팅파일 다운로드1
12963정성태2/11/2022711.NET Framework: 1152. C# - 화면 캡처한 이미지를 ffmpeg(FFmpeg.AutoGen)로 동영상 처리 (저해상도 현상 해결)파일 다운로드1
12962정성태2/9/2022604오류 유형: 793. 마이크로소프트 스토어 - 제품이 존재하지 않습니다. 재고가 없는 것일 수 있습니다.
12961정성태2/8/2022798.NET Framework: 1151. C# - ffmpeg(FFmpeg.AutoGen)를 이용한 비디오 프레임의 크기 및 포맷 변경 예제(scaling_video.c) [7]파일 다운로드1
12960정성태2/8/2022777개발 환경 구성: 637. ffmpeg(FFmpeg.AutoGen)를 이용한 비디오 디코딩 예제(decode_video.c) - 세 번째 이야기
12959정성태2/7/2022949.NET Framework: 1150. C# - ffmpeg(FFmpeg.AutoGen)를 이용한 비디오 디코딩 예제(decode_video.c) - 두 번째 이야기 [2]파일 다운로드1
12958정성태2/6/2022817.NET Framework: 1149. C# - ffmpeg(FFmpeg.AutoGen) - 비디오 프레임 디코딩 [2]파일 다운로드1
12957정성태2/6/2022771개발 환경 구성: 636. ffmpeg.exe를 이용해 planar 포맷의 데이터를 packed 형식으로 변환하는 방법? [2]
12956정성태2/4/2022745.NET Framework: 1148. C# - ffmpeg(FFmpeg.AutoGen) - decoding 과정 [2]파일 다운로드1
12955정성태2/4/2022692개발 환경 구성: 635. 비주얼 스튜디오에서 실행하던 ASP.NET Core (.NET Framework) 응용 프로그램을 명령행에서 실행하는 방법 (2)
12954정성태2/4/2022479VS.NET IDE: 173. 비주얼 스튜디오 - Output 창에 색상이 지정된 출력 결과가 "[39m[22m" 식의 문자로 나오는 문제
12953정성태2/2/2022687Linux: 48. Windows 11 + WSL 우분투 GUI 환경에서 한글 출력
12952정성태2/2/2022556.NET Framework: 1148. C# - ffmpeg(FFmpeg.AutoGen)를 이용한 오디오 필터 예제(filter_audio.c)파일 다운로드1
12951정성태2/2/2022610.NET Framework: 1147. C# - ffmpeg(FFmpeg.AutoGen)를 이용한 오디오 필터링 예제(filtering_audio.c)파일 다운로드1
12950정성태2/1/2022683.NET Framework: 1146. .NET 6에 추가되지 않은 Generic Math (예: INumber<T>)
12949정성태2/1/2022547.NET Framework: 1145. C# - ffmpeg(FFmpeg.AutoGen) - Codec 정보 열람 및 사용 준비파일 다운로드1
12948정성태1/30/2022696.NET Framework: 1144. C# - ffmpeg(FFmpeg.AutoGen) AVFormatContext를 이용해 ffprobe처럼 정보 출력파일 다운로드1
12947정성태1/30/2022873개발 환경 구성: 634. ffmpeg.exe - 기존 동영상 컨테이너에 다중 스트림을 추가하는 방법
12946정성태1/28/2022620오류 유형: 792. .NET Core - 로컬 개발 중에 docker 호스팅으로 바꾸는 경우 SQL 서버 접근 방법
12945정성태1/28/2022604오류 유형: 791. SQL 서버 로그인 시 localhost는 되고, 127.0.0.1로는 안 되는 문제
12944정성태1/28/2022962.NET Framework: 1143. C# - Entity Framework Core 6 개요
12943정성태1/27/2022684.NET Framework: 1142. .NET 5+로 포팅 시 플랫폼 호환성 경고 메시지(SYSLIB0006, SYSLIB0011, CA1416)파일 다운로드1
12942정성태1/27/2022715.NET Framework: 1141. XmlSerializer와 Dictionary 타입파일 다운로드1
12941정성태1/26/2022536오류 유형: 790. AKS/k8s - pod 상태가 Pending으로 지속되는 경우
12940정성태1/26/2022700오류 유형: 789. AKS에서 hpa에 따른 autoscale 기능이 동작하지 않는다면?
1  2  3  4  5  [6]  7  8  9  10  11  12  13  14  15  ...