Home | History | Annotate | Download | only in libmedia 
      1 /*
      2  * Copyright (C) 2009 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 //#define LOG_NDEBUG 0
     18 #define LOG_TAG "Metadata"
     19 #include <utils/Log.h>
     20 
     21 #include <sys/types.h>
     22 #include <media/Metadata.h>
     23 #include <binder/Parcel.h>
     24 #include <utils/Errors.h>
     25 #include <utils/RefBase.h>
     26 
     27 // This file contains code to serialize Metadata triples (key, type,
     28 // value) into a parcel. The Parcel is destinated to be decoded by the
     29 // Metadata.java class.
     30 
     31 namespace {
     32 // All these constants below must be kept in sync with Metadata.java.
     33 enum MetadataId {
     34     FIRST_SYSTEM_ID = 1,
     35     LAST_SYSTEM_ID = 32,
     36     FIRST_CUSTOM_ID = 8192
     37 };
     38 
     39 // Types
     40 enum Types {
     41     STRING_VAL = 1,
     42     INTEGER_VAL,
     43     BOOLEAN_VAL,
     44     LONG_VAL,
     45     DOUBLE_VAL,
     46     TIMED_TEXT_VAL,
     47     DATE_VAL,
     48     BYTE_ARRAY_VAL,
     49 };
     50 
     51 const size_t kRecordHeaderSize = 3 * sizeof(int32_t);
     52 const int32_t kMetaMarker = 0x4d455441;  // 'M' 'E' 'T' 'A'
     53 
     54 }  // anonymous namespace
     55 
     56 namespace android {
     57 namespace media {
     58 
     59 Metadata::Metadata(Parcel *p)
     60     :mData(p),
     61      mBegin(p->dataPosition()) { }
     62 
     63 Metadata::~Metadata() { }
     64 
     65 void Metadata::resetParcel()
     66 {
     67     mData->setDataPosition(mBegin);
     68 }
     69 
     70 // Update the 4 bytes int at the beginning of the parcel which holds
     71 // the number of bytes written so far.
     72 void Metadata::updateLength()
     73 {
     74     const size_t end = mData->dataPosition();
     75 
     76     mData->setDataPosition(mBegin);
     77     mData->writeInt32(end - mBegin);
     78     mData->setDataPosition(end);
     79 }
     80 
     81 // Write the header. The java layer will look for the marker.
     82 bool Metadata::appendHeader()
     83 {
     84     bool ok = true;
     85 
     86     // Placeholder for the length of the metadata
     87     ok = ok && mData->writeInt32(-1) == OK;
     88     ok = ok && mData->writeInt32(kMetaMarker) == OK;
     89     return ok;
     90 }
     91 
     92 bool Metadata::appendBool(int key, bool val)
     93 {
     94     if (!checkKey(key)) {
     95         return false;
     96     }
     97 
     98     const size_t begin = mData->dataPosition();
     99     bool ok = true;
    100 
    101     // 4 int32s: size, key, type, value.
    102     ok = ok && mData->writeInt32(4 * sizeof(int32_t)) == OK;
    103     ok = ok && mData->writeInt32(key) == OK;
    104     ok = ok && mData->writeInt32(BOOLEAN_VAL) == OK;
    105     ok = ok && mData->writeInt32(val ? 1 : 0) == OK;
    106     if (!ok) {
    107         mData->setDataPosition(begin);
    108     }
    109     return ok;
    110 }
    111 
    112 bool Metadata::appendInt32(int key, int32_t val)
    113 {
    114     if (!checkKey(key)) {
    115         return false;
    116     }
    117 
    118     const size_t begin = mData->dataPosition();
    119     bool ok = true;
    120 
    121     // 4 int32s: size, key, type, value.
    122     ok = ok && mData->writeInt32(4 * sizeof(int32_t)) == OK;
    123     ok = ok && mData->writeInt32(key) == OK;
    124     ok = ok && mData->writeInt32(INTEGER_VAL) == OK;
    125     ok = ok && mData->writeInt32(val) == OK;
    126     if (!ok) {
    127         mData->setDataPosition(begin);
    128     }
    129     return ok;
    130 }
    131 
    132 // Check the key (i.e metadata id) is valid if it is a system one.
    133 // Loop over all the exiting ones in the Parcel to check for duplicate
    134 // (not allowed).
    135 bool Metadata::checkKey(int key)
    136 {
    137     if (key < FIRST_SYSTEM_ID ||
    138         (LAST_SYSTEM_ID < key && key < FIRST_CUSTOM_ID)) {
    139         LOGE("Bad key %d", key);
    140         return false;
    141     }
    142     size_t curr = mData->dataPosition();
    143     // Loop over the keys to check if it has been used already.
    144     mData->setDataPosition(mBegin);
    145 
    146     bool error = false;
    147     size_t left = curr - mBegin;
    148     while (left > 0) {
    149         size_t pos = mData->dataPosition();
    150         size_t size = mData->readInt32();
    151         if (size < kRecordHeaderSize || size > left) {
    152             error = true;
    153             break;
    154         }
    155         if (mData->readInt32() == key) {
    156             LOGE("Key exists already %d", key);
    157             error = true;
    158             break;
    159         }
    160         mData->setDataPosition(pos + size);
    161         left -= size;
    162     }
    163     mData->setDataPosition(curr);
    164     return !error;
    165 }
    166 
    167 }  // namespace android::media
    168 }  // namespace android
    169