web-dev-qa-db-ja.com

Opusオーディオデータのデコード

Opusファイルを未加工の48 kHzにデコードしようとしています。しかし、それを行うためのサンプルコードを見つけることができません。

私の現在のコードはこれです：

void COpusCodec::Decode(unsigned char* encoded, short* decoded, unsigned int len)
{
     int max_size=960*6;//not sure about this one

     int error;
     dec = opus_decoder_create(48000, 1, &error);//decode to 48kHz mono

     int frame_size=opus_decode(dec, encoded, len, decoded, max_size, 0);
}

「encoded」という引数はより大量のデータになる可能性があるため、フレームに分割する必要があると思います。どうすればいいのかわかりません。

そして、オーパスの初心者であることで、私は何かを台無しにすることを本当に恐れています。

誰か助けてくれませんか？

c++windowsaudiocodecopus
18
tmighty

source tarball のopus_demo.cプログラムには、必要なものが含まれていると思います。

ただし、関連するすべてのコードが関係しているため、かなり複雑です。

  • コマンドライン引数からのエンコーダパラメータのエンコード、解析
  • 人工的なパケット損失注入
  • ランダムなフレームサイズの選択/オンザフライでの変更
  • インバンドFEC（2つのバッファにデコードし、2つのバッファを切り替えることを意味します）
  • デバッグと検証
  • ビットレート統計レポート

結局のところ、これらすべてのビットを削除することは、非常に退屈な仕事です。しかし、一度実行すると、かなりクリーンで理解しやすいコードになります。以下を参照してください。

注意してください

  • 参照用に「パケット損失」プロトコルコード（パケット損失がファイルからの読み取りが発生しない場合でも）を保持
  • 各フレームをデコードした後、最終的な範囲を検証するコードを保持しました

ほとんどの場合、コードを複雑にするようには見えないので、興味があるかもしれません。

このプログラムを2つの方法でテストしました。

  • 聴覚的に（以前にopus_demoを使用してエンコードされたモノwavが、このストリップされたデコーダーを使用して正しくデコードされたことを確認することにより）。テストwavは約23Mb、2.9Mb圧縮されました。
  • ./opus_demo -d 48000 1 <opus-file> <pcm-file>で呼び出された場合、Vanilla opus_demoと一緒に回帰テストが行​​われました。結果のファイルは、ここでストリップデコーダーを使用してデコードされたものと同じmd5sumチェックサムを持ちました。

MAJOR UPDATEコードをC++化しました。これにより、どこかでiostreamを使用できるようになります。

  • fin.readsomeのループに注目してください。このループは「非同期」にすることができます（つまり、次に戻り、新しいデータが到着したときに読み取りを続行することができます（Decode関数の次の呼び出し時？）[1]
  • ヘッダーファイルからopus.hへの依存関係を削除しました
  • 例外の安全性と堅牢性のために、「すべての」手動メモリ管理を標準ライブラリ（vector、unique_ptr）に置き換えました。
  • OpusErrorExceptionからエラーを伝播するために使用されるstd::exceptionから派生したlibopusクラスを実装しました

すべてのコードとMakefileをここで確認してください： https://github.com/sehe/opus/tree/master/contrib

[1] 真の非同期IO（例：ネットワークまたはシリアル通信）の場合は、Boost Asioの使用を検討してください。例 http://www.boost.org/doc/libs/1_53_0/doc/html /boost_asio/overview/networking/iostreams.html

ヘッダーファイル

// (c) Seth Heeren 2013
//
// Based on src/opus_demo.c in opus-1.0.2
// License see http://www.opus-codec.org/license/
#include <stdexcept>
#include <memory>
#include <iosfwd>

struct OpusErrorException : public virtual std::exception
{
    OpusErrorException(int code) : code(code) {}
    const char* what() const noexcept;
private:
    const int code;
};

struct COpusCodec
{
    COpusCodec(int32_t sampling_rate, int channels);
    ~COpusCodec();

    bool decode_frame(std::istream& fin, std::ostream& fout);
private:
    struct Impl;
    std::unique_ptr<Impl> _pimpl;
};

実装ファイル

