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 = 31,
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
Metadata(Parcel * p)59 Metadata::Metadata(Parcel *p)
60 :mData(p),
61 mBegin(p->dataPosition()) { }
62
~Metadata()63 Metadata::~Metadata() { }
64
resetParcel()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.
updateLength()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.
appendHeader()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
appendBool(int key,bool val)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
appendInt32(int key,int32_t val)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).
checkKey(int key)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