1 /* 2 * libjingle 3 * Copyright 2010 Google Inc. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include "talk/media/base/videocommon.h" 29 30 #include <limits.h> // For INT_MAX 31 #include <math.h> 32 #include <sstream> 33 34 #include "webrtc/base/arraysize.h" 35 #include "webrtc/base/common.h" 36 37 namespace cricket { 38 39 struct FourCCAliasEntry { 40 uint32_t alias; 41 uint32_t canonical; 42 }; 43 44 static const FourCCAliasEntry kFourCCAliases[] = { 45 {FOURCC_IYUV, FOURCC_I420}, 46 {FOURCC_YU16, FOURCC_I422}, 47 {FOURCC_YU24, FOURCC_I444}, 48 {FOURCC_YUYV, FOURCC_YUY2}, 49 {FOURCC_YUVS, FOURCC_YUY2}, 50 {FOURCC_HDYC, FOURCC_UYVY}, 51 {FOURCC_2VUY, FOURCC_UYVY}, 52 {FOURCC_JPEG, FOURCC_MJPG}, // Note: JPEG has DHT while MJPG does not. 53 {FOURCC_DMB1, FOURCC_MJPG}, 54 {FOURCC_BA81, FOURCC_BGGR}, 55 {FOURCC_RGB3, FOURCC_RAW}, 56 {FOURCC_BGR3, FOURCC_24BG}, 57 {FOURCC_CM32, FOURCC_BGRA}, 58 {FOURCC_CM24, FOURCC_RAW}, 59 }; 60 61 uint32_t CanonicalFourCC(uint32_t fourcc) { 62 for (int i = 0; i < arraysize(kFourCCAliases); ++i) { 63 if (kFourCCAliases[i].alias == fourcc) { 64 return kFourCCAliases[i].canonical; 65 } 66 } 67 // Not an alias, so return it as-is. 68 return fourcc; 69 } 70 71 static float kScaleFactors[] = { 72 1.f / 1.f, // Full size. 73 1.f / 2.f, // 1/2 scale. 74 1.f / 4.f, // 1/4 scale. 75 1.f / 8.f, // 1/8 scale. 76 1.f / 16.f // 1/16 scale. 77 }; 78 79 static const int kNumScaleFactors = arraysize(kScaleFactors); 80 81 // Finds the scale factor that, when applied to width and height, produces 82 // fewer than num_pixels. 83 static float FindLowerScale(int width, int height, int target_num_pixels) { 84 if (!target_num_pixels) { 85 return 0.f; 86 } 87 int best_distance = INT_MAX; 88 int best_index = kNumScaleFactors - 1; // Default to max scale. 89 for (int i = 0; i < kNumScaleFactors; ++i) { 90 int test_num_pixels = static_cast<int>(width * kScaleFactors[i] * 91 height * kScaleFactors[i]); 92 int diff = target_num_pixels - test_num_pixels; 93 if (diff >= 0 && diff < best_distance) { 94 best_distance = diff; 95 best_index = i; 96 if (best_distance == 0) { // Found exact match. 97 break; 98 } 99 } 100 } 101 return kScaleFactors[best_index]; 102 } 103 104 // Computes a scale less to fit in max_pixels while maintaining aspect ratio. 105 void ComputeScaleMaxPixels(int frame_width, int frame_height, int max_pixels, 106 int* scaled_width, int* scaled_height) { 107 ASSERT(scaled_width != NULL); 108 ASSERT(scaled_height != NULL); 109 ASSERT(max_pixels > 0); 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_t 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
