MediaProfiles.h revision 669012d77b00a2aacb6fd12837f2870f9ec17865 
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
24namespace android {
25
26enum 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 */
55enum 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
62enum video_decoder {
63    VIDEO_DECODER_WMV,
64};
65
66enum audio_decoder {
67    AUDIO_DECODER_WMA,
68};
69
70
71class MediaProfiles
72{
73public:
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
197private:
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
205    MediaProfiles() { mVideoEditorCap = NULL; }        // Dummy default constructor
206    ~MediaProfiles();                                // Don't delete me
207
208    struct VideoCodec {
209        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
216        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
224        ~VideoCodec() {}
225
226        video_encoder mCodec;
227        int mBitRate;
228        int mFrameWidth;
229        int mFrameHeight;
230        int mFrameRate;
231    };
232
233    struct AudioCodec {
234        AudioCodec(audio_encoder codec, int bitRate, int sampleRate, int channels)
235            : mCodec(codec),
236              mBitRate(bitRate),
237              mSampleRate(sampleRate),
238              mChannels(channels) {}
239
240        AudioCodec(const AudioCodec& copy) {
241            mCodec = copy.mCodec;
242            mBitRate = copy.mBitRate;
243            mSampleRate = copy.mSampleRate;
244            mChannels = copy.mChannels;
245        }
246
247        ~AudioCodec() {}
248
249        audio_encoder mCodec;
250        int mBitRate;
251        int mSampleRate;
252        int mChannels;
253    };
254
255    struct CamcorderProfile {
256        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
264        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
273        ~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
288        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
299         ~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
310        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
319        ~AudioEncoderCap() {}
320
321        audio_encoder mCodec;
322        int mMinBitRate, mMaxBitRate;
323        int mMinSampleRate, mMaxSampleRate;
324        int mMinChannels, mMaxChannels;
325    };
326
327    struct VideoDecoderCap {
328        VideoDecoderCap(video_decoder codec): mCodec(codec) {}
329        ~VideoDecoderCap() {}
330
331        video_decoder mCodec;
332    };
333
334    struct AudioDecoderCap {
335        AudioDecoderCap(audio_decoder codec): mCodec(codec) {}
336        ~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 {
351        ExportVideoProfile(int codec, int profile, int level)
352            :mCodec(codec),mProfile(profile),mLevel(level) {}
353        ~ExportVideoProfile() {}
354        int mCodec;
355        int mProfile;
356        int mLevel;
357    };
358    struct VideoEditorCap {
359        VideoEditorCap(int inFrameWidth, int inFrameHeight,
360            int outFrameWidth, int outFrameHeight)
361            : mMaxInputFrameWidth(inFrameWidth),
362              mMaxInputFrameHeight(inFrameHeight),
363              mMaxOutputFrameWidth(outFrameWidth),
364              mMaxOutputFrameHeight(outFrameHeight) {}
365
366        ~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