1 /* 2 * Copyright (c) 2012 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 11 #include "webrtc/modules/video_coding/codecs/i420/include/i420.h" 12 13 #include <limits> 14 #include <string> 15 16 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" 17 18 namespace { 19 const size_t kI420HeaderSize = 4; 20 } 21 22 namespace webrtc { 23 24 I420Encoder::I420Encoder() 25 : _inited(false), _encodedImage(), _encodedCompleteCallback(NULL) {} 26 27 I420Encoder::~I420Encoder() { 28 _inited = false; 29 delete[] _encodedImage._buffer; 30 } 31 32 int I420Encoder::Release() { 33 // Should allocate an encoded frame and then release it here, for that we 34 // actually need an init flag. 35 if (_encodedImage._buffer != NULL) { 36 delete[] _encodedImage._buffer; 37 _encodedImage._buffer = NULL; 38 } 39 _inited = false; 40 return WEBRTC_VIDEO_CODEC_OK; 41 } 42 43 int I420Encoder::InitEncode(const VideoCodec* codecSettings, 44 int /*numberOfCores*/, 45 size_t /*maxPayloadSize */) { 46 if (codecSettings == NULL) { 47 return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; 48 } 49 if (codecSettings->width < 1 || codecSettings->height < 1) { 50 return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; 51 } 52 53 // Allocating encoded memory. 54 if (_encodedImage._buffer != NULL) { 55 delete[] _encodedImage._buffer; 56 _encodedImage._buffer = NULL; 57 _encodedImage._size = 0; 58 } 59 const size_t newSize = 60 CalcBufferSize(kI420, codecSettings->width, codecSettings->height) + 61 kI420HeaderSize; 62 uint8_t* newBuffer = new uint8_t[newSize]; 63 if (newBuffer == NULL) { 64 return WEBRTC_VIDEO_CODEC_MEMORY; 65 } 66 _encodedImage._size = newSize; 67 _encodedImage._buffer = newBuffer; 68 69 // If no memory allocation, no point to init. 70 _inited = true; 71 return WEBRTC_VIDEO_CODEC_OK; 72 } 73 74 int I420Encoder::Encode(const VideoFrame& inputImage, 75 const CodecSpecificInfo* /*codecSpecificInfo*/, 76 const std::vector<FrameType>* /*frame_types*/) { 77 if (!_inited) { 78 return WEBRTC_VIDEO_CODEC_UNINITIALIZED; 79 } 80 if (_encodedCompleteCallback == NULL) { 81 return WEBRTC_VIDEO_CODEC_UNINITIALIZED; 82 } 83 84 _encodedImage._frameType = kVideoFrameKey; 85 _encodedImage._timeStamp = inputImage.timestamp(); 86 _encodedImage._encodedHeight = inputImage.height(); 87 _encodedImage._encodedWidth = inputImage.width(); 88 89 int width = inputImage.width(); 90 if (width > std::numeric_limits<uint16_t>::max()) { 91 return WEBRTC_VIDEO_CODEC_ERR_SIZE; 92 } 93 int height = inputImage.height(); 94 if (height > std::numeric_limits<uint16_t>::max()) { 95 return WEBRTC_VIDEO_CODEC_ERR_SIZE; 96 } 97 98 size_t req_length = 99 CalcBufferSize(kI420, inputImage.width(), inputImage.height()) + 100 kI420HeaderSize; 101 if (_encodedImage._size > req_length) { 102 // Reallocate buffer. 103 delete[] _encodedImage._buffer; 104 105 _encodedImage._buffer = new uint8_t[req_length]; 106 _encodedImage._size = req_length; 107 } 108 109 uint8_t* buffer = _encodedImage._buffer; 110 111 buffer = InsertHeader(buffer, width, height); 112 113 int ret_length = 114 ExtractBuffer(inputImage, req_length - kI420HeaderSize, buffer); 115 if (ret_length < 0) 116 return WEBRTC_VIDEO_CODEC_MEMORY; 117 _encodedImage._length = ret_length + kI420HeaderSize; 118 119 _encodedCompleteCallback->Encoded(_encodedImage, NULL, NULL); 120 return WEBRTC_VIDEO_CODEC_OK; 121 } 122 123 uint8_t* I420Encoder::InsertHeader(uint8_t* buffer, 124 uint16_t width, 125 uint16_t height) { 126 *buffer++ = static_cast<uint8_t>(width >> 8); 127 *buffer++ = static_cast<uint8_t>(width & 0xFF); 128 *buffer++ = static_cast<uint8_t>(height >> 8); 129 *buffer++ = static_cast<uint8_t>(height & 0xFF); 130 return buffer; 131 } 132 133 int I420Encoder::RegisterEncodeCompleteCallback( 134 EncodedImageCallback* callback) { 135 _encodedCompleteCallback = callback; 136 return WEBRTC_VIDEO_CODEC_OK; 137 } 138 139 I420Decoder::I420Decoder() 140 : _decodedImage(), 141 _width(0), 142 _height(0), 143 _inited(false), 144 _decodeCompleteCallback(NULL) {} 145 146 I420Decoder::~I420Decoder() { 147 Release(); 148 } 149 150 int I420Decoder::Reset() { 151 return WEBRTC_VIDEO_CODEC_OK; 152 } 153 154 int I420Decoder::InitDecode(const VideoCodec* codecSettings, 155 int /*numberOfCores */) { 156 if (codecSettings == NULL) { 157 return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; 158 } else if (codecSettings->width < 1 || codecSettings->height < 1) { 159 return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; 160 } 161 _width = codecSettings->width; 162 _height = codecSettings->height; 163 _inited = true; 164 return WEBRTC_VIDEO_CODEC_OK; 165 } 166 167 int I420Decoder::Decode(const EncodedImage& inputImage, 168 bool /*missingFrames*/, 169 const RTPFragmentationHeader* /*fragmentation*/, 170 const CodecSpecificInfo* /*codecSpecificInfo*/, 171 int64_t /*renderTimeMs*/) { 172 if (inputImage._buffer == NULL) { 173 return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; 174 } 175 if (_decodeCompleteCallback == NULL) { 176 return WEBRTC_VIDEO_CODEC_UNINITIALIZED; 177 } 178 if (inputImage._length <= 0) { 179 return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; 180 } 181 if (inputImage._completeFrame == false) { 182 return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; 183 } 184 if (!_inited) { 185 return WEBRTC_VIDEO_CODEC_UNINITIALIZED; 186 } 187 if (inputImage._length < kI420HeaderSize) { 188 return WEBRTC_VIDEO_CODEC_ERROR; 189 } 190 191 const uint8_t* buffer = inputImage._buffer; 192 uint16_t width, height; 193 194 buffer = ExtractHeader(buffer, &width, &height); 195 _width = width; 196 _height = height; 197 198 // Verify that the available length is sufficient: 199 size_t req_length = CalcBufferSize(kI420, _width, _height) + kI420HeaderSize; 200 201 if (req_length > inputImage._length) { 202 return WEBRTC_VIDEO_CODEC_ERROR; 203 } 204 // Set decoded image parameters. 205 int half_width = (_width + 1) / 2; 206 _decodedImage.CreateEmptyFrame(_width, _height, _width, half_width, 207 half_width); 208 // Converting from buffer to plane representation. 209 int ret = ConvertToI420(kI420, buffer, 0, 0, _width, _height, 0, 210 kVideoRotation_0, &_decodedImage); 211 if (ret < 0) { 212 return WEBRTC_VIDEO_CODEC_MEMORY; 213 } 214 _decodedImage.set_timestamp(inputImage._timeStamp); 215 216 _decodeCompleteCallback->Decoded(_decodedImage); 217 return WEBRTC_VIDEO_CODEC_OK; 218 } 219 220 const uint8_t* I420Decoder::ExtractHeader(const uint8_t* buffer, 221 uint16_t* width, 222 uint16_t* height) { 223 *width = static_cast<uint16_t>(*buffer++) << 8; 224 *width |= *buffer++; 225 *height = static_cast<uint16_t>(*buffer++) << 8; 226 *height |= *buffer++; 227 228 return buffer; 229 } 230 231 int I420Decoder::RegisterDecodeCompleteCallback( 232 DecodedImageCallback* callback) { 233 _decodeCompleteCallback = callback; 234 return WEBRTC_VIDEO_CODEC_OK; 235 } 236 237 int I420Decoder::Release() { 238 _inited = false; 239 return WEBRTC_VIDEO_CODEC_OK; 240 } 241 } // namespace webrtc 242