Make it possible for file and HTTP streams to use different audio codecs.

[nageru] / h264encode.cpp

diff --git a/h264encode.cpp b/h264encode.cpp
index b329c983969e2f6696795f7afe53410ef2ff6484..8f4508835c0a2f3d57a02c5e5c52f258f73344c2 100644 (file)
--- a/h264encode.cpp
+++ b/h264encode.cpp
@@ -226,8 +226,15 @@ private:
                          int frame_type, int64_t pts, int64_t dts);
        void storage_task_thread();
        void encode_audio(const vector<float> &audio,
+                         vector<float> *audio_queue,
                          int64_t audio_pts,
-                         AVCodecContext *ctx);
+                         AVCodecContext *ctx,
+                         const vector<PacketDestination *> &destinations);
+       void encode_audio_one_frame(const float *audio,
+                                   size_t num_samples,  // In each channel.
+                                   int64_t audio_pts,
+                                   AVCodecContext *ctx,
+                                   const vector<PacketDestination *> &destinations);
        void storage_task_enqueue(storage_task task);
        void save_codeddata(storage_task task);
        int render_packedsequence();
@@ -274,7 +281,12 @@ private:
        map<int64_t, vector<float>> pending_audio_frames;  // under frame_queue_mutex
        QSurface *surface;
 
-       AVCodecContext *context_audio;
+       AVCodecContext *context_audio_file;
+       AVCodecContext *context_audio_stream = nullptr;  // nullptr = don't code separate audio for stream.
+
+       vector<float> audio_queue_file;
+       vector<float> audio_queue_stream;
+
        AVFrame *audio_frame = nullptr;
        HTTPD *httpd;
        unique_ptr<FrameReorderer> reorderer;
@@ -1646,7 +1658,12 @@ void H264EncoderImpl::save_codeddata(storage_task task)
                        pending_audio_frames.erase(it); 
                }
 
-               encode_audio(audio, audio_pts, context_audio);
+               if (context_audio_stream) {
+                       encode_audio(audio, &audio_queue_file, audio_pts, context_audio_file, { file_mux.get() });
+                       encode_audio(audio, &audio_queue_stream, audio_pts, context_audio_stream, { httpd });
+               } else {
+                       encode_audio(audio, &audio_queue_file, audio_pts, context_audio_file, { httpd, file_mux.get() });
+               }
 
                if (audio_pts == task.pts) break;
        }
@@ -1654,10 +1671,41 @@ void H264EncoderImpl::save_codeddata(storage_task task)
 
 void H264EncoderImpl::encode_audio(
        const vector<float> &audio,
+       vector<float> *audio_queue,
        int64_t audio_pts,
-       AVCodecContext *ctx)
+       AVCodecContext *ctx,
+       const vector<PacketDestination *> &destinations)
 {
-       audio_frame->nb_samples = audio.size() / 2;
+       if (ctx->frame_size == 0) {
+               // No queueing needed.
+               assert(audio_queue->empty());
+               assert(audio.size() % 2 == 0);
+               encode_audio_one_frame(&audio[0], audio.size() / 2, audio_pts, ctx, destinations);
+               return;
+       }
+
+       audio_queue->insert(audio_queue->end(), audio.begin(), audio.end());
+       size_t sample_num;
+       for (sample_num = 0;
+            sample_num + ctx->frame_size * 2 <= audio_queue->size();
+            sample_num += ctx->frame_size * 2) {
+               encode_audio_one_frame(&(*audio_queue)[sample_num],
+                                      ctx->frame_size,
+                                      audio_pts,
+                                      ctx,
+                                      destinations);
+       }
+       audio_queue->erase(audio_queue->begin(), audio_queue->begin() + sample_num);
+}
+
+void H264EncoderImpl::encode_audio_one_frame(
+       const float *audio,
+       size_t num_samples,
+       int64_t audio_pts,
+       AVCodecContext *ctx,
+       const vector<PacketDestination *> &destinations)
+{
+       audio_frame->nb_samples = num_samples;
        audio_frame->channel_layout = AV_CH_LAYOUT_STEREO;
 
        unique_ptr<float[]> planar_samples;
@@ -1665,21 +1713,21 @@ void H264EncoderImpl::encode_audio(
 
        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.reset(new float[num_samples * 2]);
+               avcodec_fill_audio_frame(audio_frame, 2, AV_SAMPLE_FMT_FLTP, (const uint8_t*)planar_samples.get(), num_samples * 2 * sizeof(float), 0);
+               for (size_t i = 0; i < num_samples; ++i) {
                        planar_samples[i] = audio[i * 2 + 0];
-                       planar_samples[i + audio_frame->nb_samples] = audio[i * 2 + 1];
+                       planar_samples[i + num_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);
+               int_samples.reset(new int32_t[num_samples * 2]);
+               int ret = avcodec_fill_audio_frame(audio_frame, 2, AV_SAMPLE_FMT_S32, (const uint8_t*)int_samples.get(), num_samples * 2 * sizeof(int32_t), 1);
                if (ret < 0) {
                        fprintf(stderr, "avcodec_fill_audio_frame() failed with %d\n", ret);
                        exit(1);
                }
-               for (int i = 0; i < audio_frame->nb_samples * 2; ++i) {
+               for (size_t i = 0; i < num_samples * 2; ++i) {
                        if (audio[i] >= 1.0f) {
                                int_samples[i] = 2147483647;
                        } else if (audio[i] <= -1.0f) {
@@ -1695,14 +1743,13 @@ void H264EncoderImpl::encode_audio(
        pkt.data = nullptr;
        pkt.size = 0;
        int got_output = 0;
-       avcodec_encode_audio2(context_audio, &pkt, audio_frame, &got_output);
+       avcodec_encode_audio2(ctx, &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());
+               for (PacketDestination *dest : destinations) {
+                       dest->add_packet(pkt, audio_pts + global_delay(), audio_pts + global_delay());
                }
-               httpd->add_packet(pkt, audio_pts + global_delay(), audio_pts + global_delay());
        }
        // TODO: Delayed frames.
        av_frame_unref(audio_frame);
@@ -1821,7 +1868,12 @@ void init_audio_encoder(const string &codec_name, int bit_rate, AVCodecContext *
 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);
+       init_audio_encoder(AUDIO_OUTPUT_CODEC_NAME, DEFAULT_AUDIO_OUTPUT_BIT_RATE, &context_audio_file);
+
+       if (!global_flags.stream_audio_codec_name.empty()) {
+               init_audio_encoder(global_flags.stream_audio_codec_name,
+                       global_flags.stream_audio_codec_bitrate, &context_audio_stream);
+       }
 
        audio_frame = av_frame_alloc();
 
@@ -2036,7 +2088,7 @@ void H264EncoderImpl::open_output_file(const std::string &filename)
                exit(1);
        }
 
-       file_mux.reset(new Mux(avctx, frame_width, frame_height, Mux::CODEC_H264, TIMEBASE));
+       file_mux.reset(new Mux(avctx, frame_width, frame_height, Mux::CODEC_H264, TIMEBASE, DEFAULT_AUDIO_OUTPUT_BIT_RATE));
 }
 
 void H264EncoderImpl::close_output_file()