X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=futatabi%2Fexport.cpp;h=1b7c59c90ae75f853b1d9eaf6b7f27a190d06996;hb=e0cb348ca42ae7057f8f5acee92a23e7eb26075f;hp=2b9f5317a0dcfb5612edde9cbcd70889ec9f7a9c;hpb=2b37c51ea17b77b88e2f7fda443109acc260aa8f;p=nageru diff --git a/futatabi/export.cpp b/futatabi/export.cpp index 2b9f531..1b7c59c 100644 --- a/futatabi/export.cpp +++ b/futatabi/export.cpp @@ -6,6 +6,7 @@ #include "frame_on_disk.h" #include "player.h" #include "shared/ffmpeg_raii.h" +#include "shared/shared_defs.h" #include "shared/timebase.h" #include @@ -23,22 +24,22 @@ using namespace std; namespace { // Only used in export_cliplist_clip_multitrack_triggered. -struct BufferedJPEG { +struct BufferedFrame { int64_t pts; - unsigned stream_idx; - string jpeg; + unsigned video_stream_idx; + string data; }; -bool write_buffered_jpegs(AVFormatContext *avctx, const vector &buffered_jpegs) +bool write_buffered_frames(AVFormatContext *avctx, const vector &buffered_frames) { - for (const BufferedJPEG &jpeg : buffered_jpegs) { + for (const BufferedFrame &frame : buffered_frames) { AVPacket pkt; av_init_packet(&pkt); - pkt.stream_index = jpeg.stream_idx; - pkt.data = (uint8_t *)jpeg.jpeg.data(); - pkt.size = jpeg.jpeg.size(); - pkt.pts = jpeg.pts; - pkt.dts = jpeg.pts; + pkt.stream_index = frame.video_stream_idx; + pkt.data = (uint8_t *)frame.data.data(); + pkt.size = frame.data.size(); + pkt.pts = frame.pts; + pkt.dts = frame.pts; pkt.flags = AV_PKT_FLAG_KEY; if (av_write_frame(avctx, &pkt) < 0) { @@ -104,7 +105,7 @@ void export_multitrack_clip(const string &filename, const Clip &clip) AVStream *avstream_video = avformat_new_stream(avctx, nullptr); if (avstream_video == nullptr) { fprintf(stderr, "avformat_new_stream() failed\n"); - exit(1); + abort(); } avstream_video->time_base = AVRational{ 1, TIMEBASE }; avstream_video->codecpar->codec_type = AVMEDIA_TYPE_VIDEO; @@ -123,6 +124,23 @@ void export_multitrack_clip(const string &filename, const Clip &clip) video_streams.push_back(avstream_video); } + // Similar, for audio streams. + vector audio_streams; + for (unsigned stream_idx = 0; stream_idx <= last_stream_idx; ++stream_idx) { + AVStream *avstream_audio = avformat_new_stream(avctx, nullptr); + if (avstream_audio == nullptr) { + fprintf(stderr, "avformat_new_stream() failed\n"); + abort(); + } + avstream_audio->time_base = AVRational{ 1, TIMEBASE }; + avstream_audio->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; + avstream_audio->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE; + avstream_audio->codecpar->channel_layout = AV_CH_LAYOUT_STEREO; + avstream_audio->codecpar->channels = 2; + avstream_audio->codecpar->sample_rate = OUTPUT_FREQUENCY; + audio_streams.push_back(avstream_audio); + } + if (avformat_write_header(avctx, nullptr) < 0) { QMessageBox msgbox; msgbox.setText("Writing header failed"); @@ -140,7 +158,7 @@ void export_multitrack_clip(const string &filename, const Clip &clip) // We buffer up to 1000 frames at a time, in a hope that we can reduce // the amount of seeking needed on rotational media. - vector buffered_jpegs; + vector buffered_frames; size_t frames_written = 0; while (num_streams_with_frames_left > 0) { // Find the stream with the lowest frame. Lower stream indexes win. @@ -163,21 +181,35 @@ void export_multitrack_clip(const string &filename, const Clip &clip) --num_streams_with_frames_left; } } - string jpeg = readers[first_frame_stream_idx].read_frame(first_frame); - int64_t scaled_pts = av_rescale_q(first_frame.pts, AVRational{ 1, TIMEBASE }, - video_streams[first_frame_stream_idx]->time_base); - buffered_jpegs.emplace_back(BufferedJPEG{ scaled_pts, first_frame_stream_idx, std::move(jpeg) }); - if (buffered_jpegs.size() >= 1000) { - if (!write_buffered_jpegs(avctx, buffered_jpegs)) { + + FrameReader::Frame frame = readers[first_frame_stream_idx].read_frame(first_frame, /*read_audio=*/true); + + // Write audio. (Before video, since that's what we expect on input.) + if (!frame.audio.empty()) { + unsigned audio_stream_idx = first_frame_stream_idx + video_streams.size(); + int64_t scaled_audio_pts = av_rescale_q(first_frame.pts, AVRational{ 1, TIMEBASE }, + audio_streams[first_frame_stream_idx]->time_base); + buffered_frames.emplace_back(BufferedFrame{ scaled_audio_pts, audio_stream_idx, std::move(frame.audio) }); + } + + // Write video. + unsigned video_stream_idx = first_frame_stream_idx; + int64_t scaled_video_pts = av_rescale_q(first_frame.pts, AVRational{ 1, TIMEBASE }, + video_streams[first_frame_stream_idx]->time_base); + buffered_frames.emplace_back(BufferedFrame{ scaled_video_pts, video_stream_idx, std::move(frame.video) }); + + // Flush to disk if required. + if (buffered_frames.size() >= 1000) { + if (!write_buffered_frames(avctx, buffered_frames)) { QMessageBox msgbox; msgbox.setText("Writing frames failed"); msgbox.exec(); unlink(filename.c_str()); return; } - frames_written += buffered_jpegs.size(); + frames_written += buffered_frames.size(); progress.setValue(frames_written); - buffered_jpegs.clear(); + buffered_frames.clear(); } if (progress.wasCanceled()) { unlink(filename.c_str()); @@ -185,14 +217,14 @@ void export_multitrack_clip(const string &filename, const Clip &clip) } } - if (!write_buffered_jpegs(avctx, buffered_jpegs)) { + if (!write_buffered_frames(avctx, buffered_frames)) { QMessageBox msgbox; msgbox.setText("Writing frames failed"); msgbox.exec(); unlink(filename.c_str()); return; } - frames_written += buffered_jpegs.size(); + frames_written += buffered_frames.size(); progress.setValue(frames_written); } @@ -223,27 +255,24 @@ void export_interpolated_clip(const string &filename, const vector &clips) progress.setMaximum(100000); progress.setValue(0); - double total_length = compute_time_left(clips, { { 0, 0.0 } }); - vector clips_with_row; + vector clips_with_id; for (const Clip &clip : clips) { - clips_with_row.emplace_back(Player::ClipWithRow{ clip, 0 }); + clips_with_id.emplace_back(ClipWithID{ clip, 0 }); } + TimeRemaining total_length = compute_total_time(clips_with_id); promise done_promise; future done = done_promise.get_future(); std::atomic current_value{ 0.0 }; - size_t clip_idx = 0; Player player(/*destination=*/nullptr, Player::FILE_STREAM_OUTPUT, closer.release()); - player.set_done_callback([&done_promise, &clip_idx, &clips] { - if (clip_idx >= clips.size()) { - done_promise.set_value(); - } + player.set_done_callback([&done_promise] { + done_promise.set_value(); }); - player.set_progress_callback([¤t_value, &clips, total_length](const std::map &player_progress) { - current_value = 1.0 - compute_time_left(clips, player_progress) / total_length; + player.set_progress_callback([¤t_value, total_length](const std::map &player_progress, TimeRemaining time_remaining) { + current_value = 1.0 - time_remaining.t / total_length.t; // Nothing to do about the infinite clips. }); - player.play(clips_with_row); + player.play(clips_with_id); while (done.wait_for(std::chrono::milliseconds(100)) != future_status::ready && !progress.wasCanceled()) { progress.setValue(lrint(100000.0 * current_value)); }