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