headers/media_plugin/media/hardware/VideoAPI.h - LeafOS-Project/android_frameworks_native - Gitiles

 /*
  * Copyright (C) 2016 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 VIDEO_API_H_

 #define VIDEO_API_H_

 namespace android {

 /**
  * Structure describing a media image (frame)
  * Currently only supporting YUV
  * @deprecated. Use MediaImage2 instead
  */
 struct MediaImage {
     enum Type {
         MEDIA_IMAGE_TYPE_UNKNOWN = 0,
         MEDIA_IMAGE_TYPE_YUV,
     };

     enum PlaneIndex {
         Y = 0,
         U,
         V,
         MAX_NUM_PLANES
     };

     Type mType;
     uint32_t mNumPlanes;              // number of planes
     uint32_t mWidth;                  // width of largest plane (unpadded, as in nFrameWidth)
     uint32_t mHeight;                 // height of largest plane (unpadded, as in nFrameHeight)
     uint32_t mBitDepth;               // useable bit depth
     struct PlaneInfo {
         uint32_t mOffset;             // offset of first pixel of the plane in bytes
                                       // from buffer offset
         uint32_t mColInc;             // column increment in bytes
         uint32_t mRowInc;             // row increment in bytes
         uint32_t mHorizSubsampling;   // subsampling compared to the largest plane
         uint32_t mVertSubsampling;    // subsampling compared to the largest plane
     };
     PlaneInfo mPlane[MAX_NUM_PLANES];
 };

 /**
  * Structure describing a media image (frame)
  */
 struct __attribute__ ((__packed__)) MediaImage2 {
     enum Type : uint32_t {
         MEDIA_IMAGE_TYPE_UNKNOWN = 0,
         MEDIA_IMAGE_TYPE_YUV,
         MEDIA_IMAGE_TYPE_YUVA,
         MEDIA_IMAGE_TYPE_RGB,
         MEDIA_IMAGE_TYPE_RGBA,
         MEDIA_IMAGE_TYPE_Y,
     };

     enum PlaneIndex : uint32_t {
         Y = 0,
         U = 1,
         V = 2,
         R = 0,
         G = 1,
         B = 2,
         A = 3,
         MAX_NUM_PLANES = 4,
     };

     Type mType;
     uint32_t mNumPlanes;              // number of planes
     uint32_t mWidth;                  // width of largest plane (unpadded, as in nFrameWidth)
     uint32_t mHeight;                 // height of largest plane (unpadded, as in nFrameHeight)
     uint32_t mBitDepth;               // useable bit depth (always MSB)
     uint32_t mBitDepthAllocated;      // bits per component (must be 8 or 16)

     struct __attribute__ ((__packed__)) PlaneInfo {
         uint32_t mOffset;             // offset of first pixel of the plane in bytes
                                       // from buffer offset
         int32_t mColInc;              // column increment in bytes
         int32_t mRowInc;              // row increment in bytes
         uint32_t mHorizSubsampling;   // subsampling compared to the largest plane
         uint32_t mVertSubsampling;    // subsampling compared to the largest plane
     };
     PlaneInfo mPlane[MAX_NUM_PLANES];

     void initFromV1(const MediaImage&); // for internal use only
 };

 static_assert(sizeof(MediaImage2::PlaneInfo) == 20, "wrong struct size");
 static_assert(sizeof(MediaImage2) == 104, "wrong struct size");

 /**
  * Aspects of color.
  */

 // NOTE: this structure is expected to grow in the future if new color aspects are
 // added to codec bitstreams. OMX component should not require a specific nSize
 // though could verify that nSize is at least the size of the structure at the
 // time of implementation. All new fields will be added at the end of the structure
 // ensuring backward compatibility.
 struct __attribute__ ((__packed__, aligned(alignof(uint32_t)))) ColorAspects {
     // this is in sync with the range values in graphics.h
     enum Range : uint32_t {
         RangeUnspecified,
         RangeFull,
         RangeLimited,
         RangeOther = 0xff,
     };

     enum Primaries : uint32_t {
         PrimariesUnspecified,
         PrimariesBT709_5,       // Rec.ITU-R BT.709-5 or equivalent
         PrimariesBT470_6M,      // Rec.ITU-R BT.470-6 System M or equivalent
         PrimariesBT601_6_625,   // Rec.ITU-R BT.601-6 625 or equivalent
         PrimariesBT601_6_525,   // Rec.ITU-R BT.601-6 525 or equivalent
         PrimariesGenericFilm,   // Generic Film
         PrimariesBT2020,        // Rec.ITU-R BT.2020 or equivalent
         PrimariesRP431,         // SMPTE RP 431-2 (DCI P3)
         PrimariesEG432,         // SMPTE EG 432-1 (Display P3)
         PrimariesOther = 0xff,
     };

     // this partially in sync with the transfer values in graphics.h prior to the transfers
     // unlikely to be required by Android section
     enum Transfer : uint32_t {
         TransferUnspecified,
         TransferLinear,         // Linear transfer characteristics
         TransferSRGB,           // sRGB or equivalent
         TransferSMPTE170M,      // SMPTE 170M or equivalent (e.g. BT.601/709/2020)
         TransferGamma22,        // Assumed display gamma 2.2
         TransferGamma28,        // Assumed display gamma 2.8
         TransferST2084,         // SMPTE ST 2084 for 10/12/14/16 bit systems
         TransferHLG,            // ARIB STD-B67 hybrid-log-gamma

         // transfers unlikely to be required by Android
         TransferSMPTE240M = 0x40, // SMPTE 240M
         TransferXvYCC,          // IEC 61966-2-4
         TransferBT1361,         // Rec.ITU-R BT.1361 extended gamut
         TransferST428,          // SMPTE ST 428-1
         TransferOther = 0xff,
     };

     enum MatrixCoeffs : uint32_t {
         MatrixUnspecified,
         MatrixBT709_5,          // Rec.ITU-R BT.709-5 or equivalent
         MatrixBT470_6M,         // KR=0.30, KB=0.11 or equivalent
         MatrixBT601_6,          // Rec.ITU-R BT.601-6 625 or equivalent
         MatrixSMPTE240M,        // SMPTE 240M or equivalent
         MatrixBT2020,           // Rec.ITU-R BT.2020 non-constant luminance
         MatrixBT2020Constant,   // Rec.ITU-R BT.2020 constant luminance
         MatrixOther = 0xff,
     };

     // this is in sync with the standard values in graphics.h
     enum Standard : uint32_t {
         StandardUnspecified,
         StandardBT709,                  // PrimariesBT709_5 and MatrixBT709_5
         StandardBT601_625,              // PrimariesBT601_6_625 and MatrixBT601_6
         StandardBT601_625_Unadjusted,   // PrimariesBT601_6_625 and KR=0.222, KB=0.071
         StandardBT601_525,              // PrimariesBT601_6_525 and MatrixBT601_6
         StandardBT601_525_Unadjusted,   // PrimariesBT601_6_525 and MatrixSMPTE240M
         StandardBT2020,                 // PrimariesBT2020 and MatrixBT2020
         StandardBT2020Constant,         // PrimariesBT2020 and MatrixBT2020Constant
         StandardBT470M,                 // PrimariesBT470_6M and MatrixBT470_6M
         StandardFilm,                   // PrimariesGenericFilm and KR=0.253, KB=0.068
         StandardDisplayP3,              // PrimariesEG432 and MatrixBT601_6
         // StandardAdobeRGB,  // for placeholder only (not used by media)
         StandardOther = 0xff,
     };

     Range mRange;                // IN/OUT
     Primaries mPrimaries;        // IN/OUT
     Transfer mTransfer;          // IN/OUT
     MatrixCoeffs mMatrixCoeffs;  // IN/OUT
 };

 static_assert(sizeof(ColorAspects) == 16, "wrong struct size");

 /**
  * HDR Metadata.
  */

 // HDR Static Metadata Descriptor as defined by CTA-861-3.
 struct __attribute__ ((__packed__)) HDRStaticInfo {
     // Static_Metadata_Descriptor_ID
     enum ID : uint8_t {
         kType1 = 0, // Static Metadata Type 1
     } mID;

     struct __attribute__ ((__packed__)) Primaries1 {
         // values are in units of 0.00002
         uint16_t x;
         uint16_t y;
     };

     // Static Metadata Descriptor Type 1
     struct __attribute__ ((__packed__)) Type1 {
         Primaries1 mR; // display primary 0
         Primaries1 mG; // display primary 1
         Primaries1 mB; // display primary 2
         Primaries1 mW; // white point
         uint16_t mMaxDisplayLuminance; // in cd/m^2
         uint16_t mMinDisplayLuminance; // in 0.0001 cd/m^2
         uint16_t mMaxContentLightLevel; // in cd/m^2
         uint16_t mMaxFrameAverageLightLevel; // in cd/m^2
     };

     union {
          Type1 sType1;
     };
 };

 static_assert(sizeof(HDRStaticInfo::Primaries1) == 4, "wrong struct size");
 static_assert(sizeof(HDRStaticInfo::Type1) == 24, "wrong struct size");
 static_assert(sizeof(HDRStaticInfo) == 25, "wrong struct size");

 #ifdef STRINGIFY_ENUMS

 inline static const char *asString(MediaImage::Type i, const char *def = "??") {
     switch (i) {
         case MediaImage::MEDIA_IMAGE_TYPE_UNKNOWN: return "Unknown";
         case MediaImage::MEDIA_IMAGE_TYPE_YUV:     return "YUV";
         default:                                   return def;
     }
 }

 inline static const char *asString(MediaImage::PlaneIndex i, const char *def = "??") {
     switch (i) {
         case MediaImage::Y: return "Y";
         case MediaImage::U: return "U";
         case MediaImage::V: return "V";
         default:            return def;
     }
 }

 inline static const char *asString(MediaImage2::Type i, const char *def = "??") {
     switch (i) {
         case MediaImage2::MEDIA_IMAGE_TYPE_UNKNOWN: return "Unknown";
         case MediaImage2::MEDIA_IMAGE_TYPE_YUV:     return "YUV";
         case MediaImage2::MEDIA_IMAGE_TYPE_YUVA:    return "YUVA";
         case MediaImage2::MEDIA_IMAGE_TYPE_RGB:     return "RGB";
         case MediaImage2::MEDIA_IMAGE_TYPE_RGBA:    return "RGBA";
         case MediaImage2::MEDIA_IMAGE_TYPE_Y:       return "Y";
         default:                                    return def;
     }
 }

 inline static char asChar2(
         MediaImage2::PlaneIndex i, MediaImage2::Type j, char def = '?') {
     const char *planes = asString(j, NULL);
     // handle unknown values
     if (j == MediaImage2::MEDIA_IMAGE_TYPE_UNKNOWN || planes == NULL || i >= strlen(planes)) {
         return def;
     }
     return planes[i];
 }

 inline static const char *asString(ColorAspects::Range i, const char *def = "??") {
     switch (i) {
         case ColorAspects::RangeUnspecified: return "Unspecified";
         case ColorAspects::RangeFull:        return "Full";
         case ColorAspects::RangeLimited:     return "Limited";
         case ColorAspects::RangeOther:       return "Other";
         default:                             return def;
     }
 }

 inline static const char *asString(ColorAspects::Primaries i, const char *def = "??") {
     switch (i) {
         case ColorAspects::PrimariesUnspecified: return "Unspecified";
         case ColorAspects::PrimariesBT709_5:     return "BT709_5";
         case ColorAspects::PrimariesBT470_6M:    return "BT470_6M";
         case ColorAspects::PrimariesBT601_6_625: return "BT601_6_625";
         case ColorAspects::PrimariesBT601_6_525: return "BT601_6_525";
         case ColorAspects::PrimariesGenericFilm: return "GenericFilm";
         case ColorAspects::PrimariesBT2020:      return "BT2020";
         case ColorAspects::PrimariesRP431:       return "RP431";
         case ColorAspects::PrimariesEG432:       return "EG432";
         case ColorAspects::PrimariesOther:       return "Other";
         default:                                 return def;
     }
 }

 inline static const char *asString(ColorAspects::Transfer i, const char *def = "??") {
     switch (i) {
         case ColorAspects::TransferUnspecified: return "Unspecified";
         case ColorAspects::TransferLinear:      return "Linear";
         case ColorAspects::TransferSRGB:        return "SRGB";
         case ColorAspects::TransferSMPTE170M:   return "SMPTE170M";
         case ColorAspects::TransferGamma22:     return "Gamma22";
         case ColorAspects::TransferGamma28:     return "Gamma28";
         case ColorAspects::TransferST2084:      return "ST2084";
         case ColorAspects::TransferHLG:         return "HLG";
         case ColorAspects::TransferSMPTE240M:   return "SMPTE240M";
         case ColorAspects::TransferXvYCC:       return "XvYCC";
         case ColorAspects::TransferBT1361:      return "BT1361";
         case ColorAspects::TransferST428:       return "ST428";
         case ColorAspects::TransferOther:       return "Other";
         default:                                return def;
     }
 }

 inline static const char *asString(ColorAspects::MatrixCoeffs i, const char *def = "??") {
     switch (i) {
         case ColorAspects::MatrixUnspecified:    return "Unspecified";
         case ColorAspects::MatrixBT709_5:        return "BT709_5";
         case ColorAspects::MatrixBT470_6M:       return "BT470_6M";
         case ColorAspects::MatrixBT601_6:        return "BT601_6";
         case ColorAspects::MatrixSMPTE240M:      return "SMPTE240M";
         case ColorAspects::MatrixBT2020:         return "BT2020";
         case ColorAspects::MatrixBT2020Constant: return "BT2020Constant";
         case ColorAspects::MatrixOther:          return "Other";
         default:                                 return def;
     }
 }

 inline static const char *asString(ColorAspects::Standard i, const char *def = "??") {
     switch (i) {
         case ColorAspects::StandardUnspecified:          return "Unspecified";
         case ColorAspects::StandardBT709:                return "BT709";
         case ColorAspects::StandardBT601_625:            return "BT601_625";
         case ColorAspects::StandardBT601_625_Unadjusted: return "BT601_625_Unadjusted";
         case ColorAspects::StandardBT601_525:            return "BT601_525";
         case ColorAspects::StandardBT601_525_Unadjusted: return "BT601_525_Unadjusted";
         case ColorAspects::StandardBT2020:               return "BT2020";
         case ColorAspects::StandardBT2020Constant:       return "BT2020Constant";
         case ColorAspects::StandardBT470M:               return "BT470M";
         case ColorAspects::StandardFilm:                 return "Film";
         case ColorAspects::StandardDisplayP3:            return "DisplayP3";
         // case ColorAspects::StandardAdobeRGB:             return "AdobeRGB";
         case ColorAspects::StandardOther:                return "Other";
         default:                                         return def;
     }
 }

 #endif

 }  // namespace android

 #endif  // VIDEO_API_H_
	/*
	* Copyright (C) 2016 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 VIDEO_API_H_

	#define VIDEO_API_H_

	namespace android {

	/**
	* Structure describing a media image (frame)
	* Currently only supporting YUV
	* @deprecated. Use MediaImage2 instead
	*/
	struct MediaImage {
	enum Type {
	MEDIA_IMAGE_TYPE_UNKNOWN = 0,
	MEDIA_IMAGE_TYPE_YUV,
	};

	enum PlaneIndex {
	Y = 0,
	U,
	V,
	MAX_NUM_PLANES
	};

	Type mType;
	uint32_t mNumPlanes; // number of planes
	uint32_t mWidth; // width of largest plane (unpadded, as in nFrameWidth)
	uint32_t mHeight; // height of largest plane (unpadded, as in nFrameHeight)
	uint32_t mBitDepth; // useable bit depth
	struct PlaneInfo {
	uint32_t mOffset; // offset of first pixel of the plane in bytes
	// from buffer offset
	uint32_t mColInc; // column increment in bytes
	uint32_t mRowInc; // row increment in bytes
	uint32_t mHorizSubsampling; // subsampling compared to the largest plane
	uint32_t mVertSubsampling; // subsampling compared to the largest plane
	};
	PlaneInfo mPlane[MAX_NUM_PLANES];
	};

	/**
	* Structure describing a media image (frame)
	*/
	struct __attribute__ ((__packed__)) MediaImage2 {
	enum Type : uint32_t {
	MEDIA_IMAGE_TYPE_UNKNOWN = 0,
	MEDIA_IMAGE_TYPE_YUV,
	MEDIA_IMAGE_TYPE_YUVA,
	MEDIA_IMAGE_TYPE_RGB,
	MEDIA_IMAGE_TYPE_RGBA,
	MEDIA_IMAGE_TYPE_Y,
	};

	enum PlaneIndex : uint32_t {
	Y = 0,
	U = 1,
	V = 2,
	R = 0,
	G = 1,
	B = 2,
	A = 3,
	MAX_NUM_PLANES = 4,
	};

	Type mType;
	uint32_t mNumPlanes; // number of planes
	uint32_t mWidth; // width of largest plane (unpadded, as in nFrameWidth)
	uint32_t mHeight; // height of largest plane (unpadded, as in nFrameHeight)
	uint32_t mBitDepth; // useable bit depth (always MSB)
	uint32_t mBitDepthAllocated; // bits per component (must be 8 or 16)

	struct __attribute__ ((__packed__)) PlaneInfo {
	uint32_t mOffset; // offset of first pixel of the plane in bytes
	// from buffer offset
	int32_t mColInc; // column increment in bytes
	int32_t mRowInc; // row increment in bytes
	uint32_t mHorizSubsampling; // subsampling compared to the largest plane
	uint32_t mVertSubsampling; // subsampling compared to the largest plane
	};
	PlaneInfo mPlane[MAX_NUM_PLANES];

	void initFromV1(const MediaImage&); // for internal use only
	};

	static_assert(sizeof(MediaImage2::PlaneInfo) == 20, "wrong struct size");
	static_assert(sizeof(MediaImage2) == 104, "wrong struct size");

	/**
	* Aspects of color.
	*/

	// NOTE: this structure is expected to grow in the future if new color aspects are
	// added to codec bitstreams. OMX component should not require a specific nSize
	// though could verify that nSize is at least the size of the structure at the
	// time of implementation. All new fields will be added at the end of the structure
	// ensuring backward compatibility.
	struct __attribute__ ((__packed__, aligned(alignof(uint32_t)))) ColorAspects {
	// this is in sync with the range values in graphics.h
	enum Range : uint32_t {
	RangeUnspecified,
	RangeFull,
	RangeLimited,
	RangeOther = 0xff,
	};

	enum Primaries : uint32_t {
	PrimariesUnspecified,
	PrimariesBT709_5, // Rec.ITU-R BT.709-5 or equivalent
	PrimariesBT470_6M, // Rec.ITU-R BT.470-6 System M or equivalent
	PrimariesBT601_6_625, // Rec.ITU-R BT.601-6 625 or equivalent
	PrimariesBT601_6_525, // Rec.ITU-R BT.601-6 525 or equivalent
	PrimariesGenericFilm, // Generic Film
	PrimariesBT2020, // Rec.ITU-R BT.2020 or equivalent
	PrimariesRP431, // SMPTE RP 431-2 (DCI P3)
	PrimariesEG432, // SMPTE EG 432-1 (Display P3)
	PrimariesOther = 0xff,
	};

	// this partially in sync with the transfer values in graphics.h prior to the transfers
	// unlikely to be required by Android section
	enum Transfer : uint32_t {
	TransferUnspecified,
	TransferLinear, // Linear transfer characteristics
	TransferSRGB, // sRGB or equivalent
	TransferSMPTE170M, // SMPTE 170M or equivalent (e.g. BT.601/709/2020)
	TransferGamma22, // Assumed display gamma 2.2
	TransferGamma28, // Assumed display gamma 2.8
	TransferST2084, // SMPTE ST 2084 for 10/12/14/16 bit systems
	TransferHLG, // ARIB STD-B67 hybrid-log-gamma

	// transfers unlikely to be required by Android
	TransferSMPTE240M = 0x40, // SMPTE 240M
	TransferXvYCC, // IEC 61966-2-4
	TransferBT1361, // Rec.ITU-R BT.1361 extended gamut
	TransferST428, // SMPTE ST 428-1
	TransferOther = 0xff,
	};

	enum MatrixCoeffs : uint32_t {
	MatrixUnspecified,
	MatrixBT709_5, // Rec.ITU-R BT.709-5 or equivalent
	MatrixBT470_6M, // KR=0.30, KB=0.11 or equivalent
	MatrixBT601_6, // Rec.ITU-R BT.601-6 625 or equivalent
	MatrixSMPTE240M, // SMPTE 240M or equivalent
	MatrixBT2020, // Rec.ITU-R BT.2020 non-constant luminance
	MatrixBT2020Constant, // Rec.ITU-R BT.2020 constant luminance
	MatrixOther = 0xff,
	};

	// this is in sync with the standard values in graphics.h
	enum Standard : uint32_t {
	StandardUnspecified,
	StandardBT709, // PrimariesBT709_5 and MatrixBT709_5
	StandardBT601_625, // PrimariesBT601_6_625 and MatrixBT601_6
	StandardBT601_625_Unadjusted, // PrimariesBT601_6_625 and KR=0.222, KB=0.071
	StandardBT601_525, // PrimariesBT601_6_525 and MatrixBT601_6
	StandardBT601_525_Unadjusted, // PrimariesBT601_6_525 and MatrixSMPTE240M
	StandardBT2020, // PrimariesBT2020 and MatrixBT2020
	StandardBT2020Constant, // PrimariesBT2020 and MatrixBT2020Constant
	StandardBT470M, // PrimariesBT470_6M and MatrixBT470_6M
	StandardFilm, // PrimariesGenericFilm and KR=0.253, KB=0.068
	StandardDisplayP3, // PrimariesEG432 and MatrixBT601_6
	// StandardAdobeRGB, // for placeholder only (not used by media)
	StandardOther = 0xff,
	};

	Range mRange; // IN/OUT
	Primaries mPrimaries; // IN/OUT
	Transfer mTransfer; // IN/OUT
	MatrixCoeffs mMatrixCoeffs; // IN/OUT
	};

	static_assert(sizeof(ColorAspects) == 16, "wrong struct size");

	/**
	* HDR Metadata.
	*/

	// HDR Static Metadata Descriptor as defined by CTA-861-3.
	struct __attribute__ ((__packed__)) HDRStaticInfo {
	// Static_Metadata_Descriptor_ID
	enum ID : uint8_t {
	kType1 = 0, // Static Metadata Type 1
	} mID;

	struct __attribute__ ((__packed__)) Primaries1 {
	// values are in units of 0.00002
	uint16_t x;
	uint16_t y;
	};

	// Static Metadata Descriptor Type 1
	struct __attribute__ ((__packed__)) Type1 {
	Primaries1 mR; // display primary 0
	Primaries1 mG; // display primary 1
	Primaries1 mB; // display primary 2
	Primaries1 mW; // white point
	uint16_t mMaxDisplayLuminance; // in cd/m^2
	uint16_t mMinDisplayLuminance; // in 0.0001 cd/m^2
	uint16_t mMaxContentLightLevel; // in cd/m^2
	uint16_t mMaxFrameAverageLightLevel; // in cd/m^2
	};

	union {
	Type1 sType1;
	};
	};

	static_assert(sizeof(HDRStaticInfo::Primaries1) == 4, "wrong struct size");
	static_assert(sizeof(HDRStaticInfo::Type1) == 24, "wrong struct size");
	static_assert(sizeof(HDRStaticInfo) == 25, "wrong struct size");

	#ifdef STRINGIFY_ENUMS

	inline static const char asString(MediaImage::Type i, const char def = "??") {
	switch (i) {
	case MediaImage::MEDIA_IMAGE_TYPE_UNKNOWN: return "Unknown";
	case MediaImage::MEDIA_IMAGE_TYPE_YUV: return "YUV";
	default: return def;
	}
	}

	inline static const char asString(MediaImage::PlaneIndex i, const char def = "??") {
	switch (i) {
	case MediaImage::Y: return "Y";
	case MediaImage::U: return "U";
	case MediaImage::V: return "V";
	default: return def;
	}
	}

	inline static const char asString(MediaImage2::Type i, const char def = "??") {
	switch (i) {
	case MediaImage2::MEDIA_IMAGE_TYPE_UNKNOWN: return "Unknown";
	case MediaImage2::MEDIA_IMAGE_TYPE_YUV: return "YUV";
	case MediaImage2::MEDIA_IMAGE_TYPE_YUVA: return "YUVA";
	case MediaImage2::MEDIA_IMAGE_TYPE_RGB: return "RGB";
	case MediaImage2::MEDIA_IMAGE_TYPE_RGBA: return "RGBA";
	case MediaImage2::MEDIA_IMAGE_TYPE_Y: return "Y";
	default: return def;
	}
	}

	inline static char asChar2(
	MediaImage2::PlaneIndex i, MediaImage2::Type j, char def = '?') {
	const char *planes = asString(j, NULL);
	// handle unknown values
	if (j == MediaImage2::MEDIA_IMAGE_TYPE_UNKNOWN \|\| planes == NULL \|\| i >= strlen(planes)) {
	return def;
	}
	return planes[i];
	}

	inline static const char asString(ColorAspects::Range i, const char def = "??") {
	switch (i) {
	case ColorAspects::RangeUnspecified: return "Unspecified";
	case ColorAspects::RangeFull: return "Full";
	case ColorAspects::RangeLimited: return "Limited";
	case ColorAspects::RangeOther: return "Other";
	default: return def;
	}
	}

	inline static const char asString(ColorAspects::Primaries i, const char def = "??") {
	switch (i) {
	case ColorAspects::PrimariesUnspecified: return "Unspecified";
	case ColorAspects::PrimariesBT709_5: return "BT709_5";
	case ColorAspects::PrimariesBT470_6M: return "BT470_6M";
	case ColorAspects::PrimariesBT601_6_625: return "BT601_6_625";
	case ColorAspects::PrimariesBT601_6_525: return "BT601_6_525";
	case ColorAspects::PrimariesGenericFilm: return "GenericFilm";
	case ColorAspects::PrimariesBT2020: return "BT2020";
	case ColorAspects::PrimariesRP431: return "RP431";
	case ColorAspects::PrimariesEG432: return "EG432";
	case ColorAspects::PrimariesOther: return "Other";
	default: return def;
	}
	}

	inline static const char asString(ColorAspects::Transfer i, const char def = "??") {
	switch (i) {
	case ColorAspects::TransferUnspecified: return "Unspecified";
	case ColorAspects::TransferLinear: return "Linear";
	case ColorAspects::TransferSRGB: return "SRGB";
	case ColorAspects::TransferSMPTE170M: return "SMPTE170M";
	case ColorAspects::TransferGamma22: return "Gamma22";
	case ColorAspects::TransferGamma28: return "Gamma28";
	case ColorAspects::TransferST2084: return "ST2084";
	case ColorAspects::TransferHLG: return "HLG";
	case ColorAspects::TransferSMPTE240M: return "SMPTE240M";
	case ColorAspects::TransferXvYCC: return "XvYCC";
	case ColorAspects::TransferBT1361: return "BT1361";
	case ColorAspects::TransferST428: return "ST428";
	case ColorAspects::TransferOther: return "Other";
	default: return def;
	}
	}

	inline static const char asString(ColorAspects::MatrixCoeffs i, const char def = "??") {
	switch (i) {
	case ColorAspects::MatrixUnspecified: return "Unspecified";
	case ColorAspects::MatrixBT709_5: return "BT709_5";
	case ColorAspects::MatrixBT470_6M: return "BT470_6M";
	case ColorAspects::MatrixBT601_6: return "BT601_6";
	case ColorAspects::MatrixSMPTE240M: return "SMPTE240M";
	case ColorAspects::MatrixBT2020: return "BT2020";
	case ColorAspects::MatrixBT2020Constant: return "BT2020Constant";
	case ColorAspects::MatrixOther: return "Other";
	default: return def;
	}
	}

	inline static const char asString(ColorAspects::Standard i, const char def = "??") {
	switch (i) {
	case ColorAspects::StandardUnspecified: return "Unspecified";
	case ColorAspects::StandardBT709: return "BT709";
	case ColorAspects::StandardBT601_625: return "BT601_625";
	case ColorAspects::StandardBT601_625_Unadjusted: return "BT601_625_Unadjusted";
	case ColorAspects::StandardBT601_525: return "BT601_525";
	case ColorAspects::StandardBT601_525_Unadjusted: return "BT601_525_Unadjusted";
	case ColorAspects::StandardBT2020: return "BT2020";
	case ColorAspects::StandardBT2020Constant: return "BT2020Constant";
	case ColorAspects::StandardBT470M: return "BT470M";
	case ColorAspects::StandardFilm: return "Film";
	case ColorAspects::StandardDisplayP3: return "DisplayP3";
	// case ColorAspects::StandardAdobeRGB: return "AdobeRGB";
	case ColorAspects::StandardOther: return "Other";
	default: return def;
	}
	}

	#endif

	} // namespace android

	#endif // VIDEO_API_H_