X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=mux.cpp;h=4f9f4d04a04d9a7221fbe696784c5b43f3158fbc;hb=c015407a3953235df07a601baa6aa8e02ba7b561;hp=ece11e117057167777023459bcc051e34b983c00;hpb=e1a58f0f4e9cd05441f1e1b43fc4c83d1f862dd7;p=nageru diff --git a/mux.cpp b/mux.cpp index ece11e1..4f9f4d0 100644 --- a/mux.cpp +++ b/mux.cpp @@ -1,5 +1,6 @@ #include +#include #include #include #include @@ -10,41 +11,59 @@ using namespace std; -Mux::Mux(AVFormatContext *avctx, int width, int height, Codec video_codec, const AVCodecContext *audio_ctx, int time_base, KeyFrameSignalReceiver *keyframe_signal_receiver) - : avctx(avctx), keyframe_signal_receiver(keyframe_signal_receiver) +struct PacketBefore { + PacketBefore(const AVFormatContext *ctx) : ctx(ctx) {} + + bool operator() (const AVPacket *a, const AVPacket *b) const { + int64_t a_dts = (a->dts == AV_NOPTS_VALUE ? a->pts : a->dts); + int64_t b_dts = (b->dts == AV_NOPTS_VALUE ? b->pts : b->dts); + AVRational a_timebase = ctx->streams[a->stream_index]->time_base; + AVRational b_timebase = ctx->streams[b->stream_index]->time_base; + if (av_compare_ts(a_dts, a_timebase, b_dts, b_timebase) != 0) { + return av_compare_ts(a_dts, a_timebase, b_dts, b_timebase) < 0; + } else { + return av_compare_ts(a->pts, a_timebase, b->pts, b_timebase) < 0; + } + } + + const AVFormatContext * const ctx; +}; + +Mux::Mux(AVFormatContext *avctx, int width, int height, Codec video_codec, const string &video_extradata, const AVCodecParameters *audio_codecpar, int time_base, std::function write_callback) + : avctx(avctx), write_callback(write_callback) { - AVCodec *codec_video = avcodec_find_encoder((video_codec == CODEC_H264) ? AV_CODEC_ID_H264 : AV_CODEC_ID_RAWVIDEO); - avstream_video = avformat_new_stream(avctx, codec_video); + avstream_video = avformat_new_stream(avctx, nullptr); if (avstream_video == nullptr) { fprintf(stderr, "avformat_new_stream() failed\n"); exit(1); } avstream_video->time_base = AVRational{1, time_base}; - avstream_video->codec->codec_type = AVMEDIA_TYPE_VIDEO; + avstream_video->codecpar->codec_type = AVMEDIA_TYPE_VIDEO; if (video_codec == CODEC_H264) { - avstream_video->codec->codec_id = AV_CODEC_ID_H264; + avstream_video->codecpar->codec_id = AV_CODEC_ID_H264; } else { assert(video_codec == CODEC_NV12); - avstream_video->codec->codec_id = AV_CODEC_ID_RAWVIDEO; - avstream_video->codec->codec_tag = avcodec_pix_fmt_to_codec_tag(AV_PIX_FMT_NV12); + avstream_video->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO; + avstream_video->codecpar->codec_tag = avcodec_pix_fmt_to_codec_tag(AV_PIX_FMT_NV12); } - avstream_video->codec->width = width; - avstream_video->codec->height = height; - avstream_video->codec->time_base = AVRational{1, time_base}; - avstream_video->codec->ticks_per_frame = 1; // or 2? + avstream_video->codecpar->width = width; + avstream_video->codecpar->height = height; // Colorspace details. Closely correspond to settings in EffectChain_finalize, // as noted in each comment. // Note that the H.264 stream also contains this information and depending on the // mux, this might simply get ignored. See sps_rbsp(). - avstream_video->codec->color_primaries = AVCOL_PRI_BT709; // RGB colorspace (inout_format.color_space). - avstream_video->codec->color_trc = AVCOL_TRC_UNSPECIFIED; // Gamma curve (inout_format.gamma_curve). - avstream_video->codec->colorspace = AVCOL_SPC_SMPTE170M; // YUV colorspace (output_ycbcr_format.luma_coefficients). - avstream_video->codec->color_range = AVCOL_RANGE_MPEG; // Full vs. limited range (output_ycbcr_format.full_range). - avstream_video->codec->chroma_sample_location = AVCHROMA_LOC_LEFT; // Chroma sample location. See chroma_offset_0[] in Mixer::subsample_chroma(). - avstream_video->codec->field_order = AV_FIELD_PROGRESSIVE; - if (avctx->oformat->flags & AVFMT_GLOBALHEADER) { - avstream_video->codec->flags = AV_CODEC_FLAG_GLOBAL_HEADER; + avstream_video->codecpar->color_primaries = AVCOL_PRI_BT709; // RGB colorspace (inout_format.color_space). + avstream_video->codecpar->color_trc = AVCOL_TRC_UNSPECIFIED; // Gamma curve (inout_format.gamma_curve). + avstream_video->codecpar->color_space = AVCOL_SPC_SMPTE170M; // YUV colorspace (output_ycbcr_format.luma_coefficients). + avstream_video->codecpar->color_range = AVCOL_RANGE_MPEG; // Full vs. limited range (output_ycbcr_format.full_range). + avstream_video->codecpar->chroma_location = AVCHROMA_LOC_LEFT; // Chroma sample location. See chroma_offset_0[] in Mixer::subsample_chroma(). + avstream_video->codecpar->field_order = AV_FIELD_PROGRESSIVE; + + if (!video_extradata.empty()) { + avstream_video->codecpar->extradata = (uint8_t *)av_malloc(video_extradata.size()); + avstream_video->codecpar->extradata_size = video_extradata.size(); + memcpy(avstream_video->codecpar->extradata, video_extradata.data(), video_extradata.size()); } avstream_audio = avformat_new_stream(avctx, nullptr); @@ -53,7 +72,10 @@ Mux::Mux(AVFormatContext *avctx, int width, int height, Codec video_codec, const exit(1); } avstream_audio->time_base = AVRational{1, time_base}; - avcodec_copy_context(avstream_audio->codec, audio_ctx); + if (avcodec_parameters_copy(avstream_audio->codecpar, audio_codecpar) < 0) { + fprintf(stderr, "avcodec_parameters_copy() failed\n"); + exit(1); + } AVDictionary *options = NULL; vector> opts = MUX_OPTS; @@ -72,8 +94,10 @@ Mux::Mux(AVFormatContext *avctx, int width, int height, Codec video_codec, const Mux::~Mux() { av_write_trailer(avctx); - av_free(avctx->pb->buffer); - av_free(avctx->pb); + if (!(avctx->oformat->flags & AVFMT_NOFILE) && + !(avctx->flags & AVFMT_FLAG_CUSTOM_IO)) { + avio_closep(&avctx->pb); + } avformat_free_context(avctx); } @@ -96,20 +120,54 @@ void Mux::add_packet(const AVPacket &pkt, int64_t pts, int64_t dts) assert(false); } - if (keyframe_signal_receiver) { - if (pkt.flags & AV_PKT_FLAG_KEY) { - av_write_frame(avctx, nullptr); - keyframe_signal_receiver->signal_keyframe(); - } - } - { - lock_guard lock(ctx_mu); - if (av_interleaved_write_frame(avctx, &pkt_copy) < 0) { - fprintf(stderr, "av_interleaved_write_frame() failed\n"); - exit(1); + lock_guard lock(mu); + if (plug_count > 0) { + plugged_packets.push_back(av_packet_clone(&pkt_copy)); + } else { + write_packet_or_die(pkt_copy); } } av_packet_unref(&pkt_copy); + + // Note: This will be wrong in the case of plugged packets, but that only happens + // for network streams, not for files, and write callbacks are only really relevant + // for files. (We don't want to do this from write_packet_or_die, as it only has + // the rescaled pts, which is unsuitable for callback.) + if (pkt.stream_index == 0 && write_callback != nullptr) { + write_callback(pts); + } +} + +void Mux::write_packet_or_die(const AVPacket &pkt) +{ + if (av_interleaved_write_frame(avctx, const_cast(&pkt)) < 0) { + fprintf(stderr, "av_interleaved_write_frame() failed\n"); + exit(1); + } + avio_flush(avctx->pb); +} + +void Mux::plug() +{ + lock_guard lock(mu); + ++plug_count; +} + +void Mux::unplug() +{ + lock_guard lock(mu); + if (--plug_count > 0) { + return; + } + assert(plug_count >= 0); + + sort(plugged_packets.begin(), plugged_packets.end(), PacketBefore(avctx)); + + for (AVPacket *pkt : plugged_packets) { + write_packet_or_die(*pkt); + av_packet_free(&pkt); + } + plugged_packets.clear(); }