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 "talk/base/common.h"
33
34namespace cricket {
35
36struct FourCCAliasEntry {
37  uint32 alias;
38  uint32 canonical;
39};
40
41static 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
58uint32 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
68static 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
76static 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.
80static 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.
102void 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.
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 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" << IntervalToFps(interval);
240  return ss.str();
241}
242
243}  // namespace cricket
244