WHIP: Only support h264+opus codec.

1. Input stream codec should be h264 or opus.
2. For video codec profile, should be h264 baseline or constrained baseline.
3. For audio, should be 48000HZ and stereo.
4. Only support one video and audio stream.

Author: winlinvip

libavformat/rtcenc.c

@@ -1,6 +1,6 @@
 /*
- * FLV muxer
- * Copyright (c) 2003 The FFmpeg Project
+ * WebRTC muxer
+ * Copyright (c) 2023 The FFmpeg Project
  *
  * This file is part of FFmpeg.
  *
@@ -28,32 +28,116 @@
 #include "internal.h"
 #include "mux.h"
 #include "libavutil/opt.h"
+#include "libavcodec/avcodec.h"
 
 typedef struct RTCContext {
     AVClass *av_class;
+
+    /* Input audio and video codec parameters */
+    AVCodecParameters *audio_par;
+    AVCodecParameters *video_par;
 } RTCContext;
 
-static int rtc_init(struct AVFormatContext *s)
+/**
+ * Only support video(h264) and audio(opus) for now. Note that only baseline
+ * and constrained baseline of h264 are supported.
+ */
+static int check_codec(AVFormatContext *s)
+{
+    int i;
+    RTCContext *rtc = s->priv_data;
+
+    for (i = 0; i < s->nb_streams; i++) {
+        AVCodecParameters *par = s->streams[i]->codecpar;
+        const AVCodecDescriptor *desc = avcodec_descriptor_get(par->codec_id);
+        switch (par->codec_type) {
+        case AVMEDIA_TYPE_VIDEO:
+            if (rtc->video_par) {
+                av_log(s, AV_LOG_ERROR,
+                       "Only one video stream is supported by RTC\n");
+                return AVERROR(EINVAL);
+            }
+            rtc->video_par = par;
+
+            if (par->codec_id != AV_CODEC_ID_H264) {
+                av_log(s, AV_LOG_ERROR,
+                       "Unsupported video codec %s by RTC, choose h264\n",
+                       desc ? desc->name : "unknown");
+                return AVERROR(EINVAL);
+            }
+            if ((par->profile & ~FF_PROFILE_H264_CONSTRAINED) != FF_PROFILE_H264_BASELINE) {
+                av_log(s, AV_LOG_ERROR,
+                       "Profile %d of stream %d is not baseline, currently unsupported by RTC\n",
+                       par->profile, i);
+                return AVERROR(EINVAL);
+            }
+            break;
+        case AVMEDIA_TYPE_AUDIO:
+            if (rtc->audio_par) {
+                av_log(s, AV_LOG_ERROR,
+                       "Only one audio stream is supported by RTC\n");
+                return AVERROR(EINVAL);
+            }
+            rtc->audio_par = par;
+
+            if (par->codec_id != AV_CODEC_ID_OPUS) {
+                av_log(s, AV_LOG_ERROR,
+                       "Unsupported audio codec %s by RTC, choose opus\n",
+                       desc ? desc->name : "unknown");
+                return AVERROR(EINVAL);
+            }
+
+            if (par->ch_layout.nb_channels != 2) {
+                av_log(s, AV_LOG_ERROR,
+                       "Unsupported audio channels %d by RTC, choose stereo\n",
+                       par->ch_layout.nb_channels);
+                return AVERROR(EINVAL);
+            }
+
+            if (par->sample_rate != 48000) {
+                av_log(s, AV_LOG_ERROR,
+                       "Unsupported audio sample rate %d by RTC, choose 48000\n",
+                       par->sample_rate);
+                return AVERROR(EINVAL);
+            }
+            break;
+        default:
+            av_log(s, AV_LOG_ERROR,
+                   "Codec type '%s' for stream %d is not supported by RTC\n",
+                   av_get_media_type_string(par->codec_type), i);
+            return AVERROR(EINVAL);
+        }
+    }
+
+    return 0;
+}
+
+static int rtc_init(AVFormatContext *s)
 {
+    int ret;
+
+    if ((ret = check_codec(s)) < 0)
+        return ret;
+
     return 0;
 }
 
-static int rtc_write_header(struct AVFormatContext *s)
+static int rtc_write_header(AVFormatContext *s)
 {
     return 0;
 }
 
-static int rtc_write_packet(struct AVFormatContext *s, AVPacket *pkt)
+static int rtc_write_packet(AVFormatContext *s, AVPacket *pkt)
 {
     return 0;
 }
 
-static int rtc_write_trailer(struct AVFormatContext *s)
+static int rtc_write_trailer(AVFormatContext *s)
 {
     return 0;
 }
 
-static void rtc_deinit(struct AVFormatContext *s)
+static void rtc_deinit(AVFormatContext *s)
 {
 }