// (c) Seth Heeren 2013
//
// Based on src/opus_demo.c in opus-1.0.2
// License see http://www.opus-codec.org/license/
#include "COpusCodec.hpp"
#include <vector>
#include <iomanip>
#include <memory>
#include <sstream>

#include "opus.h"

#define MAX_PACKET 1500

const char* OpusErrorException::what() const noexcept
{
    return opus_strerror(code);
}

// I'd suggest reading with boost::spirit::big_dword or similar
static uint32_t char_to_int(char ch[4])
{
    return static_cast<uint32_t>(static_cast<unsigned char>(ch[0])<<24) |
        static_cast<uint32_t>(static_cast<unsigned char>(ch[1])<<16) |
        static_cast<uint32_t>(static_cast<unsigned char>(ch[2])<< 8) |
        static_cast<uint32_t>(static_cast<unsigned char>(ch[3])<< 0);
}

struct COpusCodec::Impl
{
    Impl(int32_t sampling_rate = 48000, int channels = 1)
    : 
        _channels(channels),
        _decoder(nullptr, &opus_decoder_destroy),
        _state(_max_frame_size, MAX_PACKET, channels)
    {
        int err = OPUS_OK;
        auto raw = opus_decoder_create(sampling_rate, _channels, &err);
        _decoder.reset(err == OPUS_OK? raw : throw OpusErrorException(err) );
    }

    bool decode_frame(std::istream& fin, std::ostream& fout)
    {
        char ch[4] = {0};

        if (!fin.read(ch, 4) && fin.eof())
            return false;

        uint32_t len = char_to_int(ch);

        if(len>_state.data.size())
            throw std::runtime_error("Invalid payload length");

        fin.read(ch, 4);
        const uint32_t enc_final_range = char_to_int(ch);
        const auto data = reinterpret_cast<char*>(&_state.data.front());

        size_t read = 0ul;
        for (auto append_position = data; fin && read<len; append_position += read)
        {
            read += fin.readsome(append_position, len-read);
        }

        if(read<len)
        {
            std::ostringstream oss;
            oss << "Ran out of input, expecting " << len << " bytes got " << read << " at " << fin.tellg();
            throw std::runtime_error(oss.str());
        }

        int output_samples;
        const bool lost = (len==0);
        if(lost)
        {
            opus_decoder_ctl(_decoder.get(), OPUS_GET_LAST_PACKET_DURATION(&output_samples));
        }
        else
        {
            output_samples = _max_frame_size;
        }

        output_samples = opus_decode(
                _decoder.get(), 
                lost ? NULL : _state.data.data(),
                len,
                _state.out.data(),
                output_samples,
                0);

        if(output_samples>0)
        {
            for(int i=0; i<(output_samples)*_channels; i++)
            {
                short s;
                s=_state.out[i];
                _state.fbytes[2*i]   = s&0xFF;
                _state.fbytes[2*i+1] = (s>>8)&0xFF;
            }
            if(!fout.write(reinterpret_cast<char*>(_state.fbytes.data()), sizeof(short)* _channels * output_samples))
                throw std::runtime_error("Error writing");
        }
        else
        {
            throw OpusErrorException(output_samples); // negative return is error code
        }

        uint32_t dec_final_range;
        opus_decoder_ctl(_decoder.get(), OPUS_GET_FINAL_RANGE(&dec_final_range));

        /* compare final range encoder rng values of encoder and decoder */
        if(enc_final_range!=0
                && !lost && !_state.lost_prev
                && dec_final_range != enc_final_range)
        {
            std::ostringstream oss;
            oss << "Error: Range coder state mismatch between encoder and decoder in frame " << _state.frameno << ": " <<
                    "0x" << std::setw(8) << std::setfill('0') << std::hex << (unsigned long)enc_final_range <<
                    "0x" << std::setw(8) << std::setfill('0') << std::hex << (unsigned long)dec_final_range;

            throw std::runtime_error(oss.str());
        }

        _state.lost_prev = lost;
        _state.frameno++;

        return true;
    }
private:
    const int _channels;
    const int _max_frame_size = 960*6;
    std::unique_ptr<OpusDecoder, void(*)(OpusDecoder*)> _decoder;

