| Lajos Molnar | a1ae5a4 | 2014-11-06 17:05:46 -0800 | [diff] [blame] | 1 | /* | 
 | 2 |  * Copyright 2014 The Android Open Source Project | 
 | 3 |  * | 
 | 4 |  * Licensed under the Apache License, Version 2.0 (the "License"); | 
 | 5 |  * you may not use this file except in compliance with the License. | 
 | 6 |  * You may obtain a copy of the License at | 
 | 7 |  * | 
 | 8 |  *      http://www.apache.org/licenses/LICENSE-2.0 | 
 | 9 |  * | 
 | 10 |  * Unless required by applicable law or agreed to in writing, software | 
 | 11 |  * distributed under the License is distributed on an "AS IS" BASIS, | 
 | 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | 
 | 13 |  * See the License for the specific language governing permissions and | 
 | 14 |  * limitations under the License. | 
 | 15 |  */ | 
 | 16 |  | 
 | 17 | /* NOTE: This file contains several sections for individual OMX include files. | 
 | 18 |    Each section has its own include guard.  This file should be included AFTER | 
 | 19 |    the OMX include files. */ | 
 | 20 |  | 
 | 21 | #ifdef OMX_Audio_h | 
 | 22 | /* asString definitions if media/openmax/OMX_Audio.h was included */ | 
 | 23 |  | 
 | 24 | #ifndef AS_STRING_FOR_OMX_AUDIO_H | 
 | 25 | #define AS_STRING_FOR_OMX_AUDIO_H | 
 | 26 |  | 
 | 27 | inline static const char *asString(OMX_AUDIO_CODINGTYPE i, const char *def = "??") { | 
 | 28 |     switch (i) { | 
 | 29 |         case OMX_AUDIO_CodingUnused:     return "Unused";      // unused | 
 | 30 |         case OMX_AUDIO_CodingAutoDetect: return "AutoDetect";  // unused | 
 | 31 |         case OMX_AUDIO_CodingPCM:        return "PCM"; | 
 | 32 |         case OMX_AUDIO_CodingADPCM:      return "ADPCM";       // unused | 
 | 33 |         case OMX_AUDIO_CodingAMR:        return "AMR"; | 
 | 34 |         case OMX_AUDIO_CodingGSMFR:      return "GSMFR"; | 
 | 35 |         case OMX_AUDIO_CodingGSMEFR:     return "GSMEFR";      // unused | 
 | 36 |         case OMX_AUDIO_CodingGSMHR:      return "GSMHR";       // unused | 
 | 37 |         case OMX_AUDIO_CodingPDCFR:      return "PDCFR";       // unused | 
 | 38 |         case OMX_AUDIO_CodingPDCEFR:     return "PDCEFR";      // unused | 
 | 39 |         case OMX_AUDIO_CodingPDCHR:      return "PDCHR";       // unused | 
 | 40 |         case OMX_AUDIO_CodingTDMAFR:     return "TDMAFR";      // unused | 
 | 41 |         case OMX_AUDIO_CodingTDMAEFR:    return "TDMAEFR";     // unused | 
 | 42 |         case OMX_AUDIO_CodingQCELP8:     return "QCELP8";      // unused | 
 | 43 |         case OMX_AUDIO_CodingQCELP13:    return "QCELP13";     // unused | 
 | 44 |         case OMX_AUDIO_CodingEVRC:       return "EVRC";        // unused | 
 | 45 |         case OMX_AUDIO_CodingSMV:        return "SMV";         // unused | 
 | 46 |         case OMX_AUDIO_CodingG711:       return "G711"; | 
 | 47 |         case OMX_AUDIO_CodingG723:       return "G723";        // unused | 
 | 48 |         case OMX_AUDIO_CodingG726:       return "G726";        // unused | 
 | 49 |         case OMX_AUDIO_CodingG729:       return "G729";        // unused | 
 | 50 |         case OMX_AUDIO_CodingAAC:        return "AAC"; | 
 | 51 |         case OMX_AUDIO_CodingMP3:        return "MP3"; | 
 | 52 |         case OMX_AUDIO_CodingSBC:        return "SBC";         // unused | 
 | 53 |         case OMX_AUDIO_CodingVORBIS:     return "VORBIS"; | 
 | 54 |         case OMX_AUDIO_CodingWMA:        return "WMA";         // unused | 
 | 55 |         case OMX_AUDIO_CodingRA:         return "RA";          // unused | 
 | 56 |         case OMX_AUDIO_CodingMIDI:       return "MIDI";        // unused | 
 | 57 |         case OMX_AUDIO_CodingFLAC:       return "FLAC"; | 
 | 58 |         default:                         return def; | 
 | 59 |     } | 
 | 60 | } | 
 | 61 |  | 
 | 62 | inline static const char *asString(OMX_AUDIO_PCMMODETYPE i, const char *def = "??") { | 
 | 63 |     switch (i) { | 
 | 64 |         case OMX_AUDIO_PCMModeLinear: return "Linear"; | 
 | 65 |         case OMX_AUDIO_PCMModeALaw:   return "ALaw"; | 
 | 66 |         case OMX_AUDIO_PCMModeMULaw:  return "MULaw"; | 
 | 67 |         default:                      return def; | 
 | 68 |     } | 
 | 69 | } | 
 | 70 |  | 
 | 71 | inline static const char *asString(OMX_AUDIO_CHANNELTYPE i, const char *def = "??") { | 
 | 72 |     switch (i) { | 
 | 73 |         case OMX_AUDIO_ChannelNone: return "None";  // unused | 
 | 74 |         case OMX_AUDIO_ChannelLF:   return "LF"; | 
 | 75 |         case OMX_AUDIO_ChannelRF:   return "RF"; | 
 | 76 |         case OMX_AUDIO_ChannelCF:   return "CF"; | 
 | 77 |         case OMX_AUDIO_ChannelLS:   return "LS"; | 
 | 78 |         case OMX_AUDIO_ChannelRS:   return "RS"; | 
 | 79 |         case OMX_AUDIO_ChannelLFE:  return "LFE"; | 
 | 80 |         case OMX_AUDIO_ChannelCS:   return "CS"; | 
 | 81 |         case OMX_AUDIO_ChannelLR:   return "LR"; | 
 | 82 |         case OMX_AUDIO_ChannelRR:   return "RR"; | 
 | 83 |         default:                    return def; | 
 | 84 |     } | 
 | 85 | } | 
 | 86 |  | 
 | 87 | inline static const char *asString(OMX_AUDIO_CHANNELMODETYPE i, const char *def = "??") { | 
 | 88 |     switch (i) { | 
 | 89 |         case OMX_AUDIO_ChannelModeStereo:      return "Stereo"; | 
 | 90 | //      case OMX_AUDIO_ChannelModeJointStereo: return "JointStereo"; | 
 | 91 | //      case OMX_AUDIO_ChannelModeDual:        return "Dual"; | 
 | 92 |         case OMX_AUDIO_ChannelModeMono:        return "Mono"; | 
 | 93 |         default:                               return def; | 
 | 94 |     } | 
 | 95 | } | 
 | 96 |  | 
 | 97 | inline static const char *asString(OMX_AUDIO_AACSTREAMFORMATTYPE i, const char *def = "??") { | 
 | 98 |     switch (i) { | 
 | 99 | //      case OMX_AUDIO_AACStreamFormatMP2ADTS: return "MP2ADTS"; | 
 | 100 |         case OMX_AUDIO_AACStreamFormatMP4ADTS: return "MP4ADTS"; | 
 | 101 | //      case OMX_AUDIO_AACStreamFormatMP4LOAS: return "MP4LOAS"; | 
 | 102 | //      case OMX_AUDIO_AACStreamFormatMP4LATM: return "MP4LATM"; | 
 | 103 | //      case OMX_AUDIO_AACStreamFormatADIF:    return "ADIF"; | 
 | 104 |         case OMX_AUDIO_AACStreamFormatMP4FF:   return "MP4FF"; | 
 | 105 | //      case OMX_AUDIO_AACStreamFormatRAW:     return "RAW"; | 
 | 106 |         default:                               return def; | 
 | 107 |     } | 
 | 108 | } | 
 | 109 |  | 
 | 110 | inline static const char *asString(OMX_AUDIO_AMRFRAMEFORMATTYPE i, const char *def = "??") { | 
 | 111 |     switch (i) { | 
 | 112 | //      case OMX_AUDIO_AMRFrameFormatConformance: return "Conformance"; | 
 | 113 | //      case OMX_AUDIO_AMRFrameFormatIF1:         return "IF1"; | 
 | 114 | //      case OMX_AUDIO_AMRFrameFormatIF2:         return "IF2"; | 
 | 115 |         case OMX_AUDIO_AMRFrameFormatFSF:         return "FSF"; | 
 | 116 | //      case OMX_AUDIO_AMRFrameFormatRTPPayload:  return "RTPPayload"; | 
 | 117 | //      case OMX_AUDIO_AMRFrameFormatITU:         return "ITU"; | 
 | 118 |         default:                                  return def; | 
 | 119 |     } | 
 | 120 | } | 
 | 121 |  | 
 | 122 | inline static const char *asString(OMX_AUDIO_AMRBANDMODETYPE i, const char *def = "??") { | 
 | 123 |     switch (i) { | 
 | 124 |         case OMX_AUDIO_AMRBandModeUnused: return "Unused"; | 
 | 125 |         case OMX_AUDIO_AMRBandModeNB0:    return "NB0"; | 
 | 126 |         case OMX_AUDIO_AMRBandModeNB1:    return "NB1"; | 
 | 127 |         case OMX_AUDIO_AMRBandModeNB2:    return "NB2"; | 
 | 128 |         case OMX_AUDIO_AMRBandModeNB3:    return "NB3"; | 
 | 129 |         case OMX_AUDIO_AMRBandModeNB4:    return "NB4"; | 
 | 130 |         case OMX_AUDIO_AMRBandModeNB5:    return "NB5"; | 
 | 131 |         case OMX_AUDIO_AMRBandModeNB6:    return "NB6"; | 
 | 132 |         case OMX_AUDIO_AMRBandModeNB7:    return "NB7"; | 
 | 133 |         case OMX_AUDIO_AMRBandModeWB0:    return "WB0"; | 
 | 134 |         case OMX_AUDIO_AMRBandModeWB1:    return "WB1"; | 
 | 135 |         case OMX_AUDIO_AMRBandModeWB2:    return "WB2"; | 
 | 136 |         case OMX_AUDIO_AMRBandModeWB3:    return "WB3"; | 
 | 137 |         case OMX_AUDIO_AMRBandModeWB4:    return "WB4"; | 
 | 138 |         case OMX_AUDIO_AMRBandModeWB5:    return "WB5"; | 
 | 139 |         case OMX_AUDIO_AMRBandModeWB6:    return "WB6"; | 
 | 140 |         case OMX_AUDIO_AMRBandModeWB7:    return "WB7"; | 
 | 141 |         case OMX_AUDIO_AMRBandModeWB8:    return "WB8"; | 
 | 142 |         default:                          return def; | 
 | 143 |     } | 
 | 144 | } | 
 | 145 |  | 
 | 146 | inline static const char *asString(OMX_AUDIO_AMRDTXMODETYPE i, const char *def = "??") { | 
 | 147 |     switch (i) { | 
 | 148 |         case OMX_AUDIO_AMRDTXModeOff:    return "ModeOff"; | 
 | 149 | //      case OMX_AUDIO_AMRDTXModeOnVAD1: return "ModeOnVAD1"; | 
 | 150 | //      case OMX_AUDIO_AMRDTXModeOnVAD2: return "ModeOnVAD2"; | 
 | 151 | //      case OMX_AUDIO_AMRDTXModeOnAuto: return "ModeOnAuto"; | 
 | 152 | //      case OMX_AUDIO_AMRDTXasEFR:      return "asEFR"; | 
 | 153 |         default:                         return def; | 
 | 154 |     } | 
 | 155 | } | 
 | 156 |  | 
 | 157 | #endif // AS_STRING_FOR_OMX_AUDIO_H | 
 | 158 |  | 
 | 159 | #endif // OMX_Audio_h | 
 | 160 |  | 
 | 161 | #ifdef OMX_AudioExt_h | 
 | 162 | /* asString definitions if media/openmax/OMX_AudioExt.h was included */ | 
 | 163 |  | 
 | 164 | #ifndef AS_STRING_FOR_OMX_AUDIOEXT_H | 
 | 165 | #define AS_STRING_FOR_OMX_AUDIOEXT_H | 
 | 166 |  | 
 | 167 | inline static const char *asString(OMX_AUDIO_CODINGEXTTYPE i, const char *def = "??") { | 
 | 168 |     switch (i) { | 
 | 169 |         case OMX_AUDIO_CodingAndroidAC3:  return "AndroidAC3"; | 
 | 170 |         case OMX_AUDIO_CodingAndroidOPUS: return "AndroidOPUS"; | 
 | 171 |         default:                          return asString((OMX_AUDIO_CODINGTYPE)i, def); | 
 | 172 |     } | 
 | 173 | } | 
 | 174 |  | 
 | 175 | #endif // AS_STRING_FOR_OMX_AUDIOEXT_H | 
 | 176 |  | 
 | 177 | #endif // OMX_AudioExt_h | 
 | 178 |  | 
 | 179 | #ifdef OMX_Component_h | 
 | 180 | /* asString definitions if media/openmax/OMX_Component.h was included */ | 
 | 181 |  | 
 | 182 | #ifndef AS_STRING_FOR_OMX_COMPONENT_H | 
 | 183 | #define AS_STRING_FOR_OMX_COMPONENT_H | 
 | 184 |  | 
 | 185 | inline static const char *asString(OMX_PORTDOMAINTYPE i, const char *def = "??") { | 
 | 186 |     switch (i) { | 
 | 187 |         case OMX_PortDomainAudio: return "Audio"; | 
 | 188 |         case OMX_PortDomainVideo: return "Video"; | 
 | 189 |         case OMX_PortDomainImage: return "Image"; | 
 | 190 | //      case OMX_PortDomainOther: return "Other"; | 
 | 191 |         default:                  return def; | 
 | 192 |     } | 
 | 193 | } | 
 | 194 |  | 
 | 195 | #endif // AS_STRING_FOR_OMX_COMPONENT_H | 
 | 196 |  | 
 | 197 | #endif // OMX_Component_h | 
 | 198 |  | 
 | 199 | #ifdef OMX_Core_h | 
 | 200 | /* asString definitions if media/openmax/OMX_Core.h was included */ | 
 | 201 |  | 
 | 202 | #ifndef AS_STRING_FOR_OMX_CORE_H | 
 | 203 | #define AS_STRING_FOR_OMX_CORE_H | 
 | 204 |  | 
 | 205 | inline static const char *asString(OMX_COMMANDTYPE i, const char *def = "??") { | 
 | 206 |     switch (i) { | 
 | 207 |         case OMX_CommandStateSet:    return "StateSet"; | 
 | 208 |         case OMX_CommandFlush:       return "Flush"; | 
 | 209 |         case OMX_CommandPortDisable: return "PortDisable"; | 
 | 210 |         case OMX_CommandPortEnable:  return "PortEnable"; | 
 | 211 | //      case OMX_CommandMarkBuffer:  return "MarkBuffer"; | 
 | 212 |         default:                     return def; | 
 | 213 |     } | 
 | 214 | } | 
 | 215 |  | 
 | 216 | inline static const char *asString(OMX_STATETYPE i, const char *def = "??") { | 
 | 217 |     switch (i) { | 
 | 218 |         case OMX_StateInvalid:          return "Invalid"; | 
 | 219 |         case OMX_StateLoaded:           return "Loaded"; | 
 | 220 |         case OMX_StateIdle:             return "Idle"; | 
 | 221 |         case OMX_StateExecuting:        return "Executing"; | 
 | 222 | //      case OMX_StatePause:            return "Pause"; | 
 | 223 | //      case OMX_StateWaitForResources: return "WaitForResources"; | 
 | 224 |         default:                        return def; | 
 | 225 |     } | 
 | 226 | } | 
 | 227 |  | 
 | 228 | inline static const char *asString(OMX_ERRORTYPE i, const char *def = "??") { | 
 | 229 |     switch (i) { | 
 | 230 |         case OMX_ErrorNone:                               return "None"; | 
 | 231 |         case OMX_ErrorInsufficientResources:              return "InsufficientResources"; | 
 | 232 |         case OMX_ErrorUndefined:                          return "Undefined"; | 
 | 233 |         case OMX_ErrorInvalidComponentName:               return "InvalidComponentName"; | 
 | 234 |         case OMX_ErrorComponentNotFound:                  return "ComponentNotFound"; | 
 | 235 |         case OMX_ErrorInvalidComponent:                   return "InvalidComponent";       // unused | 
 | 236 |         case OMX_ErrorBadParameter:                       return "BadParameter"; | 
 | 237 |         case OMX_ErrorNotImplemented:                     return "NotImplemented"; | 
 | 238 |         case OMX_ErrorUnderflow:                          return "Underflow";              // unused | 
 | 239 |         case OMX_ErrorOverflow:                           return "Overflow";               // unused | 
 | 240 |         case OMX_ErrorHardware:                           return "Hardware";               // unused | 
 | 241 |         case OMX_ErrorInvalidState:                       return "InvalidState"; | 
 | 242 |         case OMX_ErrorStreamCorrupt:                      return "StreamCorrupt"; | 
 | 243 |         case OMX_ErrorPortsNotCompatible:                 return "PortsNotCompatible";     // unused | 
 | 244 |         case OMX_ErrorResourcesLost:                      return "ResourcesLost"; | 
 | 245 |         case OMX_ErrorNoMore:                             return "NoMore"; | 
 | 246 |         case OMX_ErrorVersionMismatch:                    return "VersionMismatch";        // unused | 
 | 247 |         case OMX_ErrorNotReady:                           return "NotReady";               // unused | 
 | 248 |         case OMX_ErrorTimeout:                            return "Timeout";                // unused | 
 | 249 |         case OMX_ErrorSameState:                          return "SameState";              // unused | 
 | 250 |         case OMX_ErrorResourcesPreempted:                 return "ResourcesPreempted";     // unused | 
 | 251 |         case OMX_ErrorPortUnresponsiveDuringAllocation: | 
 | 252 |             return "PortUnresponsiveDuringAllocation";    // unused | 
 | 253 |         case OMX_ErrorPortUnresponsiveDuringDeallocation: | 
 | 254 |             return "PortUnresponsiveDuringDeallocation";  // unused | 
 | 255 |         case OMX_ErrorPortUnresponsiveDuringStop: | 
 | 256 |             return "PortUnresponsiveDuringStop";          // unused | 
 | 257 |         case OMX_ErrorIncorrectStateTransition: | 
 | 258 |             return "IncorrectStateTransition";            // unused | 
 | 259 |         case OMX_ErrorIncorrectStateOperation: | 
 | 260 |             return "IncorrectStateOperation";             // unused | 
 | 261 |         case OMX_ErrorUnsupportedSetting:                 return "UnsupportedSetting"; | 
 | 262 |         case OMX_ErrorUnsupportedIndex:                   return "UnsupportedIndex"; | 
 | 263 |         case OMX_ErrorBadPortIndex:                       return "BadPortIndex"; | 
 | 264 |         case OMX_ErrorPortUnpopulated:                    return "PortUnpopulated";        // unused | 
 | 265 |         case OMX_ErrorComponentSuspended:                 return "ComponentSuspended";     // unused | 
 | 266 |         case OMX_ErrorDynamicResourcesUnavailable: | 
 | 267 |             return "DynamicResourcesUnavailable";         // unused | 
 | 268 |         case OMX_ErrorMbErrorsInFrame:                    return "MbErrorsInFrame";        // unused | 
 | 269 |         case OMX_ErrorFormatNotDetected:                  return "FormatNotDetected";      // unused | 
 | 270 |         case OMX_ErrorContentPipeOpenFailed:              return "ContentPipeOpenFailed";  // unused | 
 | 271 |         case OMX_ErrorContentPipeCreationFailed: | 
 | 272 |             return "ContentPipeCreationFailed";           // unused | 
 | 273 |         case OMX_ErrorSeperateTablesUsed:                 return "SeperateTablesUsed";     // unused | 
 | 274 |         case OMX_ErrorTunnelingUnsupported:               return "TunnelingUnsupported";   // unused | 
 | 275 |         default:                                          return def; | 
 | 276 |     } | 
 | 277 | } | 
 | 278 |  | 
 | 279 | inline static const char *asString(OMX_EVENTTYPE i, const char *def = "??") { | 
 | 280 |     switch (i) { | 
 | 281 |         case OMX_EventCmdComplete:               return "CmdComplete"; | 
 | 282 |         case OMX_EventError:                     return "Error"; | 
 | 283 | //      case OMX_EventMark:                      return "Mark"; | 
 | 284 |         case OMX_EventPortSettingsChanged:       return "PortSettingsChanged"; | 
 | 285 |         case OMX_EventBufferFlag:                return "BufferFlag"; | 
 | 286 | //      case OMX_EventResourcesAcquired:         return "ResourcesAcquired"; | 
 | 287 | //      case OMX_EventComponentResumed:          return "ComponentResumed"; | 
 | 288 | //      case OMX_EventDynamicResourcesAvailable: return "DynamicResourcesAvailable"; | 
 | 289 | //      case OMX_EventPortFormatDetected:        return "PortFormatDetected"; | 
 | 290 |         default:                                 return def; | 
 | 291 |     } | 
 | 292 | } | 
 | 293 |  | 
 | 294 | #endif // AS_STRING_FOR_OMX_CORE_H | 
 | 295 |  | 
 | 296 | #endif // OMX_Core_h | 
 | 297 |  | 
 | 298 | #ifdef OMX_Image_h | 
 | 299 | /* asString definitions if media/openmax/OMX_Image.h was included */ | 
 | 300 |  | 
 | 301 | #ifndef AS_STRING_FOR_OMX_IMAGE_H | 
 | 302 | #define AS_STRING_FOR_OMX_IMAGE_H | 
 | 303 |  | 
 | 304 | inline static const char *asString(OMX_IMAGE_CODINGTYPE i, const char *def = "??") { | 
 | 305 |     switch (i) { | 
 | 306 |         case OMX_IMAGE_CodingUnused:     return "Unused"; | 
 | 307 |         case OMX_IMAGE_CodingAutoDetect: return "AutoDetect";  // unused | 
 | 308 |         case OMX_IMAGE_CodingJPEG:       return "JPEG"; | 
 | 309 |         case OMX_IMAGE_CodingJPEG2K:     return "JPEG2K";      // unused | 
 | 310 |         case OMX_IMAGE_CodingEXIF:       return "EXIF";        // unused | 
 | 311 |         case OMX_IMAGE_CodingTIFF:       return "TIFF";        // unused | 
 | 312 |         case OMX_IMAGE_CodingGIF:        return "GIF";         // unused | 
 | 313 |         case OMX_IMAGE_CodingPNG:        return "PNG";         // unused | 
 | 314 |         case OMX_IMAGE_CodingLZW:        return "LZW";         // unused | 
 | 315 |         case OMX_IMAGE_CodingBMP:        return "BMP";         // unused | 
 | 316 |         default:                         return def; | 
 | 317 |     } | 
 | 318 | } | 
 | 319 |  | 
 | 320 | #endif // AS_STRING_FOR_OMX_IMAGE_H | 
 | 321 |  | 
 | 322 | #endif // OMX_Image_h | 
 | 323 |  | 
 | 324 | #ifdef OMX_Index_h | 
 | 325 | /* asString definitions if media/openmax/OMX_Index.h was included */ | 
 | 326 |  | 
 | 327 | #ifndef AS_STRING_FOR_OMX_INDEX_H | 
 | 328 | #define AS_STRING_FOR_OMX_INDEX_H | 
 | 329 |  | 
 | 330 | inline static const char *asString(OMX_INDEXTYPE i, const char *def = "??") { | 
 | 331 |     switch (i) { | 
 | 332 | //      case OMX_IndexParamPriorityMgmt:                    return "ParamPriorityMgmt"; | 
 | 333 | //      case OMX_IndexParamAudioInit:                       return "ParamAudioInit"; | 
 | 334 | //      case OMX_IndexParamImageInit:                       return "ParamImageInit"; | 
 | 335 | //      case OMX_IndexParamVideoInit:                       return "ParamVideoInit"; | 
 | 336 | //      case OMX_IndexParamOtherInit:                       return "ParamOtherInit"; | 
 | 337 | //      case OMX_IndexParamNumAvailableStreams:             return "ParamNumAvailableStreams"; | 
 | 338 | //      case OMX_IndexParamActiveStream:                    return "ParamActiveStream"; | 
 | 339 | //      case OMX_IndexParamSuspensionPolicy:                return "ParamSuspensionPolicy"; | 
 | 340 | //      case OMX_IndexParamComponentSuspended:              return "ParamComponentSuspended"; | 
 | 341 | //      case OMX_IndexConfigCapturing:                      return "ConfigCapturing"; | 
 | 342 | //      case OMX_IndexConfigCaptureMode:                    return "ConfigCaptureMode"; | 
 | 343 | //      case OMX_IndexAutoPauseAfterCapture:                return "AutoPauseAfterCapture"; | 
 | 344 | //      case OMX_IndexParamContentURI:                      return "ParamContentURI"; | 
 | 345 | //      case OMX_IndexParamCustomContentPipe:               return "ParamCustomContentPipe"; | 
 | 346 | //      case OMX_IndexParamDisableResourceConcealment: | 
 | 347 | //          return "ParamDisableResourceConcealment"; | 
 | 348 | //      case OMX_IndexConfigMetadataItemCount:              return "ConfigMetadataItemCount"; | 
 | 349 | //      case OMX_IndexConfigContainerNodeCount:             return "ConfigContainerNodeCount"; | 
 | 350 | //      case OMX_IndexConfigMetadataItem:                   return "ConfigMetadataItem"; | 
 | 351 | //      case OMX_IndexConfigCounterNodeID:                  return "ConfigCounterNodeID"; | 
 | 352 | //      case OMX_IndexParamMetadataFilterType:              return "ParamMetadataFilterType"; | 
 | 353 | //      case OMX_IndexParamMetadataKeyFilter:               return "ParamMetadataKeyFilter"; | 
 | 354 | //      case OMX_IndexConfigPriorityMgmt:                   return "ConfigPriorityMgmt"; | 
 | 355 |         case OMX_IndexParamStandardComponentRole:           return "ParamStandardComponentRole"; | 
 | 356 |         case OMX_IndexParamPortDefinition:                  return "ParamPortDefinition"; | 
 | 357 | //      case OMX_IndexParamCompBufferSupplier:              return "ParamCompBufferSupplier"; | 
 | 358 |         case OMX_IndexParamAudioPortFormat:                 return "ParamAudioPortFormat"; | 
 | 359 |         case OMX_IndexParamAudioPcm:                        return "ParamAudioPcm"; | 
 | 360 |         case OMX_IndexParamAudioAac:                        return "ParamAudioAac"; | 
 | 361 | //      case OMX_IndexParamAudioRa:                         return "ParamAudioRa"; | 
 | 362 |         case OMX_IndexParamAudioMp3:                        return "ParamAudioMp3"; | 
 | 363 | //      case OMX_IndexParamAudioAdpcm:                      return "ParamAudioAdpcm"; | 
 | 364 | //      case OMX_IndexParamAudioG723:                       return "ParamAudioG723"; | 
 | 365 | //      case OMX_IndexParamAudioG729:                       return "ParamAudioG729"; | 
 | 366 |         case OMX_IndexParamAudioAmr:                        return "ParamAudioAmr"; | 
 | 367 | //      case OMX_IndexParamAudioWma:                        return "ParamAudioWma"; | 
 | 368 | //      case OMX_IndexParamAudioSbc:                        return "ParamAudioSbc"; | 
 | 369 | //      case OMX_IndexParamAudioMidi:                       return "ParamAudioMidi"; | 
 | 370 | //      case OMX_IndexParamAudioGsm_FR:                     return "ParamAudioGsm_FR"; | 
 | 371 | //      case OMX_IndexParamAudioMidiLoadUserSound:          return "ParamAudioMidiLoadUserSound"; | 
 | 372 | //      case OMX_IndexParamAudioG726:                       return "ParamAudioG726"; | 
 | 373 | //      case OMX_IndexParamAudioGsm_EFR:                    return "ParamAudioGsm_EFR"; | 
 | 374 | //      case OMX_IndexParamAudioGsm_HR:                     return "ParamAudioGsm_HR"; | 
 | 375 | //      case OMX_IndexParamAudioPdc_FR:                     return "ParamAudioPdc_FR"; | 
 | 376 | //      case OMX_IndexParamAudioPdc_EFR:                    return "ParamAudioPdc_EFR"; | 
 | 377 | //      case OMX_IndexParamAudioPdc_HR:                     return "ParamAudioPdc_HR"; | 
 | 378 | //      case OMX_IndexParamAudioTdma_FR:                    return "ParamAudioTdma_FR"; | 
 | 379 | //      case OMX_IndexParamAudioTdma_EFR:                   return "ParamAudioTdma_EFR"; | 
 | 380 | //      case OMX_IndexParamAudioQcelp8:                     return "ParamAudioQcelp8"; | 
 | 381 | //      case OMX_IndexParamAudioQcelp13:                    return "ParamAudioQcelp13"; | 
 | 382 | //      case OMX_IndexParamAudioEvrc:                       return "ParamAudioEvrc"; | 
 | 383 | //      case OMX_IndexParamAudioSmv:                        return "ParamAudioSmv"; | 
 | 384 |         case OMX_IndexParamAudioVorbis:                     return "ParamAudioVorbis"; | 
 | 385 |         case OMX_IndexParamAudioFlac:                       return "ParamAudioFlac"; | 
 | 386 | //      case OMX_IndexConfigAudioMidiImmediateEvent:        return "ConfigAudioMidiImmediateEvent"; | 
 | 387 | //      case OMX_IndexConfigAudioMidiControl:               return "ConfigAudioMidiControl"; | 
 | 388 | //      case OMX_IndexConfigAudioMidiSoundBankProgram: | 
 | 389 | //          return "ConfigAudioMidiSoundBankProgram"; | 
 | 390 | //      case OMX_IndexConfigAudioMidiStatus:                return "ConfigAudioMidiStatus"; | 
 | 391 | //      case OMX_IndexConfigAudioMidiMetaEvent:             return "ConfigAudioMidiMetaEvent"; | 
 | 392 | //      case OMX_IndexConfigAudioMidiMetaEventData:         return "ConfigAudioMidiMetaEventData"; | 
 | 393 | //      case OMX_IndexConfigAudioVolume:                    return "ConfigAudioVolume"; | 
 | 394 | //      case OMX_IndexConfigAudioBalance:                   return "ConfigAudioBalance"; | 
 | 395 | //      case OMX_IndexConfigAudioChannelMute:               return "ConfigAudioChannelMute"; | 
 | 396 | //      case OMX_IndexConfigAudioMute:                      return "ConfigAudioMute"; | 
 | 397 | //      case OMX_IndexConfigAudioLoudness:                  return "ConfigAudioLoudness"; | 
 | 398 | //      case OMX_IndexConfigAudioEchoCancelation:           return "ConfigAudioEchoCancelation"; | 
 | 399 | //      case OMX_IndexConfigAudioNoiseReduction:            return "ConfigAudioNoiseReduction"; | 
 | 400 | //      case OMX_IndexConfigAudioBass:                      return "ConfigAudioBass"; | 
 | 401 | //      case OMX_IndexConfigAudioTreble:                    return "ConfigAudioTreble"; | 
 | 402 | //      case OMX_IndexConfigAudioStereoWidening:            return "ConfigAudioStereoWidening"; | 
 | 403 | //      case OMX_IndexConfigAudioChorus:                    return "ConfigAudioChorus"; | 
 | 404 | //      case OMX_IndexConfigAudioEqualizer:                 return "ConfigAudioEqualizer"; | 
 | 405 | //      case OMX_IndexConfigAudioReverberation:             return "ConfigAudioReverberation"; | 
 | 406 | //      case OMX_IndexConfigAudioChannelVolume:             return "ConfigAudioChannelVolume"; | 
 | 407 | //      case OMX_IndexParamImagePortFormat:                 return "ParamImagePortFormat"; | 
 | 408 | //      case OMX_IndexParamFlashControl:                    return "ParamFlashControl"; | 
 | 409 | //      case OMX_IndexConfigFocusControl:                   return "ConfigFocusControl"; | 
 | 410 | //      case OMX_IndexParamQFactor:                         return "ParamQFactor"; | 
 | 411 | //      case OMX_IndexParamQuantizationTable:               return "ParamQuantizationTable"; | 
 | 412 | //      case OMX_IndexParamHuffmanTable:                    return "ParamHuffmanTable"; | 
 | 413 | //      case OMX_IndexConfigFlashControl:                   return "ConfigFlashControl"; | 
 | 414 |         case OMX_IndexParamVideoPortFormat:                 return "ParamVideoPortFormat"; | 
 | 415 | //      case OMX_IndexParamVideoQuantization:               return "ParamVideoQuantization"; | 
 | 416 | //      case OMX_IndexParamVideoFastUpdate:                 return "ParamVideoFastUpdate"; | 
 | 417 |         case OMX_IndexParamVideoBitrate:                    return "ParamVideoBitrate"; | 
 | 418 | //      case OMX_IndexParamVideoMotionVector:               return "ParamVideoMotionVector"; | 
 | 419 |         case OMX_IndexParamVideoIntraRefresh:               return "ParamVideoIntraRefresh"; | 
 | 420 |         case OMX_IndexParamVideoErrorCorrection:            return "ParamVideoErrorCorrection"; | 
 | 421 | //      case OMX_IndexParamVideoVBSMC:                      return "ParamVideoVBSMC"; | 
 | 422 | //      case OMX_IndexParamVideoMpeg2:                      return "ParamVideoMpeg2"; | 
 | 423 |         case OMX_IndexParamVideoMpeg4:                      return "ParamVideoMpeg4"; | 
 | 424 | //      case OMX_IndexParamVideoWmv:                        return "ParamVideoWmv"; | 
 | 425 | //      case OMX_IndexParamVideoRv:                         return "ParamVideoRv"; | 
 | 426 |         case OMX_IndexParamVideoAvc:                        return "ParamVideoAvc"; | 
 | 427 |         case OMX_IndexParamVideoH263:                       return "ParamVideoH263"; | 
 | 428 |         case OMX_IndexParamVideoProfileLevelQuerySupported: | 
 | 429 |             return "ParamVideoProfileLevelQuerySupported"; | 
 | 430 |         case OMX_IndexParamVideoProfileLevelCurrent:        return "ParamVideoProfileLevelCurrent"; | 
 | 431 |         case OMX_IndexConfigVideoBitrate:                   return "ConfigVideoBitrate"; | 
 | 432 | //      case OMX_IndexConfigVideoFramerate:                 return "ConfigVideoFramerate"; | 
 | 433 |         case OMX_IndexConfigVideoIntraVOPRefresh:           return "ConfigVideoIntraVOPRefresh"; | 
 | 434 | //      case OMX_IndexConfigVideoIntraMBRefresh:            return "ConfigVideoIntraMBRefresh"; | 
 | 435 | //      case OMX_IndexConfigVideoMBErrorReporting:          return "ConfigVideoMBErrorReporting"; | 
 | 436 | //      case OMX_IndexParamVideoMacroblocksPerFrame:        return "ParamVideoMacroblocksPerFrame"; | 
 | 437 | //      case OMX_IndexConfigVideoMacroBlockErrorMap:        return "ConfigVideoMacroBlockErrorMap"; | 
 | 438 | //      case OMX_IndexParamVideoSliceFMO:                   return "ParamVideoSliceFMO"; | 
 | 439 | //      case OMX_IndexConfigVideoAVCIntraPeriod:            return "ConfigVideoAVCIntraPeriod"; | 
 | 440 | //      case OMX_IndexConfigVideoNalSize:                   return "ConfigVideoNalSize"; | 
 | 441 | //      case OMX_IndexParamCommonDeblocking:                return "ParamCommonDeblocking"; | 
 | 442 | //      case OMX_IndexParamCommonSensorMode:                return "ParamCommonSensorMode"; | 
 | 443 | //      case OMX_IndexParamCommonInterleave:                return "ParamCommonInterleave"; | 
 | 444 | //      case OMX_IndexConfigCommonColorFormatConversion: | 
 | 445 | //          return "ConfigCommonColorFormatConversion"; | 
 | 446 |         case OMX_IndexConfigCommonScale:                    return "ConfigCommonScale"; | 
 | 447 | //      case OMX_IndexConfigCommonImageFilter:              return "ConfigCommonImageFilter"; | 
 | 448 | //      case OMX_IndexConfigCommonColorEnhancement:         return "ConfigCommonColorEnhancement"; | 
 | 449 | //      case OMX_IndexConfigCommonColorKey:                 return "ConfigCommonColorKey"; | 
 | 450 | //      case OMX_IndexConfigCommonColorBlend:               return "ConfigCommonColorBlend"; | 
 | 451 | //      case OMX_IndexConfigCommonFrameStabilisation:       return "ConfigCommonFrameStabilisation"; | 
 | 452 | //      case OMX_IndexConfigCommonRotate:                   return "ConfigCommonRotate"; | 
 | 453 | //      case OMX_IndexConfigCommonMirror:                   return "ConfigCommonMirror"; | 
 | 454 | //      case OMX_IndexConfigCommonOutputPosition:           return "ConfigCommonOutputPosition"; | 
 | 455 |         case OMX_IndexConfigCommonInputCrop:                return "ConfigCommonInputCrop"; | 
 | 456 |         case OMX_IndexConfigCommonOutputCrop:               return "ConfigCommonOutputCrop"; | 
 | 457 | //      case OMX_IndexConfigCommonDigitalZoom:              return "ConfigCommonDigitalZoom"; | 
 | 458 | //      case OMX_IndexConfigCommonOpticalZoom:              return "ConfigCommonOpticalZoom"; | 
 | 459 | //      case OMX_IndexConfigCommonWhiteBalance:             return "ConfigCommonWhiteBalance"; | 
 | 460 | //      case OMX_IndexConfigCommonExposure:                 return "ConfigCommonExposure"; | 
 | 461 | //      case OMX_IndexConfigCommonContrast:                 return "ConfigCommonContrast"; | 
 | 462 | //      case OMX_IndexConfigCommonBrightness:               return "ConfigCommonBrightness"; | 
 | 463 | //      case OMX_IndexConfigCommonBacklight:                return "ConfigCommonBacklight"; | 
 | 464 | //      case OMX_IndexConfigCommonGamma:                    return "ConfigCommonGamma"; | 
 | 465 | //      case OMX_IndexConfigCommonSaturation:               return "ConfigCommonSaturation"; | 
 | 466 | //      case OMX_IndexConfigCommonLightness:                return "ConfigCommonLightness"; | 
 | 467 | //      case OMX_IndexConfigCommonExclusionRect:            return "ConfigCommonExclusionRect"; | 
 | 468 | //      case OMX_IndexConfigCommonDithering:                return "ConfigCommonDithering"; | 
 | 469 | //      case OMX_IndexConfigCommonPlaneBlend:               return "ConfigCommonPlaneBlend"; | 
 | 470 | //      case OMX_IndexConfigCommonExposureValue:            return "ConfigCommonExposureValue"; | 
 | 471 | //      case OMX_IndexConfigCommonOutputSize:               return "ConfigCommonOutputSize"; | 
 | 472 | //      case OMX_IndexParamCommonExtraQuantData:            return "ParamCommonExtraQuantData"; | 
 | 473 | //      case OMX_IndexConfigCommonFocusRegion:              return "ConfigCommonFocusRegion"; | 
 | 474 | //      case OMX_IndexConfigCommonFocusStatus:              return "ConfigCommonFocusStatus"; | 
 | 475 | //      case OMX_IndexConfigCommonTransitionEffect:         return "ConfigCommonTransitionEffect"; | 
 | 476 | //      case OMX_IndexParamOtherPortFormat:                 return "ParamOtherPortFormat"; | 
 | 477 | //      case OMX_IndexConfigOtherPower:                     return "ConfigOtherPower"; | 
 | 478 | //      case OMX_IndexConfigOtherStats:                     return "ConfigOtherStats"; | 
 | 479 | //      case OMX_IndexConfigTimeScale:                      return "ConfigTimeScale"; | 
 | 480 | //      case OMX_IndexConfigTimeClockState:                 return "ConfigTimeClockState"; | 
 | 481 | //      case OMX_IndexConfigTimeActiveRefClock:             return "ConfigTimeActiveRefClock"; | 
 | 482 | //      case OMX_IndexConfigTimeCurrentMediaTime:           return "ConfigTimeCurrentMediaTime"; | 
 | 483 | //      case OMX_IndexConfigTimeCurrentWallTime:            return "ConfigTimeCurrentWallTime"; | 
 | 484 | //      case OMX_IndexConfigTimeCurrentAudioReference: | 
 | 485 | //          return "ConfigTimeCurrentAudioReference"; | 
 | 486 | //      case OMX_IndexConfigTimeCurrentVideoReference: | 
 | 487 | //          return "ConfigTimeCurrentVideoReference"; | 
 | 488 | //      case OMX_IndexConfigTimeMediaTimeRequest:           return "ConfigTimeMediaTimeRequest"; | 
 | 489 | //      case OMX_IndexConfigTimeClientStartTime:            return "ConfigTimeClientStartTime"; | 
 | 490 | //      case OMX_IndexConfigTimePosition:                   return "ConfigTimePosition"; | 
 | 491 | //      case OMX_IndexConfigTimeSeekMode:                   return "ConfigTimeSeekMode"; | 
 | 492 |         default:                                            return def; | 
 | 493 |     } | 
 | 494 | } | 
 | 495 |  | 
 | 496 | #endif // AS_STRING_FOR_OMX_INDEX_H | 
 | 497 |  | 
 | 498 | #endif // OMX_Index_h | 
 | 499 |  | 
 | 500 | #ifdef OMX_IndexExt_h | 
 | 501 | /* asString definitions if media/openmax/OMX_IndexExt.h was included */ | 
 | 502 |  | 
 | 503 | #ifndef AS_STRING_FOR_OMX_INDEXEXT_H | 
 | 504 | #define AS_STRING_FOR_OMX_INDEXEXT_H | 
 | 505 |  | 
 | 506 | inline static const char *asString(OMX_INDEXEXTTYPE i, const char *def = "??") { | 
 | 507 |     switch (i) { | 
 | 508 | //      case OMX_IndexConfigCallbackRequest:            return "ConfigCallbackRequest"; | 
 | 509 | //      case OMX_IndexConfigCommitMode:                 return "ConfigCommitMode"; | 
 | 510 | //      case OMX_IndexConfigCommit:                     return "ConfigCommit"; | 
 | 511 |         case OMX_IndexParamAudioAndroidAc3:             return "ParamAudioAndroidAc3"; | 
 | 512 |         case OMX_IndexParamAudioAndroidOpus:            return "ParamAudioAndroidOpus"; | 
 | 513 |         case OMX_IndexParamAudioAndroidAacPresentation: return "ParamAudioAndroidAacPresentation"; | 
 | 514 | //      case OMX_IndexParamNalStreamFormatSupported:    return "ParamNalStreamFormatSupported"; | 
 | 515 | //      case OMX_IndexParamNalStreamFormat:             return "ParamNalStreamFormat"; | 
 | 516 | //      case OMX_IndexParamNalStreamFormatSelect:       return "ParamNalStreamFormatSelect"; | 
 | 517 |         case OMX_IndexParamVideoVp8:                    return "ParamVideoVp8"; | 
 | 518 | //      case OMX_IndexConfigVideoVp8ReferenceFrame:     return "ConfigVideoVp8ReferenceFrame"; | 
 | 519 | //      case OMX_IndexConfigVideoVp8ReferenceFrameType: return "ConfigVideoVp8ReferenceFrameType"; | 
 | 520 |         case OMX_IndexParamVideoAndroidVp8Encoder:      return "ParamVideoAndroidVp8Encoder"; | 
 | 521 |         case OMX_IndexParamVideoHevc:                   return "ParamVideoHevc"; | 
 | 522 | //      case OMX_IndexParamSliceSegments:               return "ParamSliceSegments"; | 
| Lajos Molnar | 76d4c5c | 2014-11-06 10:47:41 -0800 | [diff] [blame] | 523 |         case OMX_IndexConfigAutoFramerateConversion:    return "ConfigAutoFramerateConversion"; | 
| Lajos Molnar | a1ae5a4 | 2014-11-06 17:05:46 -0800 | [diff] [blame] | 524 |         default:                                        return asString((OMX_INDEXTYPE)i, def); | 
 | 525 |     } | 
 | 526 | } | 
 | 527 |  | 
 | 528 | #endif // AS_STRING_FOR_OMX_INDEXEXT_H | 
 | 529 |  | 
 | 530 | #endif // OMX_IndexExt_h | 
 | 531 |  | 
 | 532 | #ifdef OMX_IVCommon_h | 
 | 533 | /* asString definitions if media/openmax/OMX_IVCommon.h was included */ | 
 | 534 |  | 
 | 535 | #ifndef AS_STRING_FOR_OMX_IVCOMMON_H | 
 | 536 | #define AS_STRING_FOR_OMX_IVCOMMON_H | 
 | 537 |  | 
 | 538 | inline static const char *asString(OMX_COLOR_FORMATTYPE i, const char *def = "??") { | 
 | 539 |     switch (i) { | 
 | 540 |         case OMX_COLOR_FormatUnused: | 
 | 541 |             return "COLOR_FormatUnused"; | 
 | 542 |         case OMX_COLOR_FormatMonochrome: | 
 | 543 |             return "COLOR_FormatMonochrome"; | 
 | 544 |         case OMX_COLOR_Format8bitRGB332: | 
 | 545 |             return "COLOR_Format8bitRGB332"; | 
 | 546 |         case OMX_COLOR_Format12bitRGB444: | 
 | 547 |             return "COLOR_Format12bitRGB444"; | 
 | 548 |         case OMX_COLOR_Format16bitARGB4444: | 
 | 549 |             return "COLOR_Format16bitARGB4444"; | 
 | 550 |         case OMX_COLOR_Format16bitARGB1555: | 
 | 551 |             return "COLOR_Format16bitARGB1555"; | 
 | 552 |         case OMX_COLOR_Format16bitRGB565: | 
 | 553 |             return "COLOR_Format16bitRGB565"; | 
 | 554 |         case OMX_COLOR_Format16bitBGR565: | 
 | 555 |             return "COLOR_Format16bitBGR565"; | 
 | 556 |         case OMX_COLOR_Format18bitRGB666: | 
 | 557 |             return "COLOR_Format18bitRGB666"; | 
 | 558 |         case OMX_COLOR_Format18bitARGB1665: | 
 | 559 |             return "COLOR_Format18bitARGB1665"; | 
 | 560 |         case OMX_COLOR_Format19bitARGB1666: | 
 | 561 |             return "COLOR_Format19bitARGB1666"; | 
 | 562 |         case OMX_COLOR_Format24bitRGB888: | 
 | 563 |             return "COLOR_Format24bitRGB888"; | 
 | 564 |         case OMX_COLOR_Format24bitBGR888: | 
 | 565 |             return "COLOR_Format24bitBGR888"; | 
 | 566 |         case OMX_COLOR_Format24bitARGB1887: | 
 | 567 |             return "COLOR_Format24bitARGB1887"; | 
 | 568 |         case OMX_COLOR_Format25bitARGB1888: | 
 | 569 |             return "COLOR_Format25bitARGB1888"; | 
 | 570 |         case OMX_COLOR_Format32bitBGRA8888: | 
 | 571 |             return "COLOR_Format32bitBGRA8888"; | 
 | 572 |         case OMX_COLOR_Format32bitARGB8888: | 
 | 573 |             return "COLOR_Format32bitARGB8888"; | 
 | 574 |         case OMX_COLOR_FormatYUV411Planar: | 
 | 575 |             return "COLOR_FormatYUV411Planar"; | 
 | 576 |         case OMX_COLOR_FormatYUV411PackedPlanar: | 
 | 577 |             return "COLOR_FormatYUV411PackedPlanar"; | 
 | 578 |         case OMX_COLOR_FormatYUV420Planar: | 
 | 579 |             return "COLOR_FormatYUV420Planar"; | 
 | 580 |         case OMX_COLOR_FormatYUV420PackedPlanar: | 
 | 581 |             return "COLOR_FormatYUV420PackedPlanar"; | 
 | 582 |         case OMX_COLOR_FormatYUV420SemiPlanar: | 
 | 583 |             return "COLOR_FormatYUV420SemiPlanar"; | 
 | 584 |         case OMX_COLOR_FormatYUV422Planar: | 
 | 585 |             return "COLOR_FormatYUV422Planar"; | 
 | 586 |         case OMX_COLOR_FormatYUV422PackedPlanar: | 
 | 587 |             return "COLOR_FormatYUV422PackedPlanar"; | 
 | 588 |         case OMX_COLOR_FormatYUV422SemiPlanar: | 
 | 589 |             return "COLOR_FormatYUV422SemiPlanar"; | 
 | 590 |         case OMX_COLOR_FormatYCbYCr: | 
 | 591 |             return "COLOR_FormatYCbYCr"; | 
 | 592 |         case OMX_COLOR_FormatYCrYCb: | 
 | 593 |             return "COLOR_FormatYCrYCb"; | 
 | 594 |         case OMX_COLOR_FormatCbYCrY: | 
 | 595 |             return "COLOR_FormatCbYCrY"; | 
 | 596 |         case OMX_COLOR_FormatCrYCbY: | 
 | 597 |             return "COLOR_FormatCrYCbY"; | 
 | 598 |         case OMX_COLOR_FormatYUV444Interleaved: | 
 | 599 |             return "COLOR_FormatYUV444Interleaved"; | 
 | 600 |         case OMX_COLOR_FormatRawBayer8bit: | 
 | 601 |             return "COLOR_FormatRawBayer8bit"; | 
 | 602 |         case OMX_COLOR_FormatRawBayer10bit: | 
 | 603 |             return "COLOR_FormatRawBayer10bit"; | 
 | 604 |         case OMX_COLOR_FormatRawBayer8bitcompressed: | 
 | 605 |             return "COLOR_FormatRawBayer8bitcompressed"; | 
 | 606 |         case OMX_COLOR_FormatL2: | 
 | 607 |             return "COLOR_FormatL2"; | 
 | 608 |         case OMX_COLOR_FormatL4: | 
 | 609 |             return "COLOR_FormatL4"; | 
 | 610 |         case OMX_COLOR_FormatL8: | 
 | 611 |             return "COLOR_FormatL8"; | 
 | 612 |         case OMX_COLOR_FormatL16: | 
 | 613 |             return "COLOR_FormatL16"; | 
 | 614 |         case OMX_COLOR_FormatL24: | 
 | 615 |             return "COLOR_FormatL24"; | 
 | 616 |         case OMX_COLOR_FormatL32: | 
 | 617 |             return "COLOR_FormatL32"; | 
 | 618 |         case OMX_COLOR_FormatYUV420PackedSemiPlanar: | 
 | 619 |             return "COLOR_FormatYUV420PackedSemiPlanar"; | 
 | 620 |         case OMX_COLOR_FormatYUV422PackedSemiPlanar: | 
 | 621 |             return "COLOR_FormatYUV422PackedSemiPlanar"; | 
 | 622 |         case OMX_COLOR_Format18BitBGR666: | 
 | 623 |             return "COLOR_Format18BitBGR666"; | 
 | 624 |         case OMX_COLOR_Format24BitARGB6666: | 
 | 625 |             return "COLOR_Format24BitARGB6666"; | 
 | 626 |         case OMX_COLOR_Format24BitABGR6666: | 
 | 627 |             return "COLOR_Format24BitABGR6666"; | 
 | 628 |         case OMX_COLOR_FormatAndroidOpaque: | 
 | 629 |             return "COLOR_FormatAndroidOpaque"; | 
 | 630 |         case OMX_COLOR_FormatYUV420Flexible: | 
 | 631 |             return "COLOR_FormatYUV420Flexible"; | 
 | 632 |         case OMX_TI_COLOR_FormatYUV420PackedSemiPlanar: | 
 | 633 |             return "TI_COLOR_FormatYUV420PackedSemiPlanar"; | 
 | 634 |         case OMX_QCOM_COLOR_FormatYVU420SemiPlanar: | 
 | 635 |             return "QCOM_COLOR_FormatYVU420SemiPlanar"; | 
 | 636 | //      case OMX_QCOM_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka: | 
 | 637 | //          return "QCOM_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka"; | 
 | 638 | //      case OMX_SEC_COLOR_FormatNV12Tiled: | 
 | 639 | //          return "SEC_COLOR_FormatNV12Tiled"; | 
 | 640 | //      case OMX_QCOM_COLOR_FormatYUV420PackedSemiPlanar32m: | 
 | 641 | //          return "QCOM_COLOR_FormatYUV420PackedSemiPlanar32m"; | 
 | 642 |         default: | 
 | 643 |             return def; | 
 | 644 |     } | 
 | 645 | } | 
 | 646 |  | 
 | 647 | #endif // AS_STRING_FOR_OMX_IVCOMMON_H | 
 | 648 |  | 
 | 649 | #endif // OMX_IVCommon_h | 
 | 650 |  | 
 | 651 | #ifdef OMX_Types_h | 
 | 652 | /* asString definitions if media/openmax/OMX_Types.h was included */ | 
 | 653 |  | 
 | 654 | #ifndef AS_STRING_FOR_OMX_TYPES_H | 
 | 655 | #define AS_STRING_FOR_OMX_TYPES_H | 
 | 656 |  | 
 | 657 | inline static const char *asString(OMX_BOOL i, const char *def = "??") { | 
 | 658 |     switch (i) { | 
 | 659 |         case OMX_FALSE: return "FALSE"; | 
 | 660 |         case OMX_TRUE:  return "TRUE"; | 
 | 661 |         default:        return def; | 
 | 662 |     } | 
 | 663 | } | 
 | 664 |  | 
 | 665 | inline static const char *asString(OMX_DIRTYPE i, const char *def = "??") { | 
 | 666 |     switch (i) { | 
 | 667 |         case OMX_DirInput:  return "Input"; | 
 | 668 |         case OMX_DirOutput: return "Output"; | 
 | 669 |         default:            return def; | 
 | 670 |     } | 
 | 671 | } | 
 | 672 |  | 
 | 673 | inline static const char *asString(OMX_ENDIANTYPE i, const char *def = "??") { | 
 | 674 |     switch (i) { | 
 | 675 |         case OMX_EndianBig:    return "Big"; | 
 | 676 | //      case OMX_EndianLittle: return "Little"; | 
 | 677 |         default:               return def; | 
 | 678 |     } | 
 | 679 | } | 
 | 680 |  | 
 | 681 | inline static const char *asString(OMX_NUMERICALDATATYPE i, const char *def = "??") { | 
 | 682 |     switch (i) { | 
 | 683 |         case OMX_NumericalDataSigned:   return "Signed"; | 
 | 684 | //      case OMX_NumericalDataUnsigned: return "Unsigned"; | 
 | 685 |         default:                        return def; | 
 | 686 |     } | 
 | 687 | } | 
 | 688 |  | 
 | 689 | #endif // AS_STRING_FOR_OMX_TYPES_H | 
 | 690 |  | 
 | 691 | #endif // OMX_Types_h | 
 | 692 |  | 
 | 693 | #ifdef OMX_Video_h | 
 | 694 | /* asString definitions if media/openmax/OMX_Video.h was included */ | 
 | 695 |  | 
 | 696 | #ifndef AS_STRING_FOR_OMX_VIDEO_H | 
 | 697 | #define AS_STRING_FOR_OMX_VIDEO_H | 
 | 698 |  | 
 | 699 | inline static const char *asString(OMX_VIDEO_CODINGTYPE i, const char *def = "??") { | 
 | 700 |     switch (i) { | 
 | 701 |         case OMX_VIDEO_CodingUnused:     return "Unused"; | 
 | 702 |         case OMX_VIDEO_CodingAutoDetect: return "AutoDetect";  // unused | 
 | 703 |         case OMX_VIDEO_CodingMPEG2:      return "MPEG2"; | 
 | 704 |         case OMX_VIDEO_CodingH263:       return "H263"; | 
 | 705 |         case OMX_VIDEO_CodingMPEG4:      return "MPEG4"; | 
 | 706 |         case OMX_VIDEO_CodingWMV:        return "WMV";         // unused | 
 | 707 |         case OMX_VIDEO_CodingRV:         return "RV";          // unused | 
 | 708 |         case OMX_VIDEO_CodingAVC:        return "AVC"; | 
 | 709 |         case OMX_VIDEO_CodingMJPEG:      return "MJPEG";       // unused | 
 | 710 |         case OMX_VIDEO_CodingVP8:        return "VP8"; | 
 | 711 |         case OMX_VIDEO_CodingVP9:        return "VP9"; | 
 | 712 |         case OMX_VIDEO_CodingHEVC:       return "HEVC"; | 
 | 713 |         default:                         return def; | 
 | 714 |     } | 
 | 715 | } | 
 | 716 |  | 
 | 717 | inline static const char *asString(OMX_VIDEO_CONTROLRATETYPE i, const char *def = "??") { | 
 | 718 |     switch (i) { | 
 | 719 | //      case OMX_Video_ControlRateDisable:            return "Disable"; | 
 | 720 |         case OMX_Video_ControlRateVariable:           return "Variable"; | 
 | 721 |         case OMX_Video_ControlRateConstant:           return "Constant"; | 
 | 722 | //      case OMX_Video_ControlRateVariableSkipFrames: return "VariableSkipFrames"; | 
 | 723 | //      case OMX_Video_ControlRateConstantSkipFrames: return "ConstantSkipFrames"; | 
 | 724 |         default:                                      return def; | 
 | 725 |     } | 
 | 726 | } | 
 | 727 |  | 
 | 728 | inline static const char *asString(OMX_VIDEO_INTRAREFRESHTYPE i, const char *def = "??") { | 
 | 729 |     switch (i) { | 
 | 730 |         case OMX_VIDEO_IntraRefreshCyclic:   return "Cyclic"; | 
 | 731 |         case OMX_VIDEO_IntraRefreshAdaptive: return "Adaptive"; | 
 | 732 |         case OMX_VIDEO_IntraRefreshBoth:     return "Both"; | 
 | 733 |         default:                             return def; | 
 | 734 |     } | 
 | 735 | } | 
 | 736 |  | 
 | 737 | inline static const char *asString(OMX_VIDEO_H263PROFILETYPE i, const char *def = "??") { | 
 | 738 |     switch (i) { | 
 | 739 |         case OMX_VIDEO_H263ProfileBaseline:           return "Baseline"; | 
 | 740 |         case OMX_VIDEO_H263ProfileH320Coding:         return "H320Coding"; | 
 | 741 |         case OMX_VIDEO_H263ProfileBackwardCompatible: return "BackwardCompatible"; | 
 | 742 |         case OMX_VIDEO_H263ProfileISWV2:              return "ISWV2"; | 
 | 743 |         case OMX_VIDEO_H263ProfileISWV3:              return "ISWV3"; | 
 | 744 |         case OMX_VIDEO_H263ProfileHighCompression:    return "HighCompression"; | 
 | 745 |         case OMX_VIDEO_H263ProfileInternet:           return "Internet"; | 
 | 746 |         case OMX_VIDEO_H263ProfileInterlace:          return "Interlace"; | 
 | 747 |         case OMX_VIDEO_H263ProfileHighLatency:        return "HighLatency"; | 
 | 748 |         default:                                      return def; | 
 | 749 |     } | 
 | 750 | } | 
 | 751 |  | 
 | 752 | inline static const char *asString(OMX_VIDEO_H263LEVELTYPE i, const char *def = "??") { | 
 | 753 |     switch (i) { | 
 | 754 |         case OMX_VIDEO_H263Level10: return "Level10"; | 
 | 755 |         case OMX_VIDEO_H263Level20: return "Level20"; | 
 | 756 |         case OMX_VIDEO_H263Level30: return "Level30"; | 
 | 757 |         case OMX_VIDEO_H263Level40: return "Level40"; | 
 | 758 |         case OMX_VIDEO_H263Level45: return "Level45"; | 
 | 759 |         case OMX_VIDEO_H263Level50: return "Level50"; | 
 | 760 |         case OMX_VIDEO_H263Level60: return "Level60"; | 
 | 761 |         case OMX_VIDEO_H263Level70: return "Level70"; | 
 | 762 |         default:                    return def; | 
 | 763 |     } | 
 | 764 | } | 
 | 765 |  | 
 | 766 | inline static const char *asString(OMX_VIDEO_PICTURETYPE i, const char *def = "??") { | 
 | 767 |     switch (i) { | 
 | 768 |         case OMX_VIDEO_PictureTypeI:  return "I"; | 
 | 769 |         case OMX_VIDEO_PictureTypeP:  return "P"; | 
 | 770 |         case OMX_VIDEO_PictureTypeB:  return "B"; | 
 | 771 | //      case OMX_VIDEO_PictureTypeSI: return "SI"; | 
 | 772 | //      case OMX_VIDEO_PictureTypeSP: return "SP"; | 
 | 773 | //      case OMX_VIDEO_PictureTypeEI: return "EI"; | 
 | 774 | //      case OMX_VIDEO_PictureTypeEP: return "EP"; | 
 | 775 | //      case OMX_VIDEO_PictureTypeS:  return "S"; | 
 | 776 |         default:                      return def; | 
 | 777 |     } | 
 | 778 | } | 
 | 779 |  | 
 | 780 | inline static const char *asString(OMX_VIDEO_MPEG4PROFILETYPE i, const char *def = "??") { | 
 | 781 |     switch (i) { | 
 | 782 |         case OMX_VIDEO_MPEG4ProfileSimple:           return "Simple"; | 
 | 783 |         case OMX_VIDEO_MPEG4ProfileSimpleScalable:   return "SimpleScalable"; | 
 | 784 |         case OMX_VIDEO_MPEG4ProfileCore:             return "Core"; | 
 | 785 |         case OMX_VIDEO_MPEG4ProfileMain:             return "Main"; | 
 | 786 |         case OMX_VIDEO_MPEG4ProfileNbit:             return "Nbit"; | 
 | 787 |         case OMX_VIDEO_MPEG4ProfileScalableTexture:  return "ScalableTexture"; | 
 | 788 |         case OMX_VIDEO_MPEG4ProfileSimpleFace:       return "SimpleFace"; | 
 | 789 |         case OMX_VIDEO_MPEG4ProfileSimpleFBA:        return "SimpleFBA"; | 
 | 790 |         case OMX_VIDEO_MPEG4ProfileBasicAnimated:    return "BasicAnimated"; | 
 | 791 |         case OMX_VIDEO_MPEG4ProfileHybrid:           return "Hybrid"; | 
 | 792 |         case OMX_VIDEO_MPEG4ProfileAdvancedRealTime: return "AdvancedRealTime"; | 
 | 793 |         case OMX_VIDEO_MPEG4ProfileCoreScalable:     return "CoreScalable"; | 
 | 794 |         case OMX_VIDEO_MPEG4ProfileAdvancedCoding:   return "AdvancedCoding"; | 
 | 795 |         case OMX_VIDEO_MPEG4ProfileAdvancedCore:     return "AdvancedCore"; | 
 | 796 |         case OMX_VIDEO_MPEG4ProfileAdvancedScalable: return "AdvancedScalable"; | 
 | 797 |         case OMX_VIDEO_MPEG4ProfileAdvancedSimple:   return "AdvancedSimple"; | 
 | 798 |         default:                                     return def; | 
 | 799 |     } | 
 | 800 | } | 
 | 801 |  | 
 | 802 | inline static const char *asString(OMX_VIDEO_MPEG4LEVELTYPE i, const char *def = "??") { | 
 | 803 |     switch (i) { | 
 | 804 |         case OMX_VIDEO_MPEG4Level0:  return "Level0"; | 
 | 805 |         case OMX_VIDEO_MPEG4Level0b: return "Level0b"; | 
 | 806 |         case OMX_VIDEO_MPEG4Level1:  return "Level1"; | 
 | 807 |         case OMX_VIDEO_MPEG4Level2:  return "Level2"; | 
 | 808 |         case OMX_VIDEO_MPEG4Level3:  return "Level3"; | 
 | 809 |         case OMX_VIDEO_MPEG4Level4:  return "Level4"; | 
 | 810 |         case OMX_VIDEO_MPEG4Level4a: return "Level4a"; | 
 | 811 |         case OMX_VIDEO_MPEG4Level5:  return "Level5"; | 
 | 812 |         default:                     return def; | 
 | 813 |     } | 
 | 814 | } | 
 | 815 |  | 
 | 816 | inline static const char *asString(OMX_VIDEO_AVCPROFILETYPE i, const char *def = "??") { | 
 | 817 |     switch (i) { | 
 | 818 |         case OMX_VIDEO_AVCProfileBaseline: return "Baseline"; | 
 | 819 |         case OMX_VIDEO_AVCProfileMain:     return "Main"; | 
 | 820 |         case OMX_VIDEO_AVCProfileExtended: return "Extended"; | 
 | 821 |         case OMX_VIDEO_AVCProfileHigh:     return "High"; | 
 | 822 |         case OMX_VIDEO_AVCProfileHigh10:   return "High10"; | 
 | 823 |         case OMX_VIDEO_AVCProfileHigh422:  return "High422"; | 
 | 824 |         case OMX_VIDEO_AVCProfileHigh444:  return "High444"; | 
 | 825 |         default:                           return def; | 
 | 826 |     } | 
 | 827 | } | 
 | 828 |  | 
 | 829 | inline static const char *asString(OMX_VIDEO_AVCLEVELTYPE i, const char *def = "??") { | 
 | 830 |     switch (i) { | 
 | 831 |         case OMX_VIDEO_AVCLevel1:  return "Level1"; | 
 | 832 |         case OMX_VIDEO_AVCLevel1b: return "Level1b"; | 
 | 833 |         case OMX_VIDEO_AVCLevel11: return "Level11"; | 
 | 834 |         case OMX_VIDEO_AVCLevel12: return "Level12"; | 
 | 835 |         case OMX_VIDEO_AVCLevel13: return "Level13"; | 
 | 836 |         case OMX_VIDEO_AVCLevel2:  return "Level2"; | 
 | 837 |         case OMX_VIDEO_AVCLevel21: return "Level21"; | 
 | 838 |         case OMX_VIDEO_AVCLevel22: return "Level22"; | 
 | 839 |         case OMX_VIDEO_AVCLevel3:  return "Level3"; | 
 | 840 |         case OMX_VIDEO_AVCLevel31: return "Level31"; | 
 | 841 |         case OMX_VIDEO_AVCLevel32: return "Level32"; | 
 | 842 |         case OMX_VIDEO_AVCLevel4:  return "Level4"; | 
 | 843 |         case OMX_VIDEO_AVCLevel41: return "Level41"; | 
 | 844 |         case OMX_VIDEO_AVCLevel42: return "Level42"; | 
 | 845 |         case OMX_VIDEO_AVCLevel5:  return "Level5"; | 
 | 846 |         case OMX_VIDEO_AVCLevel51: return "Level51"; | 
 | 847 |         case OMX_VIDEO_AVCLevel52: return "Level52"; | 
 | 848 |         default:                   return def; | 
 | 849 |     } | 
 | 850 | } | 
 | 851 |  | 
 | 852 | inline static const char *asString(OMX_VIDEO_AVCLOOPFILTERTYPE i, const char *def = "??") { | 
 | 853 |     switch (i) { | 
 | 854 |         case OMX_VIDEO_AVCLoopFilterEnable:               return "Enable"; | 
 | 855 | //      case OMX_VIDEO_AVCLoopFilterDisable:              return "Disable"; | 
 | 856 | //      case OMX_VIDEO_AVCLoopFilterDisableSliceBoundary: return "DisableSliceBoundary"; | 
 | 857 |         default:                                          return def; | 
 | 858 |     } | 
 | 859 | } | 
 | 860 |  | 
 | 861 | #endif // AS_STRING_FOR_OMX_VIDEO_H | 
 | 862 |  | 
 | 863 | #endif // OMX_Video_h | 
 | 864 |  | 
 | 865 | #ifdef OMX_VideoExt_h | 
 | 866 | /* asString definitions if media/openmax/OMX_VideoExt.h was included */ | 
 | 867 |  | 
 | 868 | #ifndef AS_STRING_FOR_OMX_VIDEOEXT_H | 
 | 869 | #define AS_STRING_FOR_OMX_VIDEOEXT_H | 
 | 870 |  | 
 | 871 | inline static const char *asString(OMX_VIDEO_VP8PROFILETYPE i, const char *def = "!!") { | 
 | 872 |     switch (i) { | 
 | 873 |         case OMX_VIDEO_VP8ProfileMain:    return "Main"; | 
 | 874 |         case OMX_VIDEO_VP8ProfileUnknown: return "Unknown";  // unused | 
 | 875 |         default:                          return def; | 
 | 876 |     } | 
 | 877 | } | 
 | 878 |  | 
 | 879 | inline static const char *asString(OMX_VIDEO_VP8LEVELTYPE i, const char *def = "!!") { | 
 | 880 |     switch (i) { | 
 | 881 |         case OMX_VIDEO_VP8Level_Version0: return "_Version0"; | 
 | 882 |         case OMX_VIDEO_VP8Level_Version1: return "_Version1"; | 
 | 883 |         case OMX_VIDEO_VP8Level_Version2: return "_Version2"; | 
 | 884 |         case OMX_VIDEO_VP8Level_Version3: return "_Version3"; | 
 | 885 |         case OMX_VIDEO_VP8LevelUnknown:   return "Unknown";    // unused | 
 | 886 |         default:                          return def; | 
 | 887 |     } | 
 | 888 | } | 
 | 889 |  | 
 | 890 | inline static const char *asString( | 
 | 891 |         OMX_VIDEO_ANDROID_VPXTEMPORALLAYERPATTERNTYPE i, const char *def = "??") { | 
 | 892 |     switch (i) { | 
 | 893 |         case OMX_VIDEO_VPXTemporalLayerPatternNone:   return "VPXTemporalLayerPatternNone"; | 
 | 894 |         case OMX_VIDEO_VPXTemporalLayerPatternWebRTC: return "VPXTemporalLayerPatternWebRTC"; | 
 | 895 |         default:                                      return def; | 
 | 896 |     } | 
 | 897 | } | 
 | 898 |  | 
 | 899 | inline static const char *asString(OMX_VIDEO_HEVCPROFILETYPE i, const char *def = "!!") { | 
 | 900 |     switch (i) { | 
 | 901 |         case OMX_VIDEO_HEVCProfileUnknown: return "Unknown";  // unused | 
 | 902 |         case OMX_VIDEO_HEVCProfileMain:    return "Main"; | 
 | 903 |         case OMX_VIDEO_HEVCProfileMain10:  return "Main10"; | 
 | 904 |         default:                           return def; | 
 | 905 |     } | 
 | 906 | } | 
 | 907 |  | 
 | 908 | inline static const char *asString(OMX_VIDEO_HEVCLEVELTYPE i, const char *def = "!!") { | 
 | 909 |     switch (i) { | 
 | 910 |         case OMX_VIDEO_HEVCLevelUnknown:    return "LevelUnknown";     // unused | 
 | 911 |         case OMX_VIDEO_HEVCMainTierLevel1:  return "MainTierLevel1"; | 
 | 912 |         case OMX_VIDEO_HEVCHighTierLevel1:  return "HighTierLevel1"; | 
 | 913 |         case OMX_VIDEO_HEVCMainTierLevel2:  return "MainTierLevel2"; | 
 | 914 |         case OMX_VIDEO_HEVCHighTierLevel2:  return "HighTierLevel2"; | 
 | 915 |         case OMX_VIDEO_HEVCMainTierLevel21: return "MainTierLevel21"; | 
 | 916 |         case OMX_VIDEO_HEVCHighTierLevel21: return "HighTierLevel21"; | 
 | 917 |         case OMX_VIDEO_HEVCMainTierLevel3:  return "MainTierLevel3"; | 
 | 918 |         case OMX_VIDEO_HEVCHighTierLevel3:  return "HighTierLevel3"; | 
 | 919 |         case OMX_VIDEO_HEVCMainTierLevel31: return "MainTierLevel31"; | 
 | 920 |         case OMX_VIDEO_HEVCHighTierLevel31: return "HighTierLevel31"; | 
 | 921 |         case OMX_VIDEO_HEVCMainTierLevel4:  return "MainTierLevel4"; | 
 | 922 |         case OMX_VIDEO_HEVCHighTierLevel4:  return "HighTierLevel4"; | 
 | 923 |         case OMX_VIDEO_HEVCMainTierLevel41: return "MainTierLevel41"; | 
 | 924 |         case OMX_VIDEO_HEVCHighTierLevel41: return "HighTierLevel41"; | 
 | 925 |         case OMX_VIDEO_HEVCMainTierLevel5:  return "MainTierLevel5"; | 
 | 926 |         case OMX_VIDEO_HEVCHighTierLevel5:  return "HighTierLevel5"; | 
 | 927 |         case OMX_VIDEO_HEVCMainTierLevel51: return "MainTierLevel51"; | 
 | 928 |         case OMX_VIDEO_HEVCHighTierLevel51: return "HighTierLevel51"; | 
 | 929 |         case OMX_VIDEO_HEVCMainTierLevel52: return "MainTierLevel52"; | 
 | 930 |         case OMX_VIDEO_HEVCHighTierLevel52: return "HighTierLevel52"; | 
 | 931 |         case OMX_VIDEO_HEVCMainTierLevel6:  return "MainTierLevel6"; | 
 | 932 |         case OMX_VIDEO_HEVCHighTierLevel6:  return "HighTierLevel6"; | 
 | 933 |         case OMX_VIDEO_HEVCMainTierLevel61: return "MainTierLevel61"; | 
 | 934 |         case OMX_VIDEO_HEVCHighTierLevel61: return "HighTierLevel61"; | 
 | 935 |         case OMX_VIDEO_HEVCMainTierLevel62: return "MainTierLevel62"; | 
 | 936 |         case OMX_VIDEO_HEVCHighTierLevel62: return "HighTierLevel62"; | 
 | 937 |         default:                            return def; | 
 | 938 |     } | 
 | 939 | } | 
 | 940 |  | 
 | 941 | #endif // AS_STRING_FOR_OMX_VIDEOEXT_H | 
 | 942 |  | 
 | 943 | #endif // OMX_VideoExt_h |