X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=nageru%2Fkaeru.cpp;h=1699d243491900f45a1c1fdfb8f0db7bc3efc874;hb=2f92c975a3cf9f4803a58267fd2a12765e34a69e;hp=0e555862969234246087ed4f2436015d95db35db;hpb=af8007aa958271ba16b15e7d11a891570488f6c9;p=nageru diff --git a/nageru/kaeru.cpp b/nageru/kaeru.cpp index 0e55586..1699d24 100644 --- a/nageru/kaeru.cpp +++ b/nageru/kaeru.cpp @@ -6,7 +6,7 @@ #include "flags.h" #include "ffmpeg_capture.h" #include "mixer.h" -#include "mux.h" +#include "shared/mux.h" #include "quittable_sleeper.h" #include "shared/timebase.h" #include "x264_encoder.h" @@ -18,6 +18,10 @@ #include #include +extern "C" { +#include +} + using namespace bmusb; using namespace movit; using namespace std; @@ -31,6 +35,8 @@ BasicStats *global_basic_stats = nullptr; QuittableSleeper should_quit; MuxMetrics stream_mux_metrics; +namespace { + int write_packet(void *opaque, uint8_t *buf, int buf_size, AVIODataMarkerType type, int64_t time) { static bool seen_sync_markers = false; @@ -45,19 +51,22 @@ int write_packet(void *opaque, uint8_t *buf, int buf_size, AVIODataMarkerType ty type = AVIO_DATA_MARKER_SYNC_POINT; } + HTTPD::StreamID stream_id{ HTTPD::MAIN_STREAM, 0 }; if (type == AVIO_DATA_MARKER_HEADER) { stream_mux_header.append((char *)buf, buf_size); - httpd->set_header(stream_mux_header); + httpd->set_header(stream_id, stream_mux_header); } else { - httpd->add_data((char *)buf, buf_size, type == AVIO_DATA_MARKER_SYNC_POINT, time, AVRational{ AV_TIME_BASE, 1 }); + httpd->add_data(stream_id, (char *)buf, buf_size, type == AVIO_DATA_MARKER_SYNC_POINT, time, AVRational{ AV_TIME_BASE, 1 }); } return buf_size; } -unique_ptr create_mux(HTTPD *httpd, AVOutputFormat *oformat, X264Encoder *x264_encoder, AudioEncoder *audio_encoder) +} // namespace + +unique_ptr create_mux(HTTPD *httpd, const AVOutputFormat *oformat, X264Encoder *x264_encoder, AudioEncoder *audio_encoder) { AVFormatContext *avctx = avformat_alloc_context(); - avctx->oformat = oformat; + avctx->oformat = const_castoformat)>(oformat); // const_cast is a hack to work in FFmpeg both before and after 5.0. uint8_t *buf = (uint8_t *)av_malloc(MUX_BUFFER_SIZE); avctx->pb = avio_alloc_context(buf, MUX_BUFFER_SIZE, 1, httpd, nullptr, nullptr, nullptr); @@ -67,8 +76,14 @@ unique_ptr create_mux(HTTPD *httpd, AVOutputFormat *oformat, X264Encoder *x string video_extradata = x264_encoder->get_global_headers(); + // If audio is disabled (ie., we won't ever see any audio packets), + // set nullptr here to also not include the stream in the mux. + AVCodecParameters *audio_codecpar = + global_flags.enable_audio ? audio_encoder->get_codec_parameters().release() : nullptr; + unique_ptr mux; - mux.reset(new Mux(avctx, global_flags.width, global_flags.height, Mux::CODEC_H264, video_extradata, audio_encoder->get_codec_parameters().get(), COARSE_TIMEBASE, + mux.reset(new Mux(avctx, global_flags.width, global_flags.height, Mux::CODEC_H264, video_extradata, audio_codecpar, + get_color_space(global_flags.ycbcr_rec709_coefficients), COARSE_TIMEBASE, /*write_callback=*/nullptr, Mux::WRITE_FOREGROUND, { &stream_mux_metrics })); stream_mux_metrics.init({{ "destination", "http" }}); return mux; @@ -86,7 +101,7 @@ void video_frame_callback(FFmpegCapture *video, X264Encoder *x264_encoder, Audio ts.ts.push_back(steady_clock::now()); video_pts = av_rescale_q(video_pts, video_timebase, AVRational{ 1, TIMEBASE }); - int64_t frame_duration = TIMEBASE * video_format.frame_rate_den / video_format.frame_rate_nom; + int64_t frame_duration = int64_t(TIMEBASE) * video_format.frame_rate_den / video_format.frame_rate_nom; x264_encoder->add_frame(video_pts, frame_duration, video->get_current_frame_ycbcr_format().luma_coefficients, video_frame.data + video_offset, ts); global_basic_stats->update(frame_num++, /*dropped_frames=*/0); } @@ -99,17 +114,18 @@ void video_frame_callback(FFmpegCapture *video, X264Encoder *x264_encoder, Audio size_t num_samples = audio_frame.len / (audio_format.bits_per_sample / 8); vector float_samples; float_samples.resize(num_samples); + if (audio_format.bits_per_sample == 16) { const int16_t *src = (const int16_t *)audio_frame.data; float *dst = &float_samples[0]; for (size_t i = 0; i < num_samples; ++i) { - *dst++ = le16toh(*src++) * (1.0f / 32768.0f); + *dst++ = int16_t(le16toh(*src++)) * (1.0f / 32768.0f); } } else if (audio_format.bits_per_sample == 32) { const int32_t *src = (const int32_t *)audio_frame.data; float *dst = &float_samples[0]; for (size_t i = 0; i < num_samples; ++i) { - *dst++ = le32toh(*src++) * (1.0f / 2147483648.0f); + *dst++ = int32_t(le32toh(*src++)) * (1.0f / 2147483648.0f); } } else { assert(false); @@ -126,9 +142,37 @@ void video_frame_callback(FFmpegCapture *video, X264Encoder *x264_encoder, Audio } } -void audio_frame_callback(Mux *mux, const AVPacket *pkt, AVRational timebase) +void raw_packet_callback(Mux *mux, int stream_index, const AVPacket *pkt, AVRational timebase) { - mux->add_packet(*pkt, pkt->pts, pkt->dts == AV_NOPTS_VALUE ? pkt->pts : pkt->dts, timebase, /*stream_index=*/1); + mux->add_packet(*pkt, pkt->pts, pkt->dts == AV_NOPTS_VALUE ? pkt->pts : pkt->dts, timebase, stream_index); +} + +void filter_packet_callback(Mux *mux, int stream_index, AVBSFContext *bsfctx, const AVPacket *pkt, AVRational timebase) +{ + if (pkt->size <= 2 || pkt->data[0] != 0xff || (pkt->data[1] & 0xf0) != 0xf0) { + // Not ADTS data, so just pass it through. + mux->add_packet(*pkt, pkt->pts, pkt->dts == AV_NOPTS_VALUE ? pkt->pts : pkt->dts, timebase, stream_index); + return; + } + + AVPacket *in_pkt = av_packet_clone(pkt); + unique_ptr in_pkt_cleanup(in_pkt, av_packet_unref); + int err = av_bsf_send_packet(bsfctx, in_pkt); + if (err < 0) { + fprintf(stderr, "av_bsf_send_packet() failed with %d, ignoring\n", err); + } + for ( ;; ) { + AVPacketWithDeleter out_pkt = av_packet_alloc_unique(); + err = av_bsf_receive_packet(bsfctx, out_pkt.get()); + if (err == AVERROR(EAGAIN)) { + break; + } + if (err < 0) { + fprintf(stderr, "av_bsf_receive_packet() failed with %d, ignoring\n", err); + return; + } + mux->add_packet(*out_pkt, out_pkt->pts, out_pkt->dts == AV_NOPTS_VALUE ? out_pkt->pts : out_pkt->dts, timebase, stream_index); + } } void adjust_bitrate(int signal) @@ -167,9 +211,9 @@ int main(int argc, char *argv[]) parse_flags(PROGRAM_KAERU, argc, argv); if (optind + 1 != argc) { usage(PROGRAM_KAERU); - exit(1); + abort(); } - global_flags.num_cards = 1; // For latency metrics. + global_flags.max_num_cards = 1; // For latency metrics. #if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(58, 9, 100) av_register_all(); @@ -178,7 +222,7 @@ int main(int argc, char *argv[]) HTTPD httpd; - AVOutputFormat *oformat = av_guess_format(global_flags.stream_mux_name.c_str(), nullptr, nullptr); + const AVOutputFormat *oformat = av_guess_format(global_flags.stream_mux_name.c_str(), nullptr, nullptr); assert(oformat != nullptr); unique_ptr audio_encoder; @@ -188,23 +232,43 @@ int main(int argc, char *argv[]) audio_encoder.reset(new AudioEncoder(global_flags.stream_audio_codec_name, global_flags.stream_audio_codec_bitrate, oformat)); } - unique_ptr x264_encoder(new X264Encoder(oformat)); + unique_ptr x264_encoder(new X264Encoder(oformat, /*use_separate_disk_params=*/false)); unique_ptr http_mux = create_mux(&httpd, oformat, x264_encoder.get(), audio_encoder.get()); if (global_flags.transcode_audio) { audio_encoder->add_mux(http_mux.get()); } - x264_encoder->add_mux(http_mux.get()); + if (global_flags.transcode_video) { + x264_encoder->add_mux(http_mux.get()); + } global_x264_encoder = x264_encoder.get(); FFmpegCapture video(argv[optind], global_flags.width, global_flags.height); video.set_pixel_format(FFmpegCapture::PixelFormat_NV12); - video.set_frame_callback(bind(video_frame_callback, &video, x264_encoder.get(), audio_encoder.get(), _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11)); - if (!global_flags.transcode_audio) { - video.set_audio_callback(bind(audio_frame_callback, http_mux.get(), _1, _2)); + if (global_flags.transcode_video) { + video.set_frame_callback(bind(video_frame_callback, &video, x264_encoder.get(), audio_encoder.get(), _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11)); + } else { + video.set_video_callback(bind(raw_packet_callback, http_mux.get(), /*stream_index=*/0, _1, _2)); + } + if (!global_flags.transcode_audio && global_flags.enable_audio) { + AVBSFContext *bsfctx = nullptr; + if (strcmp(oformat->name, "mp4") == 0 && strcmp(audio_encoder->get_codec()->name, "aac") == 0) { + // We need to insert the aac_adtstoasc filter, seemingly (or we will get warnings to do so). + const AVBitStreamFilter *filter = av_bsf_get_by_name("aac_adtstoasc"); + int err = av_bsf_alloc(filter, &bsfctx); + if (err < 0) { + fprintf(stderr, "av_bsf_alloc() failed with %d\n", err); + exit(1); + } + } + if (bsfctx == nullptr) { + video.set_audio_callback(bind(raw_packet_callback, http_mux.get(), /*stream_index=*/1, _1, _2)); + } else { + video.set_audio_callback(bind(filter_packet_callback, http_mux.get(), /*stream_index=*/1, bsfctx, _1, _2)); + } } video.configure_card(); video.start_bm_capture(); - video.change_rate(2.0); // Be sure never to really fall behind, but also don't dump huge amounts of stuff onto x264. + video.change_rate(10.0); // Play as fast as possible. BasicStats basic_stats(/*verbose=*/false, /*use_opengl=*/false); global_basic_stats = &basic_stats; @@ -220,6 +284,7 @@ int main(int argc, char *argv[]) video.stop_dequeue_thread(); // Stop the x264 encoder before killing the mux it's writing to. + global_x264_encoder = nullptr; x264_encoder.reset(); return 0; }