| /* |
| * Copyright 2014, The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef MEDIA_CODEC_INFO_H_ |
| |
| #define MEDIA_CODEC_INFO_H_ |
| |
| #include <android-base/macros.h> |
| #include <binder/Parcel.h> |
| #include <media/stagefright/foundation/ABase.h> |
| #include <media/stagefright/foundation/AString.h> |
| |
| #include <sys/types.h> |
| #include <utils/Errors.h> |
| #include <utils/KeyedVector.h> |
| #include <utils/RefBase.h> |
| #include <utils/Vector.h> |
| #include <utils/StrongPointer.h> |
| |
| namespace android { |
| |
| struct AMessage; |
| class Parcel; |
| |
| typedef KeyedVector<AString, AString> CodecSettings; |
| |
| struct MediaCodecInfoWriter; |
| struct MediaCodecListWriter; |
| |
| struct MediaCodecInfo : public RefBase { |
| struct ProfileLevel { |
| uint32_t mProfile; |
| uint32_t mLevel; |
| bool operator <(const ProfileLevel &o) const { |
| return mProfile < o.mProfile || (mProfile == o.mProfile && mLevel < o.mLevel); |
| } |
| }; |
| |
| struct CapabilitiesWriter; |
| |
| struct Capabilities : public RefBase { |
| enum { |
| // decoder flags |
| kFlagSupportsAdaptivePlayback = 1 << 0, |
| kFlagSupportsSecurePlayback = 1 << 1, |
| kFlagSupportsTunneledPlayback = 1 << 2, |
| |
| // encoder flags |
| kFlagSupportsIntraRefresh = 1 << 0, |
| |
| }; |
| |
| void getSupportedProfileLevels(Vector<ProfileLevel> *profileLevels) const; |
| void getSupportedColorFormats(Vector<uint32_t> *colorFormats) const; |
| uint32_t getFlags() const; |
| const sp<AMessage> getDetails() const; |
| |
| protected: |
| Vector<ProfileLevel> mProfileLevels; |
| SortedVector<ProfileLevel> mProfileLevelsSorted; |
| Vector<uint32_t> mColorFormats; |
| SortedVector<uint32_t> mColorFormatsSorted; |
| uint32_t mFlags; |
| sp<AMessage> mDetails; |
| |
| Capabilities(); |
| |
| private: |
| // read object from parcel even if object creation fails |
| static sp<Capabilities> FromParcel(const Parcel &parcel); |
| status_t writeToParcel(Parcel *parcel) const; |
| |
| DISALLOW_COPY_AND_ASSIGN(Capabilities); |
| |
| friend struct MediaCodecInfo; |
| friend struct MediaCodecInfoWriter; |
| friend struct CapabilitiesWriter; |
| }; |
| |
| /** |
| * This class is used for modifying information inside a `Capabilities` |
| * object. An object of type `CapabilitiesWriter` can be obtained by calling |
| * `MediaCodecInfoWriter::addMime()` or |
| * `MediaCodecInfoWriter::updateMime()`. |
| */ |
| struct CapabilitiesWriter { |
| /** |
| * Add a key-value pair to the list of details. If the key already |
| * exists, the old value will be replaced. |
| * |
| * A pair added by this function will be accessible by |
| * `Capabilities::getDetails()`. Call `AMessage::getString()` with the |
| * same key to retrieve the value. |
| * |
| * @param key The key. |
| * @param value The string value. |
| */ |
| void addDetail(const char* key, const char* value); |
| /** |
| * Add a key-value pair to the list of details. If the key already |
| * exists, the old value will be replaced. |
| * |
| * A pair added by this function will be accessible by |
| * `Capabilities::getDetails()`. Call `AMessage::getInt32()` with the |
| * same key to retrieve the value. |
| * |
| * @param key The key. |
| * @param value The `int32_t` value. |
| */ |
| void addDetail(const char* key, int32_t value); |
| /** |
| * Add a profile-level pair. If this profile-level pair already exists, |
| * it will be ignored. |
| * |
| * @param profile The "profile" component. |
| * @param level The "level" component. |
| */ |
| void addProfileLevel(uint32_t profile, uint32_t level); |
| /** |
| * Add a color format. If this color format already exists, it will be |
| * ignored. |
| * |
| * @param format The color format. |
| */ |
| void addColorFormat(uint32_t format); |
| /** |
| * Add flags. The underlying operation is bitwise-or. In other words, |
| * bits that have already been set will be ignored. |
| * |
| * @param flags The additional flags. |
| */ |
| void addFlags(uint32_t flags); |
| private: |
| /** |
| * The associated `Capabilities` object. |
| */ |
| Capabilities* mCap; |
| /** |
| * Construct a writer for the given `Capabilities` object. |
| * |
| * @param cap The `Capabilities` object to be written to. |
| */ |
| CapabilitiesWriter(Capabilities* cap); |
| |
| friend MediaCodecInfoWriter; |
| }; |
| |
| bool isEncoder() const; |
| void getSupportedMimes(Vector<AString> *mimes) const; |
| const sp<Capabilities> getCapabilitiesFor(const char *mime) const; |
| const char *getCodecName() const; |
| |
| /** |
| * Return the name of the service that hosts the codec. This value is not |
| * visible at the Java level. |
| * |
| * Currently, this is the "instance name" of the IOmx service. |
| */ |
| const char *getOwnerName() const; |
| uint32_t rank() const; |
| |
| /** |
| * Serialization over Binder |
| */ |
| static sp<MediaCodecInfo> FromParcel(const Parcel &parcel); |
| status_t writeToParcel(Parcel *parcel) const; |
| |
| private: |
| AString mName; |
| AString mOwner; |
| bool mIsEncoder; |
| KeyedVector<AString, sp<Capabilities> > mCaps; |
| uint32_t mRank; |
| |
| ssize_t getCapabilityIndex(const char *mime) const; |
| |
| /** |
| * Construct an `MediaCodecInfo` object. After the construction, its |
| * information can be set via an `MediaCodecInfoWriter` object obtained from |
| * `MediaCodecListWriter::addMediaCodecInfo()`. |
| */ |
| MediaCodecInfo(); |
| |
| DISALLOW_COPY_AND_ASSIGN(MediaCodecInfo); |
| |
| friend class MediaCodecListOverridesTest; |
| friend struct MediaCodecInfoWriter; |
| friend struct MediaCodecListWriter; |
| }; |
| |
| /** |
| * This class is to be used by a `MediaCodecListBuilderBase` instance to |
| * populate information inside the associated `MediaCodecInfo` object. |
| * |
| * The only place where an instance of `MediaCodecInfoWriter` can be constructed |
| * is `MediaCodecListWriter::addMediaCodecInfo()`. A `MediaCodecListBuilderBase` |
| * instance should call `MediaCodecListWriter::addMediaCodecInfo()` on the given |
| * `MediaCodecListWriter` object given as an input to |
| * `MediaCodecListBuilderBase::buildMediaCodecList()`. |
| */ |
| struct MediaCodecInfoWriter { |
| /** |
| * Set the name of the codec. |
| * |
| * @param name The new name. |
| */ |
| void setName(const char* name); |
| /** |
| * Set the owner name of the codec. |
| * |
| * This "owner name" is the name of the `IOmx` instance that supports this |
| * codec. |
| * |
| * @param owner The new owner name. |
| */ |
| void setOwner(const char* owner); |
| /** |
| * Set whether this codec is an encoder or a decoder. |
| * |
| * @param isEncoder Whether this codec is an encoder or a decoder. |
| */ |
| void setEncoder(bool isEncoder = true); |
| /** |
| * Add a mime to an indexed list and return a `CapabilitiesWriter` object |
| * that can be used for modifying the associated `Capabilities`. |
| * |
| * If the mime already exists, this function will return the |
| * `CapabilitiesWriter` associated with the mime. |
| * |
| * @param[in] mime The name of a new mime to add. |
| * @return writer The `CapabilitiesWriter` object for modifying the |
| * `Capabilities` associated with the mime. `writer` will be valid |
| * regardless of whether `mime` already exists or not. |
| */ |
| std::unique_ptr<MediaCodecInfo::CapabilitiesWriter> addMime( |
| const char* mime); |
| /** |
| * Remove a mime. |
| * |
| * @param mime The name of the mime to remove. |
| * @return `true` if `mime` is removed; `false` if `mime` is not found. |
| */ |
| bool removeMime(const char* mime); |
| /** |
| * Set rank of the codec. MediaCodecList will stable-sort the list according |
| * to rank in non-descending order. |
| * |
| * @param rank The rank of the component. |
| */ |
| void setRank(uint32_t rank); |
| private: |
| /** |
| * The associated `MediaCodecInfo`. |
| */ |
| MediaCodecInfo* mInfo; |
| /** |
| * Construct the `MediaCodecInfoWriter` object associated with the given |
| * `MediaCodecInfo` object. |
| * |
| * @param info The underlying `MediaCodecInfo` object. |
| */ |
| MediaCodecInfoWriter(MediaCodecInfo* info); |
| |
| DISALLOW_COPY_AND_ASSIGN(MediaCodecInfoWriter); |
| |
| friend struct MediaCodecListWriter; |
| }; |
| |
| } // namespace android |
| |
| #endif // MEDIA_CODEC_INFO_H_ |
| |
| |