1 // libjingle 2 // Copyright 2010 Google Inc. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are met: 6 // 7 // 1. Redistributions of source code must retain the above copyright notice, 8 // this list of conditions and the following disclaimer. 9 // 2. Redistributions in binary form must reproduce the above copyright notice, 10 // this list of conditions and the following disclaimer in the documentation 11 // and/or other materials provided with the distribution. 12 // 3. The name of the author may not be used to endorse or promote products 13 // derived from this software without specific prior written permission. 14 // 15 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 16 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 17 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 18 // EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 19 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 20 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 21 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 22 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 23 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 24 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 26 #include "talk/media/base/videocommon.h" 27 28 #include <limits.h> // For INT_MAX 29 #include <math.h> 30 #include <sstream> 31 32 #include "webrtc/base/common.h" 33 34 namespace cricket { 35 36 struct FourCCAliasEntry { 37 uint32 alias; 38 uint32 canonical; 39 }; 40 41 static const FourCCAliasEntry kFourCCAliases[] = { 42 {FOURCC_IYUV, FOURCC_I420}, 43 {FOURCC_YU16, FOURCC_I422}, 44 {FOURCC_YU24, FOURCC_I444}, 45 {FOURCC_YUYV, FOURCC_YUY2}, 46 {FOURCC_YUVS, FOURCC_YUY2}, 47 {FOURCC_HDYC, FOURCC_UYVY}, 48 {FOURCC_2VUY, FOURCC_UYVY}, 49 {FOURCC_JPEG, FOURCC_MJPG}, // Note: JPEG has DHT while MJPG does not. 50 {FOURCC_DMB1, FOURCC_MJPG}, 51 {FOURCC_BA81, FOURCC_BGGR}, 52 {FOURCC_RGB3, FOURCC_RAW}, 53 {FOURCC_BGR3, FOURCC_24BG}, 54 {FOURCC_CM32, FOURCC_BGRA}, 55 {FOURCC_CM24, FOURCC_RAW}, 56 }; 57 58 uint32 CanonicalFourCC(uint32 fourcc) { 59 for (int i = 0; i < ARRAY_SIZE(kFourCCAliases); ++i) { 60 if (kFourCCAliases[i].alias == fourcc) { 61 return kFourCCAliases[i].canonical; 62 } 63 } 64 // Not an alias, so return it as-is. 65 return fourcc; 66 } 67 68 static float kScaleFactors[] = { 69 1.f / 1.f, // Full size. 70 1.f / 2.f, // 1/2 scale. 71 1.f / 4.f, // 1/4 scale. 72 1.f / 8.f, // 1/8 scale. 73 1.f / 16.f // 1/16 scale. 74 }; 75 76 static const int kNumScaleFactors = ARRAY_SIZE(kScaleFactors); 77 78 // Finds the scale factor that, when applied to width and height, produces 79 // fewer than num_pixels. 80 static float FindLowerScale(int width, int height, int target_num_pixels) { 81 if (!target_num_pixels) { 82 return 0.f; 83 } 84 int best_distance = INT_MAX; 85 int best_index = kNumScaleFactors - 1; // Default to max scale. 86 for (int i = 0; i < kNumScaleFactors; ++i) { 87 int test_num_pixels = static_cast<int>(width * kScaleFactors[i] * 88 height * kScaleFactors[i]); 89 int diff = target_num_pixels - test_num_pixels; 90 if (diff >= 0 && diff < best_distance) { 91 best_distance = diff; 92 best_index = i; 93 if (best_distance == 0) { // Found exact match. 94 break; 95 } 96 } 97 } 98 return kScaleFactors[best_index]; 99 } 100 101 // Computes a scale less to fit in max_pixels while maintaining aspect ratio. 102 void ComputeScaleMaxPixels(int frame_width, int frame_height, int max_pixels, 103 int* scaled_width, int* scaled_height) { 104 ASSERT(scaled_width != NULL); 105 ASSERT(scaled_height != NULL); 106 ASSERT(max_pixels > 0); 107 // For VP8 the values for max width and height can be found here 108 // webrtc/src/video_engine/vie_defines.h (kViEMaxCodecWidth and 109 // kViEMaxCodecHeight) 110 const int kMaxWidth = 4096; 111 const int kMaxHeight = 3072; 112 int new_frame_width = frame_width; 113 int new_frame_height = frame_height; 114 115 // Limit width. 116 if (new_frame_width > kMaxWidth) { 117 new_frame_height = new_frame_height * kMaxWidth / new_frame_width; 118 new_frame_width = kMaxWidth; 119 } 120 // Limit height. 121 if (new_frame_height > kMaxHeight) { 122 new_frame_width = new_frame_width * kMaxHeight / new_frame_height; 123 new_frame_height = kMaxHeight; 124 } 125 // Limit number of pixels. 126 if (new_frame_width * new_frame_height > max_pixels) { 127 // Compute new width such that width * height is less than maximum but 128 // maintains original captured frame aspect ratio. 129 new_frame_width = static_cast<int>(sqrtf(static_cast<float>( 130 max_pixels) * new_frame_width / new_frame_height)); 131 new_frame_height = max_pixels / new_frame_width; 132 } 133 // Snap to a scale factor that is less than or equal to target pixels. 134 float scale = FindLowerScale(frame_width, frame_height, 135 new_frame_width * new_frame_height); 136 *scaled_width = static_cast<int>(frame_width * scale + .5f); 137 *scaled_height = static_cast<int>(frame_height * scale + .5f); 138 } 139 140 // Compute a size to scale frames to that is below maximum compression 141 // and rendering size with the same aspect ratio. 142 void ComputeScale(int frame_width, int frame_height, int fps, 143 int* scaled_width, int* scaled_height) { 144 // Maximum pixels limit is set to Retina MacBookPro 15" resolution of 145 // 2880 x 1800 as of 4/18/2013. 146 // For high fps, maximum pixels limit is set based on common 24" monitor 147 // resolution of 2048 x 1280 as of 6/13/2013. The Retina resolution is 148 // therefore reduced to 1440 x 900. 149 int max_pixels = (fps > 5) ? 2048 * 1280 : 2880 * 1800; 150 ComputeScaleMaxPixels( 151 frame_width, frame_height, max_pixels, scaled_width, scaled_height); 152 } 153 154 // Compute size to crop video frame to. 155 // If cropped_format_* is 0, return the frame_* size as is. 156 void ComputeCrop(int cropped_format_width, int cropped_format_height, 157 int frame_width, int frame_height, 158 int pixel_width, int pixel_height, 159 int rotation, 160 int* cropped_width, int* cropped_height) { 161 // Transform screen crop to camera space if rotated. 162 if (rotation == 90 || rotation == 270) { 163 std::swap(cropped_format_width, cropped_format_height); 164 } 165 ASSERT(cropped_format_width >= 0); 166 ASSERT(cropped_format_height >= 0); 167 ASSERT(frame_width > 0); 168 ASSERT(frame_height > 0); 169 ASSERT(pixel_width >= 0); 170 ASSERT(pixel_height >= 0); 171 ASSERT(rotation == 0 || rotation == 90 || rotation == 180 || rotation == 270); 172 ASSERT(cropped_width != NULL); 173 ASSERT(cropped_height != NULL); 174 if (!pixel_width) { 175 pixel_width = 1; 176 } 177 if (!pixel_height) { 178 pixel_height = 1; 179 } 180 // if cropped_format is 0x0 disable cropping. 181 if (!cropped_format_height) { 182 cropped_format_height = 1; 183 } 184 float frame_aspect = static_cast<float>(frame_width * pixel_width) / 185 static_cast<float>(frame_height * pixel_height); 186 float crop_aspect = static_cast<float>(cropped_format_width) / 187 static_cast<float>(cropped_format_height); 188 // kAspectThresh is the maximum aspect ratio difference that we'll accept 189 // for cropping. The value 1.34 allows cropping from 4:3 to 16:9. 190 // Set to zero to disable cropping entirely. 191 // TODO(fbarchard): crop to multiple of 16 width for better performance. 192 const float kAspectThresh = 1.34f; 193 // Wide aspect - crop horizontally 194 if (frame_aspect > crop_aspect && 195 frame_aspect < crop_aspect * kAspectThresh) { 196 // Round width down to multiple of 4 to avoid odd chroma width. 197 // Width a multiple of 4 allows a half size image to have chroma channel 198 // that avoids rounding errors. 199 frame_width = static_cast<int>((crop_aspect * frame_height * 200 pixel_height) / pixel_width + 0.5f) & ~3; 201 } else if (frame_aspect < crop_aspect && 202 frame_aspect > crop_aspect / kAspectThresh) { 203 frame_height = static_cast<int>((frame_width * pixel_width) / 204 (crop_aspect * pixel_height) + 0.5f) & ~1; 205 } 206 *cropped_width = frame_width; 207 *cropped_height = frame_height; 208 } 209 210 // Compute the frame size that makes pixels square pixel aspect ratio. 211 void ComputeScaleToSquarePixels(int in_width, int in_height, 212 int pixel_width, int pixel_height, 213 int* scaled_width, int* scaled_height) { 214 *scaled_width = in_width; // Keep width the same. 215 *scaled_height = in_height * pixel_height / pixel_width; 216 } 217 218 // The C++ standard requires a namespace-scope definition of static const 219 // integral types even when they are initialized in the declaration (see 220 // [class.static.data]/4), but MSVC with /Ze is non-conforming and treats that 221 // as a multiply defined symbol error. See Also: 222 // http://msdn.microsoft.com/en-us/library/34h23df8.aspx 223 #ifndef _MSC_EXTENSIONS 224 const int64 VideoFormat::kMinimumInterval; // Initialized in header. 225 #endif 226 227 std::string VideoFormat::ToString() const { 228 std::string fourcc_name = GetFourccName(fourcc) + " "; 229 for (std::string::const_iterator i = fourcc_name.begin(); 230 i < fourcc_name.end(); ++i) { 231 // Test character is printable; Avoid isprint() which asserts on negatives. 232 if (*i < 32 || *i >= 127) { 233 fourcc_name = ""; 234 break; 235 } 236 } 237 238 std::ostringstream ss; 239 ss << fourcc_name << width << "x" << height << "x" 240 << IntervalToFpsFloat(interval); 241 return ss.str(); 242 } 243 244 } // namespace cricket 245
