• 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_LIST_END = 7,
37 
38     CAMCORDER_QUALITY_TIME_LAPSE_LIST_START = 1000,
39     CAMCORDER_QUALITY_TIME_LAPSE_LOW  = 1000,
40     CAMCORDER_QUALITY_TIME_LAPSE_HIGH = 1001,
41     CAMCORDER_QUALITY_TIME_LAPSE_QCIF = 1002,
42     CAMCORDER_QUALITY_TIME_LAPSE_CIF = 1003,
43     CAMCORDER_QUALITY_TIME_LAPSE_480P = 1004,
44     CAMCORDER_QUALITY_TIME_LAPSE_720P = 1005,
45     CAMCORDER_QUALITY_TIME_LAPSE_1080P = 1006,
46     CAMCORDER_QUALITY_TIME_LAPSE_QVGA = 1007,
47     CAMCORDER_QUALITY_TIME_LAPSE_LIST_END = 1007,
48 };
49 
50 /**
51  *Set CIF as default maximum import and export resolution of video editor.
52  *The maximum import and export resolutions are platform specific,
53  *which should be defined in media_profiles.xml.
54  */
55 enum videoeditor_capability {
56     VIDEOEDITOR_DEFAULT_MAX_INPUT_FRAME_WIDTH = 352,
57     VIDEOEDITOR_DEFUALT_MAX_INPUT_FRAME_HEIGHT = 288,
58     VIDEOEDITOR_DEFAULT_MAX_OUTPUT_FRAME_WIDTH = 352,
59     VIDEOEDITOR_DEFUALT_MAX_OUTPUT_FRAME_HEIGHT = 288,
60 };
61 
62 enum video_decoder {
63     VIDEO_DECODER_WMV,
64 };
65 
66 enum audio_decoder {
67     AUDIO_DECODER_WMA,
68 };
69 
70 
71 class MediaProfiles
72 {
73 public:
74 
75     /**
76      * Returns the singleton instance for subsequence queries.
77      * or NULL if error.
78      */
79     static MediaProfiles* getInstance();
80 
81     /**
82      * Returns the value for the given param name for the given camera at
83      * the given quality level, or -1 if error.
84      *
85      * Supported param name are:
86      * duration - the recording duration.
87      * file.format - output file format. see mediarecorder.h for details
88      * vid.codec - video encoder. see mediarecorder.h for details.
89      * aud.codec - audio encoder. see mediarecorder.h for details.
90      * vid.width - video frame width
91      * vid.height - video frame height
92      * vid.fps - video frame rate
93      * vid.bps - video bit rate
94      * aud.bps - audio bit rate
95      * aud.hz - audio sample rate
96      * aud.ch - number of audio channels
97      */
98     int getCamcorderProfileParamByName(const char *name, int cameraId,
99                                        camcorder_quality quality) const;
100 
101     /**
102      * Returns true if a profile for the given camera at the given quality exists,
103      * or false if not.
104      */
105     bool hasCamcorderProfile(int cameraId, camcorder_quality quality) const;
106 
107     /**
108      * Returns the output file formats supported.
109      */
110     Vector<output_format> getOutputFileFormats() const;
111 
112     /**
113      * Returns the video encoders supported.
114      */
115     Vector<video_encoder> getVideoEncoders() const;
116 
117     /**
118      * Returns the value for the given param name for the given video encoder
119      * returned from getVideoEncoderByIndex or -1 if error.
120      *
121      * Supported param name are:
122      * enc.vid.width.min - min video frame width
123      * enc.vid.width.max - max video frame width
124      * enc.vid.height.min - min video frame height
125      * enc.vid.height.max - max video frame height
126      * enc.vid.bps.min - min bit rate in bits per second
127      * enc.vid.bps.max - max bit rate in bits per second
128      * enc.vid.fps.min - min frame rate in frames per second
129      * enc.vid.fps.max - max frame rate in frames per second
130      */
131     int getVideoEncoderParamByName(const char *name, video_encoder codec) const;
132 
133     /**
134      * Returns the value for the given param name for the video editor cap
135      * param or -1 if error.
136      * Supported param name are:
137      * videoeditor.input.width.max - max input video frame width
138      * videoeditor.input.height.max - max input video frame height
139      * videoeditor.output.width.max - max output video frame width
140      * videoeditor.output.height.max - max output video frame height
141      */
142     int getVideoEditorCapParamByName(const char *name) const;
143 
144     /**
145      * Returns the value for the given param name for the video editor export codec format
146      * param or -1 if error.
147      * Supported param name are:
148      * videoeditor.export.profile - export video profile
149      * videoeditor.export.level - export video level
150      * Supported param codec are:
151      * 1 for h263
152      * 2 for h264
153      * 3 for mpeg4
154      */
155     int getVideoEditorExportParamByName(const char *name, int codec) const;
156 
157     /**
158      * Returns the audio encoders supported.
159      */
160     Vector<audio_encoder> getAudioEncoders() const;
161 
162     /**
163      * Returns the value for the given param name for the given audio encoder
164      * returned from getAudioEncoderByIndex or -1 if error.
165      *
166      * Supported param name are:
167      * enc.aud.ch.min - min number of channels
168      * enc.aud.ch.max - max number of channels
169      * enc.aud.bps.min - min bit rate in bits per second
170      * enc.aud.bps.max - max bit rate in bits per second
171      * enc.aud.hz.min - min sample rate in samples per second
172      * enc.aud.hz.max - max sample rate in samples per second
173      */
174     int getAudioEncoderParamByName(const char *name, audio_encoder codec) const;
175 
176     /**
177       * Returns the video decoders supported.
178       */
179     Vector<video_decoder> getVideoDecoders() const;
180 
181      /**
182       * Returns the audio decoders supported.
183       */
184     Vector<audio_decoder> getAudioDecoders() const;
185 
186     /**
187      * Returns the number of image encoding quality levels supported.
188      */
189     Vector<int> getImageEncodingQualityLevels(int cameraId) const;
190 
191     /**
192      * Returns the start time offset (in ms) for the given camera Id.
193      * If the given camera Id does not exist, -1 will be returned.
194      */
195     int getStartTimeOffsetMs(int cameraId) const;
196 
197 private:
198     enum {
199         // Camcorder profiles (high/low) and timelapse profiles (high/low)
200         kNumRequiredProfiles = 4,
201     };
202 
203     MediaProfiles& operator=(const MediaProfiles&);  // Don't call me
204     MediaProfiles(const MediaProfiles&);             // Don't call me
MediaProfiles()205     MediaProfiles() { mVideoEditorCap = NULL; }        // Dummy default constructor
206     ~MediaProfiles();                                // Don't delete me
207 
208     struct VideoCodec {
VideoCodecVideoCodec209         VideoCodec(video_encoder codec, int bitRate, int frameWidth, int frameHeight, int frameRate)
210             : mCodec(codec),
211               mBitRate(bitRate),
212               mFrameWidth(frameWidth),
213               mFrameHeight(frameHeight),
214               mFrameRate(frameRate) {}
215 
VideoCodecVideoCodec216         VideoCodec(const VideoCodec& copy) {
217             mCodec = copy.mCodec;
218             mBitRate = copy.mBitRate;
219             mFrameWidth = copy.mFrameWidth;
220             mFrameHeight = copy.mFrameHeight;
221             mFrameRate = copy.mFrameRate;
222         }
223 
~VideoCodecVideoCodec224         ~VideoCodec() {}
225 
226         video_encoder mCodec;
227         int mBitRate;
228         int mFrameWidth;
229         int mFrameHeight;
230         int mFrameRate;
231     };
232 
233     struct AudioCodec {
AudioCodecAudioCodec234         AudioCodec(audio_encoder codec, int bitRate, int sampleRate, int channels)
235             : mCodec(codec),
236               mBitRate(bitRate),
237               mSampleRate(sampleRate),
238               mChannels(channels) {}
239 
AudioCodecAudioCodec240         AudioCodec(const AudioCodec& copy) {
241             mCodec = copy.mCodec;
242             mBitRate = copy.mBitRate;
243             mSampleRate = copy.mSampleRate;
244             mChannels = copy.mChannels;
245         }
246 
~AudioCodecAudioCodec247         ~AudioCodec() {}
248 
249         audio_encoder mCodec;
250         int mBitRate;
251         int mSampleRate;
252         int mChannels;
253     };
254 
255     struct CamcorderProfile {
CamcorderProfileCamcorderProfile256         CamcorderProfile()
257             : mCameraId(0),
258               mFileFormat(OUTPUT_FORMAT_THREE_GPP),
259               mQuality(CAMCORDER_QUALITY_HIGH),
260               mDuration(0),
261               mVideoCodec(0),
262               mAudioCodec(0) {}
263 
CamcorderProfileCamcorderProfile264         CamcorderProfile(const CamcorderProfile& copy) {
265             mCameraId = copy.mCameraId;
266             mFileFormat = copy.mFileFormat;
267             mQuality = copy.mQuality;
268             mDuration = copy.mDuration;
269             mVideoCodec = new VideoCodec(*copy.mVideoCodec);
270             mAudioCodec = new AudioCodec(*copy.mAudioCodec);
271         }
272 
~CamcorderProfileCamcorderProfile273         ~CamcorderProfile() {
274             delete mVideoCodec;
275             delete mAudioCodec;
276         }
277 
278         int mCameraId;
279         output_format mFileFormat;
280         camcorder_quality mQuality;
281         int mDuration;
282         VideoCodec *mVideoCodec;
283         AudioCodec *mAudioCodec;
284     };
285 
286     struct VideoEncoderCap {
287         // Ugly constructor
VideoEncoderCapVideoEncoderCap288         VideoEncoderCap(video_encoder codec,
289                         int minBitRate, int maxBitRate,
290                         int minFrameWidth, int maxFrameWidth,
291                         int minFrameHeight, int maxFrameHeight,
292                         int minFrameRate, int maxFrameRate)
293             : mCodec(codec),
294               mMinBitRate(minBitRate), mMaxBitRate(maxBitRate),
295               mMinFrameWidth(minFrameWidth), mMaxFrameWidth(maxFrameWidth),
296               mMinFrameHeight(minFrameHeight), mMaxFrameHeight(maxFrameHeight),
297               mMinFrameRate(minFrameRate), mMaxFrameRate(maxFrameRate) {}
298 
~VideoEncoderCapVideoEncoderCap299          ~VideoEncoderCap() {}
300 
301         video_encoder mCodec;
302         int mMinBitRate, mMaxBitRate;
303         int mMinFrameWidth, mMaxFrameWidth;
304         int mMinFrameHeight, mMaxFrameHeight;
305         int mMinFrameRate, mMaxFrameRate;
306     };
307 
308     struct AudioEncoderCap {
309         // Ugly constructor
AudioEncoderCapAudioEncoderCap310         AudioEncoderCap(audio_encoder codec,
311                         int minBitRate, int maxBitRate,
312                         int minSampleRate, int maxSampleRate,
313                         int minChannels, int maxChannels)
314             : mCodec(codec),
315               mMinBitRate(minBitRate), mMaxBitRate(maxBitRate),
316               mMinSampleRate(minSampleRate), mMaxSampleRate(maxSampleRate),
317               mMinChannels(minChannels), mMaxChannels(maxChannels) {}
318 
~AudioEncoderCapAudioEncoderCap319         ~AudioEncoderCap() {}
320 
321         audio_encoder mCodec;
322         int mMinBitRate, mMaxBitRate;
323         int mMinSampleRate, mMaxSampleRate;
324         int mMinChannels, mMaxChannels;
325     };
326 
327     struct VideoDecoderCap {
VideoDecoderCapVideoDecoderCap328         VideoDecoderCap(video_decoder codec): mCodec(codec) {}
~VideoDecoderCapVideoDecoderCap329         ~VideoDecoderCap() {}
330 
331         video_decoder mCodec;
332     };
333 
334     struct AudioDecoderCap {
AudioDecoderCapAudioDecoderCap335         AudioDecoderCap(audio_decoder codec): mCodec(codec) {}
~AudioDecoderCapAudioDecoderCap336         ~AudioDecoderCap() {}
337 
338         audio_decoder mCodec;
339     };
340 
341     struct NameToTagMap {
342         const char* name;
343         int tag;
344     };
345 
346     struct ImageEncodingQualityLevels {
347         int mCameraId;
348         Vector<int> mLevels;
349     };
350     struct ExportVideoProfile {
ExportVideoProfileExportVideoProfile351         ExportVideoProfile(int codec, int profile, int level)
352             :mCodec(codec),mProfile(profile),mLevel(level) {}
~ExportVideoProfileExportVideoProfile353         ~ExportVideoProfile() {}
354         int mCodec;
355         int mProfile;
356         int mLevel;
357     };
358     struct VideoEditorCap {
VideoEditorCapVideoEditorCap359         VideoEditorCap(int inFrameWidth, int inFrameHeight,
360             int outFrameWidth, int outFrameHeight)
361             : mMaxInputFrameWidth(inFrameWidth),
362               mMaxInputFrameHeight(inFrameHeight),
363               mMaxOutputFrameWidth(outFrameWidth),
364               mMaxOutputFrameHeight(outFrameHeight) {}
365 
~VideoEditorCapVideoEditorCap366         ~VideoEditorCap() {}
367 
368         int mMaxInputFrameWidth;
369         int mMaxInputFrameHeight;
370         int mMaxOutputFrameWidth;
371         int mMaxOutputFrameHeight;
372     };
373 
374     int getCamcorderProfileIndex(int cameraId, camcorder_quality quality) const;
375     void initRequiredProfileRefs(const Vector<int>& cameraIds);
376     int getRequiredProfileRefIndex(int cameraId);
377 
378     // Debug
379     static void logVideoCodec(const VideoCodec& codec);
380     static void logAudioCodec(const AudioCodec& codec);
381     static void logVideoEncoderCap(const VideoEncoderCap& cap);
382     static void logAudioEncoderCap(const AudioEncoderCap& cap);
383     static void logVideoDecoderCap(const VideoDecoderCap& cap);
384     static void logAudioDecoderCap(const AudioDecoderCap& cap);
385     static void logVideoEditorCap(const VideoEditorCap& cap);
386 
387     // If the xml configuration file does exist, use the settings
388     // from the xml
389     static MediaProfiles* createInstanceFromXmlFile(const char *xml);
390     static output_format createEncoderOutputFileFormat(const char **atts);
391     static VideoCodec* createVideoCodec(const char **atts, MediaProfiles *profiles);
392     static AudioCodec* createAudioCodec(const char **atts, MediaProfiles *profiles);
393     static AudioDecoderCap* createAudioDecoderCap(const char **atts);
394     static VideoDecoderCap* createVideoDecoderCap(const char **atts);
395     static VideoEncoderCap* createVideoEncoderCap(const char **atts);
396     static AudioEncoderCap* createAudioEncoderCap(const char **atts);
397     static VideoEditorCap* createVideoEditorCap(
398                 const char **atts, MediaProfiles *profiles);
399     static ExportVideoProfile* createExportVideoProfile(const char **atts);
400 
401     static CamcorderProfile* createCamcorderProfile(
402                 int cameraId, const char **atts, Vector<int>& cameraIds);
403 
404     static int getCameraId(const char **atts);
405 
406     void addStartTimeOffset(int cameraId, const char **atts);
407 
408     ImageEncodingQualityLevels* findImageEncodingQualityLevels(int cameraId) const;
409     void addImageEncodingQualityLevel(int cameraId, const char** atts);
410 
411     // Customized element tag handler for parsing the xml configuration file.
412     static void startElementHandler(void *userData, const char *name, const char **atts);
413 
414     // If the xml configuration file does not exist, use hard-coded values
415     static MediaProfiles* createDefaultInstance();
416 
417     static CamcorderProfile *createDefaultCamcorderQcifProfile(camcorder_quality quality);
418     static CamcorderProfile *createDefaultCamcorderCifProfile(camcorder_quality quality);
419     static void createDefaultCamcorderLowProfiles(
420             MediaProfiles::CamcorderProfile **lowProfile,
421             MediaProfiles::CamcorderProfile **lowSpecificProfile);
422     static void createDefaultCamcorderHighProfiles(
423             MediaProfiles::CamcorderProfile **highProfile,
424             MediaProfiles::CamcorderProfile **highSpecificProfile);
425 
426     static CamcorderProfile *createDefaultCamcorderTimeLapseQcifProfile(camcorder_quality quality);
427     static CamcorderProfile *createDefaultCamcorderTimeLapse480pProfile(camcorder_quality quality);
428     static void createDefaultCamcorderTimeLapseLowProfiles(
429             MediaProfiles::CamcorderProfile **lowTimeLapseProfile,
430             MediaProfiles::CamcorderProfile **lowSpecificTimeLapseProfile);
431     static void createDefaultCamcorderTimeLapseHighProfiles(
432             MediaProfiles::CamcorderProfile **highTimeLapseProfile,
433             MediaProfiles::CamcorderProfile **highSpecificTimeLapseProfile);
434 
435     static void createDefaultCamcorderProfiles(MediaProfiles *profiles);
436     static void createDefaultVideoEncoders(MediaProfiles *profiles);
437     static void createDefaultAudioEncoders(MediaProfiles *profiles);
438     static void createDefaultVideoDecoders(MediaProfiles *profiles);
439     static void createDefaultAudioDecoders(MediaProfiles *profiles);
440     static void createDefaultEncoderOutputFileFormats(MediaProfiles *profiles);
441     static void createDefaultImageEncodingQualityLevels(MediaProfiles *profiles);
442     static void createDefaultImageDecodingMaxMemory(MediaProfiles *profiles);
443     static void createDefaultVideoEditorCap(MediaProfiles *profiles);
444     static void createDefaultExportVideoProfiles(MediaProfiles *profiles);
445 
446     static VideoEncoderCap* createDefaultH263VideoEncoderCap();
447     static VideoEncoderCap* createDefaultM4vVideoEncoderCap();
448     static AudioEncoderCap* createDefaultAmrNBEncoderCap();
449 
450     static int findTagForName(const NameToTagMap *map, size_t nMappings, const char *name);
451 
452     /**
453      * Check on existing profiles with the following criteria:
454      * 1. Low quality profile must have the lowest video
455      *    resolution product (width x height)
456      * 2. High quality profile must have the highest video
457      *    resolution product (width x height)
458      *
459      * and add required low/high quality camcorder/timelapse
460      * profiles if they are not found. This allows to remove
461      * duplicate profile definitions in the media_profiles.xml
462      * file.
463      */
464     void checkAndAddRequiredProfilesIfNecessary();
465 
466 
467     // Mappings from name (for instance, codec name) to enum value
468     static const NameToTagMap sVideoEncoderNameMap[];
469     static const NameToTagMap sAudioEncoderNameMap[];
470     static const NameToTagMap sFileFormatMap[];
471     static const NameToTagMap sVideoDecoderNameMap[];
472     static const NameToTagMap sAudioDecoderNameMap[];
473     static const NameToTagMap sCamcorderQualityNameMap[];
474 
475     static bool sIsInitialized;
476     static MediaProfiles *sInstance;
477     static Mutex sLock;
478     int mCurrentCameraId;
479 
480     Vector<CamcorderProfile*> mCamcorderProfiles;
481     Vector<AudioEncoderCap*>  mAudioEncoders;
482     Vector<VideoEncoderCap*>  mVideoEncoders;
483     Vector<AudioDecoderCap*>  mAudioDecoders;
484     Vector<VideoDecoderCap*>  mVideoDecoders;
485     Vector<output_format>     mEncoderOutputFileFormats;
486     Vector<ImageEncodingQualityLevels *>  mImageEncodingQualityLevels;
487     KeyedVector<int, int> mStartTimeOffsets;
488 
489     typedef struct {
490         bool mHasRefProfile;      // Refers to an existing profile
491         int  mRefProfileIndex;    // Reference profile index
492         int  mResolutionProduct;  // width x height
493     } RequiredProfileRefInfo;     // Required low and high profiles
494 
495     typedef struct {
496         RequiredProfileRefInfo mRefs[kNumRequiredProfiles];
497         int mCameraId;
498     } RequiredProfiles;
499 
500     RequiredProfiles *mRequiredProfileRefs;
501     Vector<int>              mCameraIds;
502     VideoEditorCap* mVideoEditorCap;
503     Vector<ExportVideoProfile*> mVideoEditorExportProfiles;
504 };
505 
506 }; // namespace android
507 
508 #endif // ANDROID_MEDIAPROFILES_H
509 
510