X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=h264encode.cpp;h=b329c983969e2f6696795f7afe53410ef2ff6484;hb=e45ebd282e3c6c369475ef0987945eca62ef8f58;hp=74fa8d1ff9ee17e70da9b419d33ef36630dc96c5;hpb=38ef008d6d6727b20174c4be1f741c3239dde959;p=nageru diff --git a/h264encode.cpp b/h264encode.cpp index 74fa8d1..b329c98 100644 --- a/h264encode.cpp +++ b/h264encode.cpp @@ -198,6 +198,8 @@ public: bool begin_frame(GLuint *y_tex, GLuint *cbcr_tex); RefCountedGLsync end_frame(int64_t pts, const vector &input_frames); void shutdown(); + void open_output_file(const std::string &filename); + void close_output_file(); private: struct storage_task { @@ -212,12 +214,20 @@ private: int64_t pts; }; + // So we never get negative dts. + int64_t global_delay() const { + return int64_t(ip_period - 1) * (TIMEBASE / MAX_FPS); + } + void encode_thread_func(); void encode_remaining_frames_as_p(int encoding_frame_num, int gop_start_display_frame_num, int64_t last_dts); void add_packet_for_uncompressed_frame(int64_t pts, const uint8_t *data); void encode_frame(PendingFrame frame, int encoding_frame_num, int display_frame_num, int gop_start_display_frame_num, int frame_type, int64_t pts, int64_t dts); void storage_task_thread(); + void encode_audio(const vector &audio, + int64_t audio_pts, + AVCodecContext *ctx); void storage_task_enqueue(storage_task task); void save_codeddata(storage_task task); int render_packedsequence(); @@ -326,6 +336,8 @@ private: int frame_height; int frame_width_mbaligned; int frame_height_mbaligned; + + unique_ptr file_mux; // To local disk. }; // Supposedly vaRenderPicture() is supposed to destroy the buffer implicitly, @@ -1590,8 +1602,6 @@ void H264EncoderImpl::save_codeddata(storage_task task) string data; - const int64_t global_delay = int64_t(ip_period - 1) * (TIMEBASE / MAX_FPS); // So we never get negative dts. - va_status = vaMapBuffer(va_dpy, gl_surfaces[task.display_order % SURFACE_NUM].coded_buf, (void **)(&buf_list)); CHECK_VASTATUS(va_status, "vaMapBuffer"); while (buf_list != NULL) { @@ -1614,8 +1624,12 @@ void H264EncoderImpl::save_codeddata(storage_task task) pkt.flags = 0; } //pkt.duration = 1; - httpd->add_packet(pkt, task.pts + global_delay, task.dts + global_delay, - global_flags.uncompressed_video_to_http ? HTTPD::DESTINATION_FILE_ONLY : HTTPD::DESTINATION_FILE_AND_HTTP); + if (file_mux) { + file_mux->add_packet(pkt, task.pts + global_delay(), task.dts + global_delay()); + } + if (!global_flags.uncompressed_video_to_http) { + httpd->add_packet(pkt, task.pts + global_delay(), task.dts + global_delay()); + } } // Encode and add all audio frames up to and including the pts of this video frame. for ( ;; ) { @@ -1632,11 +1646,34 @@ void H264EncoderImpl::save_codeddata(storage_task task) pending_audio_frames.erase(it); } - audio_frame->nb_samples = audio.size() / 2; - audio_frame->format = AV_SAMPLE_FMT_S32; - audio_frame->channel_layout = AV_CH_LAYOUT_STEREO; + encode_audio(audio, audio_pts, context_audio); + + if (audio_pts == task.pts) break; + } +} - unique_ptr int_samples(new int32_t[audio.size()]); +void H264EncoderImpl::encode_audio( + const vector &audio, + int64_t audio_pts, + AVCodecContext *ctx) +{ + audio_frame->nb_samples = audio.size() / 2; + audio_frame->channel_layout = AV_CH_LAYOUT_STEREO; + + unique_ptr planar_samples; + unique_ptr int_samples; + + if (ctx->sample_fmt == AV_SAMPLE_FMT_FLTP) { + audio_frame->format = AV_SAMPLE_FMT_FLTP; + planar_samples.reset(new float[audio.size()]); + avcodec_fill_audio_frame(audio_frame, 2, AV_SAMPLE_FMT_FLTP, (const uint8_t*)planar_samples.get(), audio.size() * sizeof(float), 0); + for (int i = 0; i < audio_frame->nb_samples; ++i) { + planar_samples[i] = audio[i * 2 + 0]; + planar_samples[i + audio_frame->nb_samples] = audio[i * 2 + 1]; + } + } else { + assert(ctx->sample_fmt == AV_SAMPLE_FMT_S32); + int_samples.reset(new int32_t[audio.size()]); int ret = avcodec_fill_audio_frame(audio_frame, 2, AV_SAMPLE_FMT_S32, (const uint8_t*)int_samples.get(), audio.size() * sizeof(int32_t), 1); if (ret < 0) { fprintf(stderr, "avcodec_fill_audio_frame() failed with %d\n", ret); @@ -1651,26 +1688,27 @@ void H264EncoderImpl::save_codeddata(storage_task task) int_samples[i] = lrintf(audio[i] * 2147483647.0f); } } + } - AVPacket pkt; - av_init_packet(&pkt); - pkt.data = nullptr; - pkt.size = 0; - int got_output; - avcodec_encode_audio2(context_audio, &pkt, audio_frame, &got_output); - if (got_output) { - pkt.stream_index = 1; - pkt.flags = AV_PKT_FLAG_KEY; - httpd->add_packet(pkt, audio_pts + global_delay, audio_pts + global_delay, HTTPD::DESTINATION_FILE_AND_HTTP); + AVPacket pkt; + av_init_packet(&pkt); + pkt.data = nullptr; + pkt.size = 0; + int got_output = 0; + avcodec_encode_audio2(context_audio, &pkt, audio_frame, &got_output); + if (got_output) { + pkt.stream_index = 1; + pkt.flags = AV_PKT_FLAG_KEY; + if (file_mux) { + file_mux->add_packet(pkt, audio_pts + global_delay(), audio_pts + global_delay()); } - // TODO: Delayed frames. - av_frame_unref(audio_frame); - av_free_packet(&pkt); - if (audio_pts == task.pts) break; + httpd->add_packet(pkt, audio_pts + global_delay(), audio_pts + global_delay()); } + // TODO: Delayed frames. + av_frame_unref(audio_frame); + av_free_packet(&pkt); } - // this is weird. but it seems to put a new frame onto the queue void H264EncoderImpl::storage_task_enqueue(storage_task task) { @@ -1739,22 +1777,52 @@ int H264EncoderImpl::deinit_va() return 0; } +namespace { -H264EncoderImpl::H264EncoderImpl(QSurface *surface, const string &va_display, int width, int height, HTTPD *httpd) - : current_storage_frame(0), surface(surface), httpd(httpd) +void init_audio_encoder(const string &codec_name, int bit_rate, AVCodecContext **ctx) { - AVCodec *codec_audio = avcodec_find_encoder(AUDIO_OUTPUT_CODEC); - context_audio = avcodec_alloc_context3(codec_audio); - context_audio->bit_rate = AUDIO_OUTPUT_BIT_RATE; + AVCodec *codec_audio = avcodec_find_encoder_by_name(codec_name.c_str()); + if (codec_audio == nullptr) { + fprintf(stderr, "ERROR: Could not find codec '%s'\n", codec_name.c_str()); + exit(1); + } + + AVCodecContext *context_audio = avcodec_alloc_context3(codec_audio); + context_audio->bit_rate = bit_rate; context_audio->sample_rate = OUTPUT_FREQUENCY; - context_audio->sample_fmt = AUDIO_OUTPUT_SAMPLE_FMT; + + // Choose sample format; we currently only support these two + // (see encode_audio), so we're a bit picky. + const AVSampleFormat *ptr = codec_audio->sample_fmts; + for ( ; *ptr != -1; ++ptr) { + if (*ptr == AV_SAMPLE_FMT_FLTP || *ptr == AV_SAMPLE_FMT_S32) { + context_audio->sample_fmt = *ptr; + break; + } + } + if (*ptr == -1) { + fprintf(stderr, "ERROR: Audio codec does not support fltp or s32 sample formats\n"); + exit(1); + } + context_audio->channels = 2; context_audio->channel_layout = AV_CH_LAYOUT_STEREO; context_audio->time_base = AVRational{1, TIMEBASE}; if (avcodec_open2(context_audio, codec_audio, NULL) < 0) { - fprintf(stderr, "Could not open codec\n"); + fprintf(stderr, "Could not open codec '%s'\n", codec_name.c_str()); exit(1); } + + *ctx = context_audio; +} + +} // namespace + +H264EncoderImpl::H264EncoderImpl(QSurface *surface, const string &va_display, int width, int height, HTTPD *httpd) + : current_storage_frame(0), surface(surface), httpd(httpd) +{ + init_audio_encoder(AUDIO_OUTPUT_CODEC_NAME, AUDIO_OUTPUT_BIT_RATE, &context_audio); + audio_frame = av_frame_alloc(); frame_width = width; @@ -1953,6 +2021,29 @@ void H264EncoderImpl::shutdown() is_shutdown = true; } +void H264EncoderImpl::open_output_file(const std::string &filename) +{ + AVFormatContext *avctx = avformat_alloc_context(); + avctx->oformat = av_guess_format(NULL, filename.c_str(), NULL); + assert(filename.size() < sizeof(avctx->filename) - 1); + strcpy(avctx->filename, filename.c_str()); + + string url = "file:" + filename; + int ret = avio_open2(&avctx->pb, url.c_str(), AVIO_FLAG_WRITE, &avctx->interrupt_callback, NULL); + if (ret < 0) { + char tmp[AV_ERROR_MAX_STRING_SIZE]; + fprintf(stderr, "%s: avio_open2() failed: %s\n", filename.c_str(), av_make_error_string(tmp, sizeof(tmp), ret)); + exit(1); + } + + file_mux.reset(new Mux(avctx, frame_width, frame_height, Mux::CODEC_H264, TIMEBASE)); +} + +void H264EncoderImpl::close_output_file() +{ + file_mux.reset(); +} + void H264EncoderImpl::encode_thread_func() { int64_t last_dts = -1; @@ -2036,7 +2127,7 @@ void H264EncoderImpl::add_packet_for_uncompressed_frame(int64_t pts, const uint8 pkt.size = frame_width * frame_height * 2; pkt.stream_index = 0; pkt.flags = AV_PKT_FLAG_KEY; - httpd->add_packet(pkt, pts, pts, HTTPD::DESTINATION_HTTP_ONLY); + httpd->add_packet(pkt, pts, pts); } namespace { @@ -2093,8 +2184,8 @@ void H264EncoderImpl::encode_frame(H264EncoderImpl::PendingFrame frame, int enco if (global_flags.uncompressed_video_to_http) { // Add uncompressed video. (Note that pts == dts here.) - const int64_t global_delay = int64_t(ip_period - 1) * (TIMEBASE / MAX_FPS); // Needs to match audio. - pair output_frame = reorderer->reorder_frame(pts + global_delay, reinterpret_cast(surf->y_ptr)); + // Delay needs to match audio. + pair output_frame = reorderer->reorder_frame(pts + global_delay(), reinterpret_cast(surf->y_ptr)); if (output_frame.second != nullptr) { add_packet_for_uncompressed_frame(output_frame.first, output_frame.second); } @@ -2164,4 +2255,12 @@ void H264Encoder::shutdown() impl->shutdown(); } -// Real class. +void H264Encoder::open_output_file(const std::string &filename) +{ + impl->open_output_file(filename); +} + +void H264Encoder::close_output_file() +{ + impl->close_output_file(); +}