OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #ifndef MEDIA_BASE_VIDEO_CAPTURE_TYPES_H_ | |
6 #define MEDIA_BASE_VIDEO_CAPTURE_TYPES_H_ | |
7 | |
8 #include <stddef.h> | |
9 | |
10 #include <vector> | |
11 | |
12 #include "build/build_config.h" | |
13 #include "media/base/media_export.h" | |
14 #include "media/base/video_types.h" | |
15 #include "ui/gfx/geometry/size.h" | |
16 | |
17 namespace media { | |
18 | |
19 // TODO(wjia): this type should be defined in a common place and | |
20 // shared with device manager. | |
21 typedef int VideoCaptureSessionId; | |
22 | |
23 // Storage type for the pixels. | |
24 // TODO(mcasas): http://crbug.com/504160 Consider making this an enum class. | |
25 // TODO(chfremer): Extend or remove this enum. | |
26 enum VideoPixelStorage { | |
27 PIXEL_STORAGE_CPU, | |
28 PIXEL_STORAGE_MAX = PIXEL_STORAGE_CPU, | |
29 }; | |
30 | |
31 // Policies for capture devices that have source content that varies in size. | |
32 // It is up to the implementation how the captured content will be transformed | |
33 // (e.g., scaling and/or letterboxing) in order to produce video frames that | |
34 // strictly adheree to one of these policies. | |
35 enum ResolutionChangePolicy { | |
36 // Capture device outputs a fixed resolution all the time. The resolution of | |
37 // the first frame is the resolution for all frames. | |
38 RESOLUTION_POLICY_FIXED_RESOLUTION, | |
39 | |
40 // Capture device is allowed to output frames of varying resolutions. The | |
41 // width and height will not exceed the maximum dimensions specified. The | |
42 // aspect ratio of the frames will match the aspect ratio of the maximum | |
43 // dimensions as closely as possible. | |
44 RESOLUTION_POLICY_FIXED_ASPECT_RATIO, | |
45 | |
46 // Capture device is allowed to output frames of varying resolutions not | |
47 // exceeding the maximum dimensions specified. | |
48 RESOLUTION_POLICY_ANY_WITHIN_LIMIT, | |
49 | |
50 // Must always be equal to largest entry in the enum. | |
51 RESOLUTION_POLICY_LAST = RESOLUTION_POLICY_ANY_WITHIN_LIMIT, | |
52 }; | |
53 | |
54 // Potential values of the googPowerLineFrequency optional constraint passed to | |
55 // getUserMedia. Note that the numeric values are currently significant, and are | |
56 // used to map enum values to corresponding frequency values. | |
57 // TODO(ajose): http://crbug.com/525167 Consider making this a class. | |
58 enum class PowerLineFrequency { | |
59 FREQUENCY_DEFAULT = 0, | |
60 FREQUENCY_50HZ = 50, | |
61 FREQUENCY_60HZ = 60, | |
62 FREQUENCY_MAX = FREQUENCY_60HZ | |
63 }; | |
64 | |
65 // Assert that the int:frequency mapping is correct. | |
66 static_assert(static_cast<int>(PowerLineFrequency::FREQUENCY_DEFAULT) == 0, | |
67 "static_cast<int>(FREQUENCY_DEFAULT) must equal 0."); | |
68 static_assert(static_cast<int>(PowerLineFrequency::FREQUENCY_50HZ) == 50, | |
69 "static_cast<int>(FREQUENCY_DEFAULT) must equal 50."); | |
70 static_assert(static_cast<int>(PowerLineFrequency::FREQUENCY_60HZ) == 60, | |
71 "static_cast<int>(FREQUENCY_DEFAULT) must equal 60."); | |
72 | |
73 // Some drivers use rational time per frame instead of float frame rate, this | |
74 // constant k is used to convert between both: A fps -> [k/k*A] seconds/frame. | |
75 const int kFrameRatePrecision = 10000; | |
76 | |
77 // Video capture format specification. | |
78 // This class is used by the video capture device to specify the format of every | |
79 // frame captured and returned to a client. It is also used to specify a | |
80 // supported capture format by a device. | |
81 struct MEDIA_EXPORT VideoCaptureFormat { | |
82 VideoCaptureFormat(); | |
83 VideoCaptureFormat(const gfx::Size& frame_size, | |
84 float frame_rate, | |
85 VideoPixelFormat pixel_format); | |
86 VideoCaptureFormat(const gfx::Size& frame_size, | |
87 float frame_rate, | |
88 VideoPixelFormat pixel_format, | |
89 VideoPixelStorage pixel_storage); | |
90 | |
91 static std::string ToString(const VideoCaptureFormat& format); | |
92 static std::string PixelStorageToString(VideoPixelStorage storage); | |
93 | |
94 // Compares the priority of the pixel formats. Returns true if |lhs| is the | |
95 // preferred pixel format in comparison with |rhs|. Returns false otherwise. | |
96 static bool ComparePixelFormatPreference(const VideoPixelFormat& lhs, | |
97 const VideoPixelFormat& rhs); | |
98 | |
99 // Returns the required buffer size to hold an image of a given | |
100 // VideoCaptureFormat with no padding and tightly packed. | |
101 size_t ImageAllocationSize() const; | |
102 | |
103 // Checks that all values are in the expected range. All limits are specified | |
104 // in media::Limits. | |
105 bool IsValid() const; | |
106 | |
107 bool operator==(const VideoCaptureFormat& other) const { | |
108 return frame_size == other.frame_size && | |
109 frame_rate == other.frame_rate && | |
110 pixel_format == other.pixel_format; | |
111 } | |
112 | |
113 gfx::Size frame_size; | |
114 float frame_rate; | |
115 VideoPixelFormat pixel_format; | |
116 VideoPixelStorage pixel_storage; | |
117 }; | |
118 | |
119 typedef std::vector<VideoCaptureFormat> VideoCaptureFormats; | |
120 | |
121 // Parameters for starting video capture. | |
122 // This class is used by the client of a video capture device to specify the | |
123 // format of frames in which the client would like to have captured frames | |
124 // returned. | |
125 struct MEDIA_EXPORT VideoCaptureParams { | |
126 VideoCaptureParams(); | |
127 | |
128 // Returns true if requested_format.IsValid() and all other values are within | |
129 // their expected ranges. | |
130 bool IsValid() const; | |
131 | |
132 bool operator==(const VideoCaptureParams& other) const { | |
133 return requested_format == other.requested_format && | |
134 resolution_change_policy == other.resolution_change_policy && | |
135 power_line_frequency == other.power_line_frequency; | |
136 } | |
137 | |
138 // Requests a resolution and format at which the capture will occur. | |
139 VideoCaptureFormat requested_format; | |
140 | |
141 // Policy for resolution change. | |
142 ResolutionChangePolicy resolution_change_policy; | |
143 | |
144 // User-specified power line frequency. | |
145 PowerLineFrequency power_line_frequency; | |
146 }; | |
147 | |
148 } // namespace media | |
149 | |
150 #endif // MEDIA_BASE_VIDEO_CAPTURE_TYPES_H_ | |
OLD | NEW |