    struct State
    {
        State(int max_frame_size, int max_payload_bytes, int channels) :
            out   (max_frame_size*channels),
            fbytes(max_frame_size*channels*sizeof(decltype(out)::value_type)),
            data  (max_payload_bytes)
        { }

        std::vector<short>         out;
        std::vector<unsigned char> fbytes, data;
        int32_t frameno   = 0;
        bool    lost_prev = true;
    };
    State _state;
};

COpusCodec::COpusCodec(int32_t sampling_rate, int channels)
    : _pimpl(std::unique_ptr<Impl>(new Impl(sampling_rate, channels)))
{
    //
}

COpusCodec::~COpusCodec()
{
    // this instantiates the pimpl deletor code on the, now-complete, pimpl class
}

bool COpusCodec::decode_frame(
        std::istream& fin,
        std::ostream& fout)
{
    return _pimpl->decode_frame(fin, fout);
}

test.cpp

// (c) Seth Heeren 2013
//
// Based on src/opus_demo.c in opus-1.0.2
// License see http://www.opus-codec.org/license/
#include <fstream>
#include <iostream>

#include "COpusCodec.hpp"

int main(int argc, char *argv[])
{
    if(argc != 3)
    {
        std::cerr << "Usage: " << argv[0] << " <input> <output>\n";
        return 255;
    }

    std::basic_ifstream<char> fin (argv[1], std::ios::binary);
    std::basic_ofstream<char> fout(argv[2], std::ios::binary);

    if(!fin)  throw std::runtime_error("Could not open input file");
    if(!fout) throw std::runtime_error("Could not open output file");

    try
    {
        COpusCodec codec(48000, 1);

        size_t frames = 0;
        while(codec.decode_frame(fin, fout))
        {
            frames++;
        }

        std::cout << "Successfully decoded " << frames << " frames\n";
    }
    catch(OpusErrorException const& e)
    {
        std::cerr << "OpusErrorException: " << e.what() << "\n";
        return 255;
    }
}
33
sehe

libopusは、opusパケットをPCMデータのチャンクに、またはその逆に変換するためのAPIを提供します。

しかし、opusパケットをファイルに格納するには、パケット境界を格納するある種のコンテナー形式が必要です。 opus_demoはデモアプリです。テスト用に独自の最小限のコンテナ形式があり、文書化されていないため、opus_demoで作成されたファイルを配布しないでください。 opusファイルの標準コンテナー形式はOggです。これは、メタデータとサンプル精度のデコード、および可変ビットレートストリームの効率的なシークのサポートも提供します。 Ogg Opusファイルの拡張子は「.opus」です。

Ogg Opusの仕様は https://wiki.xiph.org/OggOpus にあります。

（OpusはVoIPコーデックでもあるため、OpusパケットをUDP経由で直接送信するなど、コンテナーを必要としないOpusの使用方法があります。）

したがって、最初に、opus_demoではなく、opus-toolsのopusencを使用してファイルをエンコードする必要があります。他のソフトウェアでもOgg Opusファイルを生成できます（たとえば、gstreamerやffmpegで生成できると思います）が、リファレンス実装であるため、opus-toolsで問題が発生することはありません。

次に、ファイルが標準のOgg Opusファイル（Firefoxなどで読み取ることができる）であると想定すると、次のことを行う必要があります。（a）Oggコンテナーからopusパケットを抽出します。 （b）パケットをlibopusに渡し、生のPCMを取得します。

便利なことに、これを正確に行うlibopusfileというライブラリがあります。 libopusfileは、メタデータおよびシーク（HTTP接続を介したシークを含む）を含む、Ogg Opusストリームのすべての機能をサポートします。

libopusfileは https://git.xiph.org/?p=opusfile.git および https://github.com/xiph/opusfile で入手できます。 APIはドキュメント化されています ここ 、およびopusfile_example.c（ xiph.org | github ）は、WAVにデコードするためのサンプルコードを提供します。 Windowsを使用しているので、追加する必要があります downloads ページにビルド済みDLLがあります。

14
hexwab