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
37namespace cricket {
38
39struct FourCCAliasEntry {
40  uint32_t alias;
41  uint32_t canonical;
42};
43
44static 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
61uint32_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
71static 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
79static const int kNumScaleFactors = arraysize(kScaleFactors);
80
81// Finds the scale factor that, when applied to width and height, produces
82// fewer than num_pixels.
83static 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.
105void 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.
142void 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.
156void 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.
211void 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
224const int64_t VideoFormat::kMinimumInterval;  // Initialized in header.
225#endif
226
227std::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