FFmpeg/libavformat/rtpdec_opus.c

/*
 * RTP Depacketization of Opus, RFC 7587
 * Copyright (c) 2025 Jonathan Baudanza <jon@jonb.org>
 * Copyright (c) 2022 Erik Linge
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "libavcodec/bytestream.h"
#include "libavutil/mem.h"
#include "libavutil/avstring.h"
#include "rtpdec_formats.h"
#include "internal.h"

static int opus_duration(const uint8_t *src, int size)
{
    unsigned nb_frames  = 1;
    unsigned toc        = src[0];
    unsigned toc_config = toc >> 3;
    unsigned toc_count  = toc & 3;
    unsigned frame_size = toc_config < 12 ? FFMAX(480, 960 * (toc_config & 3)) :
                          toc_config < 16 ? 480 << (toc_config & 1) :
                                            120 << (toc_config & 3);
    if (toc_count == 3) {
        if (size<2)
            return AVERROR_INVALIDDATA;
        nb_frames = src[1] & 0x3F;
    } else if (toc_count) {
        nb_frames = 2;
    }

    return frame_size * nb_frames;
}

static int opus_write_extradata(AVCodecParameters *codecpar)
{
    uint8_t *bs;
    int ret;

    /* This function writes an extradata with a channel mapping family of 0.
     * This mapping family only supports mono and stereo layouts. And RFC7587
     * specifies that the number of channels in the SDP must be 2.
     */
    if (codecpar->ch_layout.nb_channels > 2) {
        return AVERROR_INVALIDDATA;
    }

    ret = ff_alloc_extradata(codecpar, 19);
    if (ret < 0)
        return ret;

    bs = (uint8_t *)codecpar->extradata;

    /* Opus magic */
    bytestream_put_buffer(&bs, "OpusHead", 8);
    /* Version */
    bytestream_put_byte  (&bs, 0x1);
    /* Channel count */
    bytestream_put_byte  (&bs, codecpar->ch_layout.nb_channels);
    /* Pre skip */
    bytestream_put_le16  (&bs, 0);
    /* Input sample rate */
    bytestream_put_le32  (&bs, 48000);
    /* Output gain */
    bytestream_put_le16  (&bs, 0x0);
    /* Mapping family */
    bytestream_put_byte  (&bs, 0x0);

    return 0;
}

static int opus_init(AVFormatContext *s, int st_index, PayloadContext *priv_data)
{
    return opus_write_extradata(s->streams[st_index]->codecpar);
}

static int opus_parse_packet(AVFormatContext *ctx, PayloadContext *data,
                            AVStream *st, AVPacket *pkt, uint32_t *timestamp,
                            const uint8_t *buf, int len, uint16_t seq,
                            int flags)
{
    int rv;
    int duration;

    if ((rv = av_new_packet(pkt, len)) < 0)
        return rv;

    memcpy(pkt->data, buf, len);
    pkt->stream_index = st->index;

    duration = opus_duration(buf, len);
    if (duration != AVERROR_INVALIDDATA) {
        pkt->duration = duration;
    }

    return 0;
}

static int parse_fmtp(AVFormatContext *s,
                      AVStream *stream, PayloadContext *data,
                      const char *attr, const char *value)
{
    if (!strcmp(attr, "sprop-maxcapturerate")) {
        int rate = atoi(value);
        if (rate < 8000 || rate > 48000) {
            av_log(s, AV_LOG_ERROR,
                   "fmtp field 'sprop-maxcapturerate' must be between 8000 to 48000 (provided value: %s)",
                   value);
            return AVERROR_INVALIDDATA;
        }
        stream->codecpar->sample_rate = rate;
    }
    return 0;
}

static int opus_parse_sdp_line(AVFormatContext *s, int st_index,
                               PayloadContext *data, const char *line)
{
    const char *p;

    if (st_index < 0)
        return 0;

    if (av_strstart(line, "fmtp:", &p)) {
        return ff_parse_fmtp(s, s->streams[st_index], data, p, parse_fmtp);
    }
    return 0;
}

const RTPDynamicProtocolHandler ff_opus_dynamic_handler = {
    .enc_name     = "opus",
    .codec_type   = AVMEDIA_TYPE_AUDIO,
    .codec_id     = AV_CODEC_ID_OPUS,
    .parse_packet = opus_parse_packet,
    .init         = opus_init,
    .parse_sdp_a_line = opus_parse_sdp_line,
};