• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  **
3  ** Copyright 2010, The Android Open Source Project.
4  **
5  ** Licensed under the Apache License, Version 2.0 (the "License");
6  ** you may not use this file except in compliance with the License.
7  ** You may obtain a copy of the License at
8  **
9  **     http://www.apache.org/licenses/LICENSE-2.0
10  **
11  ** Unless required by applicable law or agreed to in writing, software
12  ** distributed under the License is distributed on an "AS IS" BASIS,
13  ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  ** See the License for the specific language governing permissions and
15  ** limitations under the License.
16  */
17 
18 #ifndef ANDROID_MEDIAPROFILES_H
19 #define ANDROID_MEDIAPROFILES_H
20 
21 #include <utils/threads.h>
22 #include <media/mediarecorder.h>
23 
24 namespace android {
25 
26 enum camcorder_quality {
27     CAMCORDER_QUALITY_LIST_START = 0,
28     CAMCORDER_QUALITY_LOW  = 0,
29     CAMCORDER_QUALITY_HIGH = 1,
30     CAMCORDER_QUALITY_QCIF = 2,
31     CAMCORDER_QUALITY_CIF = 3,
32     CAMCORDER_QUALITY_480P = 4,
33     CAMCORDER_QUALITY_720P = 5,
34     CAMCORDER_QUALITY_1080P = 6,
35     CAMCORDER_QUALITY_QVGA = 7,
36     CAMCORDER_QUALITY_2160P = 8,
37     CAMCORDER_QUALITY_LIST_END = 8,
38 
39     CAMCORDER_QUALITY_TIME_LAPSE_LIST_START = 1000,
40     CAMCORDER_QUALITY_TIME_LAPSE_LOW  = 1000,
41     CAMCORDER_QUALITY_TIME_LAPSE_HIGH = 1001,
42     CAMCORDER_QUALITY_TIME_LAPSE_QCIF = 1002,
43     CAMCORDER_QUALITY_TIME_LAPSE_CIF = 1003,
44     CAMCORDER_QUALITY_TIME_LAPSE_480P = 1004,
45     CAMCORDER_QUALITY_TIME_LAPSE_720P = 1005,
46     CAMCORDER_QUALITY_TIME_LAPSE_1080P = 1006,
47     CAMCORDER_QUALITY_TIME_LAPSE_QVGA = 1007,
48     CAMCORDER_QUALITY_TIME_LAPSE_2160P = 1008,
49     CAMCORDER_QUALITY_TIME_LAPSE_LIST_END = 1008,
50 
51     CAMCORDER_QUALITY_HIGH_SPEED_LIST_START = 2000,
52     CAMCORDER_QUALITY_HIGH_SPEED_LOW  = 2000,
53     CAMCORDER_QUALITY_HIGH_SPEED_HIGH = 2001,
54     CAMCORDER_QUALITY_HIGH_SPEED_480P = 2002,
55     CAMCORDER_QUALITY_HIGH_SPEED_720P = 2003,
56     CAMCORDER_QUALITY_HIGH_SPEED_1080P = 2004,
57     CAMCORDER_QUALITY_HIGH_SPEED_2160P = 2005,
58     CAMCORDER_QUALITY_HIGH_SPEED_LIST_END = 2005,
59 };
60 
61 enum video_decoder {
62     VIDEO_DECODER_WMV,
63 };
64 
65 enum audio_decoder {
66     AUDIO_DECODER_WMA,
67 };
68 
69 
70 class MediaProfiles
71 {
72 public:
73 
74     /*
75      * If property media.settings.xml is not set:
76      *
77      * getInstance() will search through paths listed in xmlFiles.
78      * The search goes through members of xmlFiles in the order that they are
79      * defined, so files at lower indices have higher priority than those at
80      * higher indices.
81      *
82      * TODO: Add runtime validation of xml files. A search should be considered
83      * successful only when validation is successful.
84      */
85     static constexpr char const * const xmlFiles[] = {
86             "odm/etc/media_profiles_V1_0.xml",
87             "vendor/etc/media_profiles_V1_0.xml",
88             "system/etc/media_profiles.xml"
89             };
90 
91     /**
92      * Returns the singleton instance for subsequence queries or NULL if error.
93      *
94      * If property media.settings.xml is set, getInstance() will attempt to read
95      * from file path in media.settings.xml. Otherwise, getInstance() will
96      * search through the list xmlFiles as described above.
97      *
98      * If the search is unsuccessful, the default instance will be created
99      * instead.
100      *
101      * TODO: After validation is added, getInstance() should handle validation
102      * failure properly.
103      */
104     static MediaProfiles* getInstance();
105 
106     /**
107      * Returns the value for the given param name for the given camera at
108      * the given quality level, or -1 if error.
109      *
110      * Supported param name are:
111      * duration - the recording duration.
112      * file.format - output file format. see mediarecorder.h for details
113      * vid.codec - video encoder. see mediarecorder.h for details.
114      * aud.codec - audio encoder. see mediarecorder.h for details.
115      * vid.width - video frame width
116      * vid.height - video frame height
117      * vid.fps - video frame rate
118      * vid.bps - video bit rate
119      * aud.bps - audio bit rate
120      * aud.hz - audio sample rate
121      * aud.ch - number of audio channels
122      */
123     int getCamcorderProfileParamByName(const char *name, int cameraId,
124                                        camcorder_quality quality) const;
125 
126     /**
127      * Returns true if a profile for the given camera at the given quality exists,
128      * or false if not.
129      */
130     bool hasCamcorderProfile(int cameraId, camcorder_quality quality) const;
131 
132     /**
133      * Returns the output file formats supported.
134      */
135     Vector<output_format> getOutputFileFormats() const;
136 
137     /**
138      * Returns the video encoders supported.
139      */
140     Vector<video_encoder> getVideoEncoders() const;
141 
142     /**
143      * Returns the value for the given param name for the given video encoder
144      * returned from getVideoEncoderByIndex or -1 if error.
145      *
146      * Supported param name are:
147      * enc.vid.width.min - min video frame width
148      * enc.vid.width.max - max video frame width
149      * enc.vid.height.min - min video frame height
150      * enc.vid.height.max - max video frame height
151      * enc.vid.bps.min - min bit rate in bits per second
152      * enc.vid.bps.max - max bit rate in bits per second
153      * enc.vid.fps.min - min frame rate in frames per second
154      * enc.vid.fps.max - max frame rate in frames per second
155      */
156     int getVideoEncoderParamByName(const char *name, video_encoder codec) const;
157 
158     /**
159      * Returns the audio encoders supported.
160      */
161     Vector<audio_encoder> getAudioEncoders() const;
162 
163     /**
164      * Returns the value for the given param name for the given audio encoder
165      * returned from getAudioEncoderByIndex or -1 if error.
166      *
167      * Supported param name are:
168      * enc.aud.ch.min - min number of channels
169      * enc.aud.ch.max - max number of channels
170      * enc.aud.bps.min - min bit rate in bits per second
171      * enc.aud.bps.max - max bit rate in bits per second
172      * enc.aud.hz.min - min sample rate in samples per second
173      * enc.aud.hz.max - max sample rate in samples per second
174      */
175     int getAudioEncoderParamByName(const char *name, audio_encoder codec) const;
176 
177     /**
178       * Returns the video decoders supported.
179       */
180     Vector<video_decoder> getVideoDecoders() const;
181 
182      /**
183       * Returns the audio decoders supported.
184       */
185     Vector<audio_decoder> getAudioDecoders() const;
186 
187     /**
188      * Returns the number of image encoding quality levels supported.
189      */
190     Vector<int> getImageEncodingQualityLevels(int cameraId) const;
191 
192     /**
193      * Returns the start time offset (in ms) for the given camera Id.
194      * If the given camera Id does not exist, -1 will be returned.
195      */
196     int getStartTimeOffsetMs(int cameraId) const;
197 
198 private:
199     enum {
200         // Camcorder profiles (high/low) and timelapse profiles (high/low)
201         kNumRequiredProfiles = 4,
202     };
203 
204     MediaProfiles& operator=(const MediaProfiles&);  // Don't call me
205     MediaProfiles(const MediaProfiles&);             // Don't call me
MediaProfiles()206     MediaProfiles() {}                               // Dummy default constructor
207     ~MediaProfiles();                                // Don't delete me
208 
209     struct VideoCodec {
VideoCodecVideoCodec210         VideoCodec(video_encoder codec, int bitRate, int frameWidth, int frameHeight, int frameRate)
211             : mCodec(codec),
212               mBitRate(bitRate),
213               mFrameWidth(frameWidth),
214               mFrameHeight(frameHeight),
215               mFrameRate(frameRate) {}
216 
VideoCodecVideoCodec217         VideoCodec(const VideoCodec& copy) {
218             mCodec = copy.mCodec;
219             mBitRate = copy.mBitRate;
220             mFrameWidth = copy.mFrameWidth;
221             mFrameHeight = copy.mFrameHeight;
222             mFrameRate = copy.mFrameRate;
223         }
224 
~VideoCodecVideoCodec225         ~VideoCodec() {}
226 
227         video_encoder mCodec;
228         int mBitRate;
229         int mFrameWidth;
230         int mFrameHeight;
231         int mFrameRate;
232     };
233 
234     struct AudioCodec {
AudioCodecAudioCodec235         AudioCodec(audio_encoder codec, int bitRate, int sampleRate, int channels)
236             : mCodec(codec),
237               mBitRate(bitRate),
238               mSampleRate(sampleRate),
239               mChannels(channels) {}
240 
AudioCodecAudioCodec241         AudioCodec(const AudioCodec& copy) {
242             mCodec = copy.mCodec;
243             mBitRate = copy.mBitRate;
244             mSampleRate = copy.mSampleRate;
245             mChannels = copy.mChannels;
246         }
247 
~AudioCodecAudioCodec248         ~AudioCodec() {}
249 
250         audio_encoder mCodec;
251         int mBitRate;
252         int mSampleRate;
253         int mChannels;
254     };
255 
256     struct CamcorderProfile {
CamcorderProfileCamcorderProfile257         CamcorderProfile()
258             : mCameraId(0),
259               mFileFormat(OUTPUT_FORMAT_THREE_GPP),
260               mQuality(CAMCORDER_QUALITY_HIGH),
261               mDuration(0),
262               mVideoCodec(0),
263               mAudioCodec(0) {}
264 
CamcorderProfileCamcorderProfile265         CamcorderProfile(const CamcorderProfile& copy) {
266             mCameraId = copy.mCameraId;
267             mFileFormat = copy.mFileFormat;
268             mQuality = copy.mQuality;
269             mDuration = copy.mDuration;
270             mVideoCodec = new VideoCodec(*copy.mVideoCodec);
271             mAudioCodec = new AudioCodec(*copy.mAudioCodec);
272         }
273 
~CamcorderProfileCamcorderProfile274         ~CamcorderProfile() {
275             delete mVideoCodec;
276             delete mAudioCodec;
277         }
278 
279         int mCameraId;
280         output_format mFileFormat;
281         camcorder_quality mQuality;
282         int mDuration;
283         VideoCodec *mVideoCodec;
284         AudioCodec *mAudioCodec;
285     };
286 
287     struct VideoEncoderCap {
288         // Ugly constructor
VideoEncoderCapVideoEncoderCap289         VideoEncoderCap(video_encoder codec,
290                         int minBitRate, int maxBitRate,
291                         int minFrameWidth, int maxFrameWidth,
292                         int minFrameHeight, int maxFrameHeight,
293                         int minFrameRate, int maxFrameRate)
294             : mCodec(codec),
295               mMinBitRate(minBitRate), mMaxBitRate(maxBitRate),
296               mMinFrameWidth(minFrameWidth), mMaxFrameWidth(maxFrameWidth),
297               mMinFrameHeight(minFrameHeight), mMaxFrameHeight(maxFrameHeight),
298               mMinFrameRate(minFrameRate), mMaxFrameRate(maxFrameRate) {}
299 
~VideoEncoderCapVideoEncoderCap300          ~VideoEncoderCap() {}
301 
302         video_encoder mCodec;
303         int mMinBitRate, mMaxBitRate;
304         int mMinFrameWidth, mMaxFrameWidth;
305         int mMinFrameHeight, mMaxFrameHeight;
306         int mMinFrameRate, mMaxFrameRate;
307     };
308 
309     struct AudioEncoderCap {
310         // Ugly constructor
AudioEncoderCapAudioEncoderCap311         AudioEncoderCap(audio_encoder codec,
312                         int minBitRate, int maxBitRate,
313                         int minSampleRate, int maxSampleRate,
314                         int minChannels, int maxChannels)
315             : mCodec(codec),
316               mMinBitRate(minBitRate), mMaxBitRate(maxBitRate),
317               mMinSampleRate(minSampleRate), mMaxSampleRate(maxSampleRate),
318               mMinChannels(minChannels), mMaxChannels(maxChannels) {}
319 
~AudioEncoderCapAudioEncoderCap320         ~AudioEncoderCap() {}
321 
322         audio_encoder mCodec;
323         int mMinBitRate, mMaxBitRate;
324         int mMinSampleRate, mMaxSampleRate;
325         int mMinChannels, mMaxChannels;
326     };
327 
328     struct VideoDecoderCap {
VideoDecoderCapVideoDecoderCap329         VideoDecoderCap(video_decoder codec): mCodec(codec) {}
~VideoDecoderCapVideoDecoderCap330         ~VideoDecoderCap() {}
331 
332         video_decoder mCodec;
333     };
334 
335     struct AudioDecoderCap {
AudioDecoderCapAudioDecoderCap336         AudioDecoderCap(audio_decoder codec): mCodec(codec) {}
~AudioDecoderCapAudioDecoderCap337         ~AudioDecoderCap() {}
338 
339         audio_decoder mCodec;
340     };
341 
342     struct NameToTagMap {
343         const char* name;
344         int tag;
345     };
346 
347     struct ImageEncodingQualityLevels {
348         int mCameraId;
349         Vector<int> mLevels;
350     };
351 
352     int getCamcorderProfileIndex(int cameraId, camcorder_quality quality) const;
353     void initRequiredProfileRefs(const Vector<int>& cameraIds);
354     int getRequiredProfileRefIndex(int cameraId);
355 
356     // Debug
357     static void logVideoCodec(const VideoCodec& codec);
358     static void logAudioCodec(const AudioCodec& codec);
359     static void logVideoEncoderCap(const VideoEncoderCap& cap);
360     static void logAudioEncoderCap(const AudioEncoderCap& cap);
361     static void logVideoDecoderCap(const VideoDecoderCap& cap);
362     static void logAudioDecoderCap(const AudioDecoderCap& cap);
363 
364     // Returns true if xmlFile exists.
365     // TODO: Add runtime validation.
366     static bool checkXmlFile(const char* xmlFile);
367 
368     // If the xml configuration file does exist, use the settings
369     // from the xml
370     static MediaProfiles* createInstanceFromXmlFile(const char *xml);
371     static output_format createEncoderOutputFileFormat(const char **atts);
372     static VideoCodec* createVideoCodec(const char **atts, MediaProfiles *profiles);
373     static AudioCodec* createAudioCodec(const char **atts, MediaProfiles *profiles);
374     static AudioDecoderCap* createAudioDecoderCap(const char **atts);
375     static VideoDecoderCap* createVideoDecoderCap(const char **atts);
376     static VideoEncoderCap* createVideoEncoderCap(const char **atts);
377     static AudioEncoderCap* createAudioEncoderCap(const char **atts);
378 
379     static CamcorderProfile* createCamcorderProfile(
380                 int cameraId, const char **atts, Vector<int>& cameraIds);
381 
382     static int getCameraId(const char **atts);
383 
384     void addStartTimeOffset(int cameraId, const char **atts);
385 
386     ImageEncodingQualityLevels* findImageEncodingQualityLevels(int cameraId) const;
387     void addImageEncodingQualityLevel(int cameraId, const char** atts);
388 
389     // Customized element tag handler for parsing the xml configuration file.
390     static void startElementHandler(void *userData, const char *name, const char **atts);
391 
392     // If the xml configuration file does not exist, use hard-coded values
393     static MediaProfiles* createDefaultInstance();
394 
395     static CamcorderProfile *createDefaultCamcorderQcifProfile(camcorder_quality quality);
396     static CamcorderProfile *createDefaultCamcorderCifProfile(camcorder_quality quality);
397     static void createDefaultCamcorderLowProfiles(
398             MediaProfiles::CamcorderProfile **lowProfile,
399             MediaProfiles::CamcorderProfile **lowSpecificProfile);
400     static void createDefaultCamcorderHighProfiles(
401             MediaProfiles::CamcorderProfile **highProfile,
402             MediaProfiles::CamcorderProfile **highSpecificProfile);
403 
404     static CamcorderProfile *createDefaultCamcorderTimeLapseQcifProfile(camcorder_quality quality);
405     static CamcorderProfile *createDefaultCamcorderTimeLapse480pProfile(camcorder_quality quality);
406     static void createDefaultCamcorderTimeLapseLowProfiles(
407             MediaProfiles::CamcorderProfile **lowTimeLapseProfile,
408             MediaProfiles::CamcorderProfile **lowSpecificTimeLapseProfile);
409     static void createDefaultCamcorderTimeLapseHighProfiles(
410             MediaProfiles::CamcorderProfile **highTimeLapseProfile,
411             MediaProfiles::CamcorderProfile **highSpecificTimeLapseProfile);
412 
413     static void createDefaultCamcorderProfiles(MediaProfiles *profiles);
414     static void createDefaultVideoEncoders(MediaProfiles *profiles);
415     static void createDefaultAudioEncoders(MediaProfiles *profiles);
416     static void createDefaultVideoDecoders(MediaProfiles *profiles);
417     static void createDefaultAudioDecoders(MediaProfiles *profiles);
418     static void createDefaultEncoderOutputFileFormats(MediaProfiles *profiles);
419     static void createDefaultImageEncodingQualityLevels(MediaProfiles *profiles);
420     static void createDefaultImageDecodingMaxMemory(MediaProfiles *profiles);
421 
422     static VideoEncoderCap* createDefaultH263VideoEncoderCap();
423     static VideoEncoderCap* createDefaultM4vVideoEncoderCap();
424     static AudioEncoderCap* createDefaultAmrNBEncoderCap();
425 
426     static int findTagForName(const NameToTagMap *map, size_t nMappings, const char *name);
427 
428     /**
429      * Check on existing profiles with the following criteria:
430      * 1. Low quality profile must have the lowest video
431      *    resolution product (width x height)
432      * 2. High quality profile must have the highest video
433      *    resolution product (width x height)
434      *
435      * and add required low/high quality camcorder/timelapse
436      * profiles if they are not found. This allows to remove
437      * duplicate profile definitions in the media_profiles.xml
438      * file.
439      */
440     void checkAndAddRequiredProfilesIfNecessary();
441 
442 
443     // Mappings from name (for instance, codec name) to enum value
444     static const NameToTagMap sVideoEncoderNameMap[];
445     static const NameToTagMap sAudioEncoderNameMap[];
446     static const NameToTagMap sFileFormatMap[];
447     static const NameToTagMap sVideoDecoderNameMap[];
448     static const NameToTagMap sAudioDecoderNameMap[];
449     static const NameToTagMap sCamcorderQualityNameMap[];
450 
451     static bool sIsInitialized;
452     static MediaProfiles *sInstance;
453     static Mutex sLock;
454     int mCurrentCameraId;
455 
456     Vector<CamcorderProfile*> mCamcorderProfiles;
457     Vector<AudioEncoderCap*>  mAudioEncoders;
458     Vector<VideoEncoderCap*>  mVideoEncoders;
459     Vector<AudioDecoderCap*>  mAudioDecoders;
460     Vector<VideoDecoderCap*>  mVideoDecoders;
461     Vector<output_format>     mEncoderOutputFileFormats;
462     Vector<ImageEncodingQualityLevels *>  mImageEncodingQualityLevels;
463     KeyedVector<int, int> mStartTimeOffsets;
464 
465     typedef struct {
466         bool mHasRefProfile;      // Refers to an existing profile
467         int  mRefProfileIndex;    // Reference profile index
468         int  mResolutionProduct;  // width x height
469     } RequiredProfileRefInfo;     // Required low and high profiles
470 
471     typedef struct {
472         RequiredProfileRefInfo mRefs[kNumRequiredProfiles];
473         int mCameraId;
474     } RequiredProfiles;
475 
476     RequiredProfiles *mRequiredProfileRefs;
477     Vector<int>              mCameraIds;
478 };
479 
480 }; // namespace android
481 
482 #endif // ANDROID_MEDIAPROFILES_H
483