| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "media/formats/webm/chromeos/webm_encoder.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/file_util.h" | |
| 9 #include "base/logging.h" | |
| 10 #include "base/memory/scoped_ptr.h" | |
| 11 #include "libyuv/convert.h" | |
| 12 #include "libyuv/video_common.h" | |
| 13 #include "third_party/skia/include/core/SkBitmap.h" | |
| 14 | |
| 15 extern "C" { | |
| 16 // Getting the right degree of C compatibility has been a constant struggle. | |
| 17 // - Stroustrup, C++ Report, 12(7), July/August 2000. | |
| 18 #define private priv | |
| 19 #include "third_party/libvpx/source/libvpx/third_party/libmkv/EbmlIDs.h" | |
| 20 #include "third_party/libvpx/source/libvpx/third_party/libmkv/EbmlWriter.h" | |
| 21 #undef private | |
| 22 } | |
| 23 | |
| 24 // Number of encoder threads to use. | |
| 25 static const int kNumEncoderThreads = 2; | |
| 26 | |
| 27 // Need a fixed size serializer for the track ID. libmkv provides a 64 bit | |
| 28 // one, but not a 32 bit one. | |
| 29 static void Ebml_SerializeUnsigned32(EbmlGlobal* ebml, | |
| 30 unsigned long class_id, | |
| 31 uint64_t value) { | |
| 32 uint8 size_serialized = 4 | 0x80; | |
| 33 Ebml_WriteID(ebml, class_id); | |
| 34 Ebml_Serialize(ebml, &size_serialized, sizeof(size_serialized), 1); | |
| 35 Ebml_Serialize(ebml, &value, sizeof(value), 4); | |
| 36 } | |
| 37 | |
| 38 // Wrapper functor for vpx_codec_destroy(). | |
| 39 struct VpxCodecDeleter { | |
| 40 void operator()(vpx_codec_ctx_t* codec) { | |
| 41 vpx_codec_destroy(codec); | |
| 42 } | |
| 43 }; | |
| 44 | |
| 45 // Wrapper functor for vpx_img_free(). | |
| 46 struct VpxImgDeleter { | |
| 47 void operator()(vpx_image_t* image) { | |
| 48 vpx_img_free(image); | |
| 49 } | |
| 50 }; | |
| 51 | |
| 52 namespace media { | |
| 53 | |
| 54 namespace chromeos { | |
| 55 | |
| 56 WebmEncoder::WebmEncoder(const base::FilePath& output_path, | |
| 57 int bitrate, | |
| 58 bool realtime) | |
| 59 : bitrate_(bitrate), | |
| 60 deadline_(realtime ? VPX_DL_REALTIME : VPX_DL_GOOD_QUALITY), | |
| 61 output_path_(output_path), | |
| 62 has_errors_(false) { | |
| 63 ebml_writer_.write_cb = base::Bind( | |
| 64 &WebmEncoder::EbmlWrite, base::Unretained(this)); | |
| 65 ebml_writer_.serialize_cb = base::Bind( | |
| 66 &WebmEncoder::EbmlSerialize, base::Unretained(this)); | |
| 67 } | |
| 68 | |
| 69 WebmEncoder::~WebmEncoder() { | |
| 70 } | |
| 71 | |
| 72 bool WebmEncoder::EncodeFromSprite(const SkBitmap& sprite, | |
| 73 int fps_n, | |
| 74 int fps_d) { | |
| 75 DCHECK(!sprite.isNull()); | |
| 76 DCHECK(!sprite.empty()); | |
| 77 | |
| 78 has_errors_ = false; | |
| 79 width_ = sprite.width(); | |
| 80 height_ = sprite.width(); | |
| 81 fps_.num = fps_n; | |
| 82 fps_.den = fps_d; | |
| 83 | |
| 84 // Sprite is tiled vertically. | |
| 85 frame_count_ = sprite.height() / width_; | |
| 86 | |
| 87 vpx_image_t image; | |
| 88 vpx_img_alloc(&image, VPX_IMG_FMT_I420, width_, height_, 16); | |
| 89 // Ensure that image is freed after return. | |
| 90 scoped_ptr<vpx_image_t, VpxImgDeleter> image_ptr(&image); | |
| 91 | |
| 92 const vpx_codec_iface_t* codec_iface = vpx_codec_vp8_cx(); | |
| 93 DCHECK(codec_iface); | |
| 94 vpx_codec_err_t ret = vpx_codec_enc_config_default(codec_iface, &config_, 0); | |
| 95 DCHECK_EQ(VPX_CODEC_OK, ret); | |
| 96 | |
| 97 config_.rc_target_bitrate = bitrate_; | |
| 98 config_.g_w = width_; | |
| 99 config_.g_h = height_; | |
| 100 config_.g_pass = VPX_RC_ONE_PASS; | |
| 101 config_.g_profile = 0; // Default profile. | |
| 102 config_.g_threads = kNumEncoderThreads; | |
| 103 config_.rc_min_quantizer = 0; | |
| 104 config_.rc_max_quantizer = 63; // Maximum possible range. | |
| 105 config_.g_timebase.num = fps_.den; | |
| 106 config_.g_timebase.den = fps_.num; | |
| 107 config_.kf_mode = VPX_KF_AUTO; // Auto key frames. | |
| 108 | |
| 109 vpx_codec_ctx_t codec; | |
| 110 ret = vpx_codec_enc_init(&codec, codec_iface, &config_, 0); | |
| 111 if (ret != VPX_CODEC_OK) | |
| 112 return false; | |
| 113 // Ensure that codec context is freed after return. | |
| 114 scoped_ptr<vpx_codec_ctx_t, VpxCodecDeleter> codec_ptr(&codec); | |
| 115 | |
| 116 SkAutoLockPixels lock_sprite(sprite); | |
| 117 | |
| 118 const uint8* src = reinterpret_cast<const uint8*>(sprite.getAddr32(0, 0)); | |
| 119 size_t src_frame_size = sprite.getSize(); | |
| 120 int crop_y = 0; | |
| 121 | |
| 122 if (!WriteWebmHeader()) | |
| 123 return false; | |
| 124 | |
| 125 for (size_t frame = 0; frame < frame_count_ && !has_errors_; ++frame) { | |
| 126 int res = libyuv::ConvertToI420( | |
| 127 src, src_frame_size, | |
| 128 image.planes[VPX_PLANE_Y], image.stride[VPX_PLANE_Y], | |
| 129 image.planes[VPX_PLANE_U], image.stride[VPX_PLANE_U], | |
| 130 image.planes[VPX_PLANE_V], image.stride[VPX_PLANE_V], | |
| 131 0, crop_y, // src origin | |
| 132 width_, sprite.height(), // src size | |
| 133 width_, height_, // dest size | |
| 134 libyuv::kRotate0, | |
| 135 libyuv::FOURCC_ARGB); | |
| 136 if (res) { | |
| 137 has_errors_ = true; | |
| 138 break; | |
| 139 } | |
| 140 crop_y += height_; | |
| 141 | |
| 142 ret = vpx_codec_encode(&codec, &image, frame, 1, 0, deadline_); | |
| 143 if (ret != VPX_CODEC_OK) { | |
| 144 has_errors_ = true; | |
| 145 break; | |
| 146 } | |
| 147 | |
| 148 vpx_codec_iter_t iter = NULL; | |
| 149 const vpx_codec_cx_pkt_t* packet; | |
| 150 while (!has_errors_ && (packet = vpx_codec_get_cx_data(&codec, &iter))) { | |
| 151 if (packet->kind == VPX_CODEC_CX_FRAME_PKT) | |
| 152 WriteWebmBlock(packet); | |
| 153 } | |
| 154 } | |
| 155 | |
| 156 return WriteWebmFooter(); | |
| 157 } | |
| 158 | |
| 159 bool WebmEncoder::WriteWebmHeader() { | |
| 160 output_ = base::OpenFile(output_path_, "wb"); | |
| 161 if (!output_) | |
| 162 return false; | |
| 163 | |
| 164 // Global header. | |
| 165 StartSubElement(EBML); | |
| 166 { | |
| 167 Ebml_SerializeUnsigned(&ebml_writer_, EBMLVersion, 1); | |
| 168 Ebml_SerializeUnsigned(&ebml_writer_, EBMLReadVersion, 1); | |
| 169 Ebml_SerializeUnsigned(&ebml_writer_, EBMLMaxIDLength, 4); | |
| 170 Ebml_SerializeUnsigned(&ebml_writer_, EBMLMaxSizeLength, 8); | |
| 171 Ebml_SerializeString(&ebml_writer_, DocType, "webm"); | |
| 172 Ebml_SerializeUnsigned(&ebml_writer_, DocTypeVersion, 2); | |
| 173 Ebml_SerializeUnsigned(&ebml_writer_, DocTypeReadVersion, 2); | |
| 174 } | |
| 175 EndSubElement(); // EBML | |
| 176 | |
| 177 // Single segment with a video track. | |
| 178 StartSubElement(Segment); | |
| 179 { | |
| 180 StartSubElement(Info); | |
| 181 { | |
| 182 // All timecodes in the segment will be expressed in milliseconds. | |
| 183 Ebml_SerializeUnsigned(&ebml_writer_, TimecodeScale, 1000000); | |
| 184 double duration = 1000. * frame_count_ * fps_.den / fps_.num; | |
| 185 Ebml_SerializeFloat(&ebml_writer_, Segment_Duration, duration); | |
| 186 } | |
| 187 EndSubElement(); // Info | |
| 188 | |
| 189 StartSubElement(Tracks); | |
| 190 { | |
| 191 StartSubElement(TrackEntry); | |
| 192 { | |
| 193 Ebml_SerializeUnsigned(&ebml_writer_, TrackNumber, 1); | |
| 194 Ebml_SerializeUnsigned32(&ebml_writer_, TrackUID, 1); | |
| 195 Ebml_SerializeUnsigned(&ebml_writer_, TrackType, 1); // Video | |
| 196 Ebml_SerializeString(&ebml_writer_, CodecID, "V_VP8"); | |
| 197 | |
| 198 StartSubElement(Video); | |
| 199 { | |
| 200 Ebml_SerializeUnsigned(&ebml_writer_, PixelWidth, width_); | |
| 201 Ebml_SerializeUnsigned(&ebml_writer_, PixelHeight, height_); | |
| 202 Ebml_SerializeUnsigned(&ebml_writer_, StereoMode, 0); // Mono | |
| 203 float fps = static_cast<float>(fps_.num) / fps_.den; | |
| 204 Ebml_SerializeFloat(&ebml_writer_, FrameRate, fps); | |
| 205 } | |
| 206 EndSubElement(); // Video | |
| 207 } | |
| 208 EndSubElement(); // TrackEntry | |
| 209 } | |
| 210 EndSubElement(); // Tracks | |
| 211 | |
| 212 StartSubElement(Cluster); { | |
| 213 Ebml_SerializeUnsigned(&ebml_writer_, Timecode, 0); | |
| 214 } // Cluster left open. | |
| 215 } // Segment left open. | |
| 216 | |
| 217 // No check for |has_errors_| here because |false| is only returned when | |
| 218 // opening file fails. | |
| 219 return true; | |
| 220 } | |
| 221 | |
| 222 void WebmEncoder::WriteWebmBlock(const vpx_codec_cx_pkt_t* packet) { | |
| 223 bool is_keyframe = packet->data.frame.flags & VPX_FRAME_IS_KEY; | |
| 224 int64_t pts_ms = 1000 * packet->data.frame.pts * fps_.den / fps_.num; | |
| 225 | |
| 226 DVLOG(1) << "Video packet @" << pts_ms << " ms " | |
| 227 << packet->data.frame.sz << " bytes " | |
| 228 << (is_keyframe ? "K" : ""); | |
| 229 | |
| 230 Ebml_WriteID(&ebml_writer_, SimpleBlock); | |
| 231 | |
| 232 uint32 block_length = (packet->data.frame.sz + 4) | 0x10000000; | |
| 233 EbmlSerializeHelper(&block_length, 4); | |
| 234 | |
| 235 uint8 track_number = 1 | 0x80; | |
| 236 EbmlSerializeHelper(&track_number, 1); | |
| 237 | |
| 238 EbmlSerializeHelper(&pts_ms, 2); | |
| 239 | |
| 240 uint8 flags = 0; | |
| 241 if (is_keyframe) | |
| 242 flags |= 0x80; | |
| 243 if (packet->data.frame.flags & VPX_FRAME_IS_INVISIBLE) | |
| 244 flags |= 0x08; | |
| 245 EbmlSerializeHelper(&flags, 1); | |
| 246 | |
| 247 EbmlWrite(packet->data.frame.buf, packet->data.frame.sz); | |
| 248 } | |
| 249 | |
| 250 bool WebmEncoder::WriteWebmFooter() { | |
| 251 EndSubElement(); // Cluster | |
| 252 EndSubElement(); // Segment | |
| 253 DCHECK(ebml_sub_elements_.empty()); | |
| 254 return base::CloseFile(output_) && !has_errors_; | |
| 255 } | |
| 256 | |
| 257 void WebmEncoder::StartSubElement(unsigned long class_id) { | |
| 258 Ebml_WriteID(&ebml_writer_, class_id); | |
| 259 ebml_sub_elements_.push(ftell(output_)); | |
| 260 static const uint64_t kUnknownLen = 0x01FFFFFFFFFFFFFFLLU; | |
| 261 EbmlSerializeHelper(&kUnknownLen, 8); | |
| 262 } | |
| 263 | |
| 264 void WebmEncoder::EndSubElement() { | |
| 265 DCHECK(!ebml_sub_elements_.empty()); | |
| 266 | |
| 267 long int end_pos = ftell(output_); | |
| 268 long int start_pos = ebml_sub_elements_.top(); | |
| 269 ebml_sub_elements_.pop(); | |
| 270 | |
| 271 uint64_t size = (end_pos - start_pos - 8) | 0x0100000000000000ULL; | |
| 272 // Seek to the beginning of the sub-element and patch in the calculated size. | |
| 273 if (fseek(output_, start_pos, SEEK_SET)) { | |
| 274 has_errors_ = true; | |
| 275 LOG(ERROR) << "Error writing to " << output_path_.value(); | |
| 276 } | |
| 277 EbmlSerializeHelper(&size, 8); | |
| 278 | |
| 279 // Restore write position. | |
| 280 if (fseek(output_, end_pos, SEEK_SET)) { | |
| 281 has_errors_ = true; | |
| 282 LOG(ERROR) << "Error writing to " << output_path_.value(); | |
| 283 } | |
| 284 } | |
| 285 | |
| 286 void WebmEncoder::EbmlWrite(const void* buffer, | |
| 287 unsigned long len) { | |
| 288 if (fwrite(buffer, 1, len, output_) != len) { | |
| 289 has_errors_ = true; | |
| 290 LOG(ERROR) << "Error writing to " << output_path_.value(); | |
| 291 } | |
| 292 } | |
| 293 | |
| 294 template <class T> | |
| 295 void WebmEncoder::EbmlSerializeHelper(const T* buffer, unsigned long len) { | |
| 296 for (int i = len - 1; i >= 0; i--) { | |
| 297 uint8 c = *buffer >> (i * CHAR_BIT); | |
| 298 EbmlWrite(&c, 1); | |
| 299 } | |
| 300 } | |
| 301 | |
| 302 void WebmEncoder::EbmlSerialize(const void* buffer, | |
| 303 int buffer_size, | |
| 304 unsigned long len) { | |
| 305 switch (buffer_size) { | |
| 306 case 1: | |
| 307 return EbmlSerializeHelper(static_cast<const int8_t*>(buffer), len); | |
| 308 case 2: | |
| 309 return EbmlSerializeHelper(static_cast<const int16_t*>(buffer), len); | |
| 310 case 4: | |
| 311 return EbmlSerializeHelper(static_cast<const int32_t*>(buffer), len); | |
| 312 case 8: | |
| 313 return EbmlSerializeHelper(static_cast<const int64_t*>(buffer), len); | |
| 314 default: | |
| 315 NOTREACHED() << "Invalid EbmlSerialize length: " << len; | |
| 316 } | |
| 317 } | |
| 318 | |
| 319 } // namespace chromeos | |
| 320 | |
| 321 } // namespace media | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 395133002:
Clean up. Experimental user avatars removed. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src