blob: f1dc1d65e3873cf85fc13e2d4bf0425e28613181 [file] [log] [blame]
sprang3911c262016-04-15 01:24:14 -07001/*
2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020011#include "modules/video_coding/utility/ivf_file_writer.h"
sprang3911c262016-04-15 01:24:14 -070012
palmkviste75f2042016-09-28 06:19:48 -070013#include <utility>
14
Mirko Bonadei04255172018-09-10 16:48:02 +020015#include "api/video_codecs/video_codec.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020016#include "modules/rtp_rtcp/source/byte_io.h"
17#include "rtc_base/checks.h"
18#include "rtc_base/logging.h"
sprang3911c262016-04-15 01:24:14 -070019
palmkviste75f2042016-09-28 06:19:48 -070020// TODO(palmkvist): make logging more informative in the absence of a file name
21// (or get one)
22
sprang3911c262016-04-15 01:24:14 -070023namespace webrtc {
24
palmkviste75f2042016-09-28 06:19:48 -070025const size_t kIvfHeaderSize = 32;
26
Niels Möllerb7edf692019-02-08 16:40:53 +010027IvfFileWriter::IvfFileWriter(FileWrapper file, size_t byte_limit)
Kári Tristan Helgason84ccb2d2018-08-16 14:35:26 +020028 : codec_type_(kVideoCodecGeneric),
palmkviste75f2042016-09-28 06:19:48 -070029 bytes_written_(0),
30 byte_limit_(byte_limit),
sprang3911c262016-04-15 01:24:14 -070031 num_frames_(0),
32 width_(0),
33 height_(0),
34 last_timestamp_(-1),
35 using_capture_timestamps_(false),
palmkviste75f2042016-09-28 06:19:48 -070036 file_(std::move(file)) {
37 RTC_DCHECK(byte_limit == 0 || kIvfHeaderSize <= byte_limit)
38 << "The byte_limit is too low, not even the header will fit.";
39}
sprang3911c262016-04-15 01:24:14 -070040
41IvfFileWriter::~IvfFileWriter() {
42 Close();
43}
44
Niels Möllerb7edf692019-02-08 16:40:53 +010045std::unique_ptr<IvfFileWriter> IvfFileWriter::Wrap(FileWrapper file,
palmkviste75f2042016-09-28 06:19:48 -070046 size_t byte_limit) {
47 return std::unique_ptr<IvfFileWriter>(
48 new IvfFileWriter(std::move(file), byte_limit));
sprang3911c262016-04-15 01:24:14 -070049}
50
51bool IvfFileWriter::WriteHeader() {
Niels Möllerb7edf692019-02-08 16:40:53 +010052 if (!file_.Rewind()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +010053 RTC_LOG(LS_WARNING) << "Unable to rewind ivf output file.";
sprang3911c262016-04-15 01:24:14 -070054 return false;
55 }
56
57 uint8_t ivf_header[kIvfHeaderSize] = {0};
58 ivf_header[0] = 'D';
59 ivf_header[1] = 'K';
60 ivf_header[2] = 'I';
61 ivf_header[3] = 'F';
62 ByteWriter<uint16_t>::WriteLittleEndian(&ivf_header[4], 0); // Version.
63 ByteWriter<uint16_t>::WriteLittleEndian(&ivf_header[6], 32); // Header size.
64
65 switch (codec_type_) {
kjellander02b3d272016-04-20 05:05:54 -070066 case kVideoCodecVP8:
sprang3911c262016-04-15 01:24:14 -070067 ivf_header[8] = 'V';
68 ivf_header[9] = 'P';
69 ivf_header[10] = '8';
70 ivf_header[11] = '0';
71 break;
kjellander02b3d272016-04-20 05:05:54 -070072 case kVideoCodecVP9:
sprang3911c262016-04-15 01:24:14 -070073 ivf_header[8] = 'V';
74 ivf_header[9] = 'P';
75 ivf_header[10] = '9';
76 ivf_header[11] = '0';
77 break;
kjellander02b3d272016-04-20 05:05:54 -070078 case kVideoCodecH264:
sprang3911c262016-04-15 01:24:14 -070079 ivf_header[8] = 'H';
80 ivf_header[9] = '2';
81 ivf_header[10] = '6';
82 ivf_header[11] = '4';
83 break;
84 default:
Mirko Bonadei675513b2017-11-09 11:09:25 +010085 RTC_LOG(LS_ERROR) << "Unknown CODEC type: " << codec_type_;
sprang3911c262016-04-15 01:24:14 -070086 return false;
87 }
88
89 ByteWriter<uint16_t>::WriteLittleEndian(&ivf_header[12], width_);
90 ByteWriter<uint16_t>::WriteLittleEndian(&ivf_header[14], height_);
91 // Render timestamps are in ms (1/1000 scale), while RTP timestamps use a
92 // 90kHz clock.
93 ByteWriter<uint32_t>::WriteLittleEndian(
94 &ivf_header[16], using_capture_timestamps_ ? 1000 : 90000);
95 ByteWriter<uint32_t>::WriteLittleEndian(&ivf_header[20], 1);
96 ByteWriter<uint32_t>::WriteLittleEndian(&ivf_header[24],
97 static_cast<uint32_t>(num_frames_));
98 ByteWriter<uint32_t>::WriteLittleEndian(&ivf_header[28], 0); // Reserved.
99
Niels Möllerb7edf692019-02-08 16:40:53 +0100100 if (!file_.Write(ivf_header, kIvfHeaderSize)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100101 RTC_LOG(LS_ERROR) << "Unable to write IVF header for ivf output file.";
sprang3911c262016-04-15 01:24:14 -0700102 return false;
103 }
104
palmkviste75f2042016-09-28 06:19:48 -0700105 if (bytes_written_ < kIvfHeaderSize) {
106 bytes_written_ = kIvfHeaderSize;
107 }
108
sprang3911c262016-04-15 01:24:14 -0700109 return true;
110}
111
palmkviste75f2042016-09-28 06:19:48 -0700112bool IvfFileWriter::InitFromFirstFrame(const EncodedImage& encoded_image,
113 VideoCodecType codec_type) {
sprang3911c262016-04-15 01:24:14 -0700114 width_ = encoded_image._encodedWidth;
115 height_ = encoded_image._encodedHeight;
116 RTC_CHECK_GT(width_, 0);
117 RTC_CHECK_GT(height_, 0);
Niels Möller23775882018-08-16 10:24:12 +0200118 using_capture_timestamps_ = encoded_image.Timestamp() == 0;
sprang3911c262016-04-15 01:24:14 -0700119
palmkviste75f2042016-09-28 06:19:48 -0700120 codec_type_ = codec_type;
121
sprang3911c262016-04-15 01:24:14 -0700122 if (!WriteHeader())
123 return false;
124
Yves Gerey665174f2018-06-19 15:03:05 +0200125 const char* codec_name = CodecTypeToPayloadString(codec_type_);
Mirko Bonadei675513b2017-11-09 11:09:25 +0100126 RTC_LOG(LS_WARNING) << "Created IVF file for codec data of type "
127 << codec_name << " at resolution " << width_ << " x "
128 << height_ << ", using "
129 << (using_capture_timestamps_ ? "1" : "90")
130 << "kHz clock resolution.";
sprang3911c262016-04-15 01:24:14 -0700131 return true;
132}
133
palmkviste75f2042016-09-28 06:19:48 -0700134bool IvfFileWriter::WriteFrame(const EncodedImage& encoded_image,
135 VideoCodecType codec_type) {
Niels Möllerb7edf692019-02-08 16:40:53 +0100136 if (!file_.is_open())
sprang3911c262016-04-15 01:24:14 -0700137 return false;
138
palmkviste75f2042016-09-28 06:19:48 -0700139 if (num_frames_ == 0 && !InitFromFirstFrame(encoded_image, codec_type))
140 return false;
141 RTC_DCHECK_EQ(codec_type_, codec_type);
142
sprang3911c262016-04-15 01:24:14 -0700143 if ((encoded_image._encodedWidth > 0 || encoded_image._encodedHeight > 0) &&
144 (encoded_image._encodedHeight != height_ ||
145 encoded_image._encodedWidth != width_)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100146 RTC_LOG(LS_WARNING)
sprang3911c262016-04-15 01:24:14 -0700147 << "Incomig frame has diffferent resolution then previous: (" << width_
148 << "x" << height_ << ") -> (" << encoded_image._encodedWidth << "x"
149 << encoded_image._encodedHeight << ")";
150 }
151
152 int64_t timestamp = using_capture_timestamps_
153 ? encoded_image.capture_time_ms_
Niels Möller23775882018-08-16 10:24:12 +0200154 : wrap_handler_.Unwrap(encoded_image.Timestamp());
sprang3911c262016-04-15 01:24:14 -0700155 if (last_timestamp_ != -1 && timestamp <= last_timestamp_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100156 RTC_LOG(LS_WARNING) << "Timestamp no increasing: " << last_timestamp_
157 << " -> " << timestamp;
sprang3911c262016-04-15 01:24:14 -0700158 }
159 last_timestamp_ = timestamp;
160
161 const size_t kFrameHeaderSize = 12;
palmkviste75f2042016-09-28 06:19:48 -0700162 if (byte_limit_ != 0 &&
Niels Möller77536a22019-01-15 08:50:01 +0100163 bytes_written_ + kFrameHeaderSize + encoded_image.size() > byte_limit_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100164 RTC_LOG(LS_WARNING) << "Closing IVF file due to reaching size limit: "
165 << byte_limit_ << " bytes.";
palmkviste75f2042016-09-28 06:19:48 -0700166 Close();
167 return false;
168 }
sprang3911c262016-04-15 01:24:14 -0700169 uint8_t frame_header[kFrameHeaderSize] = {};
170 ByteWriter<uint32_t>::WriteLittleEndian(
Niels Möller77536a22019-01-15 08:50:01 +0100171 &frame_header[0], static_cast<uint32_t>(encoded_image.size()));
sprang3911c262016-04-15 01:24:14 -0700172 ByteWriter<uint64_t>::WriteLittleEndian(&frame_header[4], timestamp);
Niels Möllerb7edf692019-02-08 16:40:53 +0100173 if (!file_.Write(frame_header, kFrameHeaderSize) ||
174 !file_.Write(encoded_image.data(), encoded_image.size())) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100175 RTC_LOG(LS_ERROR) << "Unable to write frame to file.";
sprang3911c262016-04-15 01:24:14 -0700176 return false;
177 }
178
Niels Möller77536a22019-01-15 08:50:01 +0100179 bytes_written_ += kFrameHeaderSize + encoded_image.size();
palmkviste75f2042016-09-28 06:19:48 -0700180
sprang3911c262016-04-15 01:24:14 -0700181 ++num_frames_;
182 return true;
183}
184
185bool IvfFileWriter::Close() {
Niels Möllerb7edf692019-02-08 16:40:53 +0100186 if (!file_.is_open())
sprang3911c262016-04-15 01:24:14 -0700187 return false;
188
189 if (num_frames_ == 0) {
palmkviste75f2042016-09-28 06:19:48 -0700190 file_.Close();
sprang3911c262016-04-15 01:24:14 -0700191 return true;
192 }
193
tommia6219cc2016-06-15 10:30:14 -0700194 bool ret = WriteHeader();
palmkviste75f2042016-09-28 06:19:48 -0700195 file_.Close();
tommia6219cc2016-06-15 10:30:14 -0700196 return ret;
sprang3911c262016-04-15 01:24:14 -0700197}
198
199} // namespace webrtc