utils/codec_utils.cpp

   1 /*
   2  * Copyright 2012 Michael Chen <omxcodec@gmail.com>
   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 #define LOG_TAG "codec_utils"
  18 #include <utils/Log.h>
  19
  20 extern "C" {
  21
  22 #include "config.h"
  23 #include "libavcodec/xiph.h"
  24 #include "libavutil/intreadwrite.h"
  25
  26 }
  27
  28 #include <utils/Errors.h>
  29 #include <media/stagefright/foundation/ABitReader.h>
  30 #include <media/stagefright/foundation/ADebug.h>
  31 #include <media/stagefright/foundation/avc_utils.h>
  32 #include <media/stagefright/MediaDefs.h>
  33 #include <media/stagefright/MediaErrors.h>
  34 #include <media/stagefright/MetaData.h>
  35 #include <media/stagefright/MetaDataUtils.h>
  36
  37 #include "codec_utils.h"
  38
  39 namespace android {
  40
  41 static void EncodeSize14(uint8_t **_ptr, size_t size) {
  42     CHECK_LE(size, 0x3fffu);
  43
  44     uint8_t *ptr = *_ptr;
  45
  46     *ptr++ = 0x80 | (size >> 7);
  47     *ptr++ = size & 0x7f;
  48
  49     *_ptr = ptr;
  50 }
  51
  52 static sp<ABuffer> MakeMPEGVideoESDS(const sp<ABuffer> &csd) {
  53     sp<ABuffer> esds = new ABuffer(csd->size() + 25);
  54
  55     uint8_t *ptr = esds->data();
  56     *ptr++ = 0x03;
  57     EncodeSize14(&ptr, 22 + csd->size());
  58
  59     *ptr++ = 0x00;  // ES_ID
  60     *ptr++ = 0x00;
  61
  62     *ptr++ = 0x00;  // streamDependenceFlag, URL_Flag, OCRstreamFlag
  63
  64     *ptr++ = 0x04;
  65     EncodeSize14(&ptr, 16 + csd->size());
  66
  67     *ptr++ = 0x40;  // Audio ISO/IEC 14496-3
  68
  69     for (size_t i = 0; i < 12; ++i) {
  70         *ptr++ = 0x00;
  71     }
  72
  73     *ptr++ = 0x05;
  74     EncodeSize14(&ptr, csd->size());
  75
  76     memcpy(ptr, csd->data(), csd->size());
  77
  78     return esds;
  79 }
  80
  81 //video
  82
  83 //H.264 Video Types
  84 //http://msdn.microsoft.com/en-us/library/dd757808(v=vs.85).aspx
  85
  86 // H.264 bitstream without start codes.
  87 status_t setAVCFormat(AVCodecContext *avctx, MetaDataBase &meta)
  88 {
  89     ALOGV("AVC");
  90
  91     CHECK_GT(avctx->extradata_size, 0);
  92     CHECK_EQ((int)avctx->extradata[0], 1); //configurationVersion
  93
  94     if (avctx->width == 0 || avctx->height == 0) {
  95          int32_t width, height;
  96          sp<ABuffer> seqParamSet = new ABuffer(avctx->extradata_size - 8);
  97          memcpy(seqParamSet->data(), avctx->extradata + 8, avctx->extradata_size - 8);
  98          FindAVCDimensions(seqParamSet, &width, &height);
  99          avctx->width  = width;
 100          avctx->height = height;
 101      }
 102
 103     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);
 104     meta.setData(kKeyAVCC, kTypeAVCC, avctx->extradata, avctx->extradata_size);
 105
 106     return OK;
 107 }
 108
 109 // H.264 bitstream with start codes.
 110 status_t setH264Format(AVCodecContext *avctx, MetaDataBase &meta)
 111 {
 112     ALOGV("H264");
 113
 114     CHECK_NE((int)avctx->extradata[0], 1); //configurationVersion
 115
 116     if (!MakeAVCCodecSpecificData(meta, avctx->extradata, avctx->extradata_size))
 117       return UNKNOWN_ERROR;
 118
 119     return OK;
 120 }
 121
 122 status_t setMPEG4Format(AVCodecContext *avctx, MetaDataBase &meta)
 123 {
 124     ALOGV("MPEG4");
 125
 126     sp<ABuffer> csd = new ABuffer(avctx->extradata_size);
 127     memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
 128     sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
 129
 130     meta.setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
 131
 132     int divxVersion = getDivXVersion(avctx);
 133     if (divxVersion >= 0) {
 134         meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_DIVX);
 135         meta.setInt32(kKeyDivXVersion, divxVersion);
 136     } else {
 137         meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
 138     }
 139     return OK;
 140 }
 141
 142 status_t setH263Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
 143 {
 144     ALOGV("H263");
 145
 146     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_H263);
 147
 148     return OK;
 149 }
 150
 151 status_t setMPEG2VIDEOFormat(AVCodecContext *avctx, MetaDataBase &meta)
 152 {
 153     ALOGV("MPEG%uVIDEO", avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 2 : 1);
 154
 155     sp<ABuffer> csd = new ABuffer(avctx->extradata_size);
 156     memcpy(csd->data(), avctx->extradata, avctx->extradata_size);
 157     sp<ABuffer> esds = MakeMPEGVideoESDS(csd);
 158
 159     meta.setData(kKeyESDS, kTypeESDS, esds->data(), esds->size());
 160     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG2);
 161
 162     return OK;
 163 }
 164
 165 status_t setVC1Format(AVCodecContext *avctx, MetaDataBase &meta)
 166 {
 167     ALOGV("VC1");
 168
 169     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VC1);
 170     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 171
 172     return OK;
 173 }
 174
 175 status_t setWMV1Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
 176 {
 177     ALOGV("WMV1");
 178
 179     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
 180     meta.setInt32(kKeyWMVVersion, kTypeWMVVer_7);
 181
 182     return OK;
 183 }
 184
 185 status_t setWMV2Format(AVCodecContext *avctx, MetaDataBase &meta)
 186 {
 187     ALOGV("WMV2");
 188
 189     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
 190     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 191     meta.setInt32(kKeyWMVVersion, kTypeWMVVer_8);
 192
 193     return OK;
 194 }
 195
 196 status_t setWMV3Format(AVCodecContext *avctx, MetaDataBase &meta)
 197 {
 198     ALOGV("WMV3");
 199
 200     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);
 201     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 202     meta.setInt32(kKeyWMVVersion, kTypeWMVVer_9);
 203
 204     return OK;
 205 }
 206
 207 status_t setRV20Format(AVCodecContext *avctx, MetaDataBase &meta)
 208 {
 209     ALOGV("RV20");
 210
 211     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
 212     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 213     meta.setInt32(kKeyRVVersion, kTypeRVVer_G2); //http://en.wikipedia.org/wiki/RealVide
 214
 215     return OK;
 216 }
 217
 218 status_t setRV30Format(AVCodecContext *avctx, MetaDataBase &meta)
 219 {
 220     ALOGV("RV30");
 221
 222     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
 223     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 224     meta.setInt32(kKeyRVVersion, kTypeRVVer_8); //http://en.wikipedia.org/wiki/RealVide
 225
 226     return OK;
 227 }
 228
 229 status_t setRV40Format(AVCodecContext *avctx, MetaDataBase &meta)
 230 {
 231     ALOGV("RV40");
 232
 233     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RV);
 234     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 235     meta.setInt32(kKeyRVVersion, kTypeRVVer_9); //http://en.wikipedia.org/wiki/RealVide
 236
 237     return OK;
 238 }
 239
 240 status_t setFLV1Format(AVCodecContext *avctx, MetaDataBase &meta)
 241 {
 242     ALOGV("FLV1(Sorenson H263)");
 243
 244     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_FLV1);
 245     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 246
 247     return OK;
 248 }
 249
 250 status_t setHEVCFormat(AVCodecContext *avctx, MetaDataBase &meta)
 251 {
 252     ALOGV("HEVC");
 253
 254     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_HEVC);
 255     meta.setData(kKeyHVCC, kTypeHVCC, avctx->extradata, avctx->extradata_size);
 256
 257     return OK;
 258 }
 259
 260 status_t setVP8Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
 261 {
 262     ALOGV("VP8");
 263
 264     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP8);
 265
 266     return OK;
 267 }
 268
 269 status_t setVP9Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
 270 {
 271     ALOGV("VP9");
 272
 273     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP9);
 274
 275     return OK;
 276 }
 277
 278 //audio
 279
 280 status_t setMP2Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
 281 {
 282     ALOGV("MP2");
 283
 284     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
 285
 286     return OK;
 287 }
 288
 289 status_t setMP3Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
 290 {
 291     ALOGV("MP3");
 292
 293     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
 294
 295     return OK;
 296 }
 297
 298 status_t setVORBISFormat(AVCodecContext *avctx, MetaDataBase &meta)
 299 {
 300     ALOGV("VORBIS");
 301
 302     const uint8_t *header_start[3];
 303     int header_len[3];
 304     if (avpriv_split_xiph_headers(avctx->extradata,
 305                 avctx->extradata_size, 30,
 306                 header_start, header_len) < 0) {
 307         ALOGE("vorbis extradata corrupt.");
 308         return UNKNOWN_ERROR;
 309     }
 310
 311     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_VORBIS);
 312     //identification header
 313     meta.setData(kKeyVorbisInfo,  0, header_start[0], header_len[0]);
 314     //setup header
 315     meta.setData(kKeyVorbisBooks, 0, header_start[2], header_len[2]);
 316
 317     return OK;
 318 }
 319
 320 status_t setAC3Format(AVCodecContext *avctx __unused, MetaDataBase &meta)
 321 {
 322     ALOGV("AC3");
 323
 324     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AC3);
 325
 326     return OK;
 327 }
 328
 329 status_t setAACFormat(AVCodecContext *avctx, MetaDataBase &meta)
 330 {
 331     ALOGV("AAC");
 332
 333     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC);
 334     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 335     meta.setInt32(kKeyAACAOT, avctx->profile + 1);
 336
 337     return OK;
 338 }
 339
 340 status_t setWMAV1Format(AVCodecContext *avctx, MetaDataBase &meta)
 341 {
 342     ALOGV("WMAV1");
 343
 344     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 345     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 346     meta.setInt32(kKeyWMAVersion, kTypeWMA); //FIXME version?
 347
 348     return OK;
 349 }
 350
 351 status_t setWMAV2Format(AVCodecContext *avctx, MetaDataBase &meta)
 352 {
 353     ALOGV("WMAV2");
 354
 355     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 356     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 357     meta.setInt32(kKeyWMAVersion, kTypeWMA);
 358
 359     return OK;
 360 }
 361
 362 status_t setWMAProFormat(AVCodecContext *avctx, MetaDataBase &meta)
 363 {
 364     ALOGV("WMAPro");
 365
 366     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 367     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 368     meta.setInt32(kKeyWMAVersion, kTypeWMAPro);
 369
 370     return OK;
 371 }
 372
 373 status_t setWMALossLessFormat(AVCodecContext *avctx, MetaDataBase &meta)
 374 {
 375     ALOGV("WMALOSSLESS");
 376
 377     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_WMA);
 378     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 379     meta.setInt32(kKeyWMAVersion, kTypeWMALossLess);
 380
 381     return OK;
 382 }
 383
 384 status_t setRAFormat(AVCodecContext *avctx, MetaDataBase &meta)
 385 {
 386     ALOGV("COOK");
 387
 388     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RA);
 389     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 390
 391     return OK;
 392 }
 393
 394 status_t setALACFormat(AVCodecContext *avctx, MetaDataBase &meta)
 395 {
 396     ALOGV("ALAC");
 397
 398     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_ALAC);
 399     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 400
 401     return OK;
 402 }
 403
 404 status_t setAPEFormat(AVCodecContext *avctx, MetaDataBase &meta)
 405 {
 406     ALOGV("APE");
 407
 408     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_APE);
 409     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 410
 411     return OK;
 412 }
 413
 414 status_t setDTSFormat(AVCodecContext *avctx, MetaDataBase &meta)
 415 {
 416     ALOGV("DTS");
 417
 418     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_DTS);
 419     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 420
 421     return OK;
 422 }
 423
 424 status_t setFLACFormat(AVCodecContext *avctx, MetaDataBase &meta)
 425 {
 426     ALOGV("FLAC");
 427
 428     meta.setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC);
 429     meta.setData(kKeyRawCodecSpecificData, 0, avctx->extradata, avctx->extradata_size);
 430
 431     if (avctx->extradata_size < 10) {
 432         ALOGE("Invalid extradata in FLAC file! (size=%d)", avctx->extradata_size);
 433         return UNKNOWN_ERROR;
 434     }
 435
 436     ABitReader br(avctx->extradata, avctx->extradata_size);
 437     int32_t minBlockSize = br.getBits(16);
 438     int32_t maxBlockSize = br.getBits(16);
 439     int32_t minFrameSize = br.getBits(24);
 440     int32_t maxFrameSize = br.getBits(24);
 441
 442     meta.setInt32('mibs', minBlockSize);
 443     meta.setInt32('mabs', maxBlockSize);
 444     meta.setInt32('mifs', minFrameSize);
 445     meta.setInt32('mafs', maxFrameSize);
 446
 447     return OK;
 448 }
 449
 450 //Convert H.264 NAL format to annex b
 451 status_t convertNal2AnnexB(uint8_t *dst, size_t dst_size,
 452         uint8_t *src, size_t src_size, size_t nal_len_size)
 453 {
 454     size_t i = 0;
 455     size_t nal_len = 0;
 456     status_t status = OK;
 457
 458     CHECK_EQ(dst_size, src_size);
 459     CHECK(nal_len_size == 3 || nal_len_size == 4);
 460
 461     while (src_size >= nal_len_size) {
 462         nal_len = 0;
 463         for( i = 0; i < nal_len_size; i++ ) {
 464             nal_len = (nal_len << 8) | src[i];
 465             dst[i] = 0;
 466         }
 467         dst[nal_len_size - 1] = 1;
 468         if (nal_len > INT_MAX || nal_len > src_size) {
 469             status = ERROR_MALFORMED;
 470             break;
 471         }
 472         dst += nal_len_size;
 473         src += nal_len_size;
 474         src_size -= nal_len_size;
 475
 476         memcpy(dst, src, nal_len);
 477
 478         dst += nal_len;
 479         src += nal_len;
 480         src_size -= nal_len;
 481     }
 482
 483     return status;
 484 }
 485
 486 int getDivXVersion(AVCodecContext *avctx)
 487 {
 488     if (avctx->codec_tag == AV_RL32("DIV3")
 489             || avctx->codec_tag == AV_RL32("div3")
 490             || avctx->codec_tag == AV_RL32("DIV4")
 491             || avctx->codec_tag == AV_RL32("div4")) {
 492         return kTypeDivXVer_3_11;
 493     }
 494     if (avctx->codec_tag == AV_RL32("DIVX")
 495             || avctx->codec_tag == AV_RL32("divx")) {
 496         return kTypeDivXVer_4;
 497     }
 498     if (avctx->codec_tag == AV_RL32("DX50")
 499            || avctx->codec_tag == AV_RL32("dx50")) {
 500         return kTypeDivXVer_5;
 501     }
 502     return -1;
 503 }
 504
 505 status_t parseMetadataTags(AVFormatContext *ctx, MetaDataBase &meta) {
 506     if (ctx == NULL) {
 507         return NO_INIT;
 508     }
 509
 510     AVDictionary *dict = ctx->metadata;
 511     if (dict == NULL) {
 512         return NO_INIT;
 513     }
 514
 515     struct MetadataMapping {
 516         const char *from;
 517         int to;
 518     };
 519
 520     // avformat -> android mapping
 521     static const MetadataMapping kMap[] = {
 522         { "track", kKeyCDTrackNumber },
 523         { "disc", kKeyDiscNumber },
 524         { "album", kKeyAlbum },
 525         { "artist", kKeyArtist },
 526         { "album_artist", kKeyAlbumArtist },
 527         { "composer", kKeyComposer },
 528         { "date", kKeyDate },
 529         { "genre", kKeyGenre },
 530         { "title", kKeyTitle },
 531         { "year", kKeyYear },
 532         { "compilation", kKeyCompilation },
 533         { "location", kKeyLocation },
 534     };
 535
 536     static const size_t kNumEntries = sizeof(kMap) / sizeof(kMap[0]);
 537
 538     for (size_t i = 0; i < kNumEntries; ++i) {
 539         AVDictionaryEntry *entry = av_dict_get(dict, kMap[i].from, NULL, 0);
 540         if (entry != NULL) {
 541             ALOGV("found key %s with value %s", entry->key, entry->value);
 542             meta.setCString(kMap[i].to, entry->value);
 543         }
 544     }
 545
 546     // now look for album art- this will be in a separate stream
 547     for (size_t i = 0; i < ctx->nb_streams; i++) {
 548         if (ctx->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC) {
 549             AVPacket pkt = ctx->streams[i]->attached_pic;
 550             if (pkt.size > 0) {
 551                 if (ctx->streams[i]->codec != NULL) {
 552                     const char *mime;
 553                     if (ctx->streams[i]->codec->codec_id == AV_CODEC_ID_MJPEG) {
 554                         mime = MEDIA_MIMETYPE_IMAGE_JPEG;
 555                     } else if (ctx->streams[i]->codec->codec_id == AV_CODEC_ID_PNG) {
 556                         mime = "image/png";
 557                     } else {
 558                         mime = NULL;
 559                     }
 560                     if (mime != NULL) {
 561                         ALOGV("found albumart in stream %zu with type %s len %d", i, mime, pkt.size);
 562                         meta.setData(kKeyAlbumArt, MetaData::TYPE_NONE, pkt.data, pkt.size);
 563                         meta.setCString(kKeyAlbumArtMIME, mime);
 564                     }
 565                 }
 566             }
 567         }
 568     }
 569     return OK;
 570 }
 571
 572 AudioEncoding sampleFormatToEncoding(AVSampleFormat fmt) {
 573
 574     // we resample planar formats to interleaved
 575     switch (fmt) {
 576         case AV_SAMPLE_FMT_U8:
 577         case AV_SAMPLE_FMT_U8P:
 578             return kAudioEncodingPcm8bit;
 579         case AV_SAMPLE_FMT_S16:
 580         case AV_SAMPLE_FMT_S16P:
 581             return kAudioEncodingPcm16bit;
 582         case AV_SAMPLE_FMT_FLT:
 583         case AV_SAMPLE_FMT_FLTP:
 584             return kAudioEncodingPcmFloat;
 585         case AV_SAMPLE_FMT_DBL:
 586         case AV_SAMPLE_FMT_DBLP:
 587             return kAudioEncodingPcmFloat;
 588         default:
 589             return kAudioEncodingInvalid;
 590     }
 591
 592 }
 593
 594 AVSampleFormat encodingToSampleFormat(AudioEncoding encoding) {
 595     switch (encoding) {
 596         case kAudioEncodingPcm8bit:
 597             return AV_SAMPLE_FMT_U8;
 598         case kAudioEncodingPcm16bit:
 599             return AV_SAMPLE_FMT_S16;
 600         case kAudioEncodingPcmFloat:
 601             return AV_SAMPLE_FMT_FLT;
 602         default:
 603             return AV_SAMPLE_FMT_NONE;
 604     }
 605 }
 606
 607 }  // namespace android
 608