1 /*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "box/item_info_box.h"
17
18 namespace OHOS {
19 namespace ImagePlugin {
ParseContent(HeifStreamReader & reader)20 heif_error HeifIinfBox::ParseContent(HeifStreamReader &reader)
21 {
22 ParseFullHeader(reader);
23 uint8_t boxVersion = GetVersion();
24 uint32_t entryCount = (boxVersion == HEIF_BOX_VERSION_ZERO) ? reader.Read16() : reader.Read32();
25 if (entryCount == 0) {
26 return heif_error_ok;
27 }
28 return ReadChildren(reader);
29 }
30
InferFullBoxVersion()31 void HeifIinfBox::InferFullBoxVersion()
32 {
33 SetVersion(children_.size() > 0xFFFF ? HEIF_BOX_VERSION_ONE : HEIF_BOX_VERSION_ZERO);
34 }
35
Write(HeifStreamWriter & writer) const36 heif_error HeifIinfBox::Write(HeifStreamWriter &writer) const
37 {
38 size_t boxStart = ReserveHeader(writer);
39 uint8_t boxVersion = GetVersion();
40 writer.Write(boxVersion > HEIF_BOX_VERSION_ZERO ? UINT32_BYTES_NUM : UINT16_BYTES_NUM, children_.size());
41 heif_error err = WriteChildren(writer);
42 WriteCalculatedHeader(writer, boxStart);
43 return err;
44 }
45
ParseContent(HeifStreamReader & reader)46 heif_error HeifInfeBox::ParseContent(HeifStreamReader &reader)
47 {
48 ParseFullHeader(reader);
49
50 uint8_t boxVersion = GetVersion();
51 if (boxVersion <= HEIF_BOX_VERSION_ONE) {
52 itemId_ = reader.Read16();
53 itemProtectionIndex_ = reader.Read16();
54 itemName_ = reader.ReadString();
55 contentType_ = reader.ReadString();
56 contentEncoding_ = reader.ReadString();
57 } else if (boxVersion >= HEIF_BOX_VERSION_TWO) {
58 isHidden_ = (GetFlags() & 0x01);
59 itemId_ = boxVersion == HEIF_BOX_VERSION_TWO ? reader.Read16() : reader.Read32();
60 itemProtectionIndex_ = reader.Read16();
61 uint32_t itemType = reader.Read32();
62 if (itemType != 0) {
63 itemType_ = code_to_fourcc(itemType);
64 }
65 itemName_ = reader.ReadString();
66 if (itemType == ITEM_TYPE_MIME) {
67 contentType_ = reader.ReadString();
68 contentEncoding_ = reader.ReadString();
69 } else if (itemType == ITEM_TYPE_URI) {
70 itemUriType_ = reader.ReadString();
71 }
72 }
73
74 return reader.GetError();
75 }
76
InferFullBoxVersion()77 void HeifInfeBox::InferFullBoxVersion()
78 {
79 uint8_t version = GetVersion();
80 if (isHidden_ || !itemType_.empty()) {
81 version = std::max(version, (uint8_t)HEIF_BOX_VERSION_TWO);
82 }
83 if (itemId_ > 0xFFFF) {
84 version = std::max(version, (uint8_t)HEIF_BOX_VERSION_THREE);
85 }
86 SetVersion(version);
87 }
88
SetHidden(bool hidden)89 void HeifInfeBox::SetHidden(bool hidden)
90 {
91 isHidden_ = hidden;
92 SetFlags(isHidden_ ? (GetFlags() | 0x01) : (GetFlags() & ~(0x00000001)));
93 }
94
Write(HeifStreamWriter & writer) const95 heif_error HeifInfeBox::Write(HeifStreamWriter &writer) const
96 {
97 size_t boxStart = ReserveHeader(writer);
98
99 uint8_t boxVersion = GetVersion();
100 if (boxVersion <= HEIF_BOX_VERSION_ONE) {
101 writer.Write16(itemId_);
102 writer.Write16(itemProtectionIndex_);
103
104 writer.Write(itemName_);
105 writer.Write(contentType_);
106 writer.Write(contentEncoding_);
107 }
108
109 if (boxVersion >= HEIF_BOX_VERSION_TWO) {
110 if (boxVersion == HEIF_BOX_VERSION_TWO) {
111 writer.Write16(itemId_);
112 } else if (boxVersion == HEIF_BOX_VERSION_THREE) {
113 writer.Write32(itemId_);
114 }
115
116 writer.Write16(itemProtectionIndex_);
117
118 if (itemType_.empty()) {
119 writer.Write32(0);
120 } else {
121 writer.Write32(fourcc_to_code(itemType_.c_str()));
122 }
123
124 writer.Write(itemName_);
125 if (itemType_ == "mime") {
126 writer.Write(contentType_);
127 writer.Write(contentEncoding_);
128 } else if (itemType_ == "uri ") {
129 writer.Write(itemUriType_);
130 }
131 }
132
133 WriteCalculatedHeader(writer, boxStart);
134 return heif_error_ok;
135 }
136
ParseContent(HeifStreamReader & reader)137 heif_error HeifPtimBox::ParseContent(HeifStreamReader &reader)
138 {
139 ParseFullHeader(reader);
140 uint8_t boxVersion = GetVersion();
141 itemId_ = boxVersion == HEIF_BOX_VERSION_ZERO ? reader.Read16() : reader.Read32();
142 return reader.GetError();
143 }
144
InferFullBoxVersion()145 void HeifPtimBox::InferFullBoxVersion()
146 {
147 SetVersion(itemId_ <= 0xFFFF ? HEIF_BOX_VERSION_ZERO : HEIF_BOX_VERSION_ONE);
148 }
149
Write(HeifStreamWriter & writer) const150 heif_error HeifPtimBox::Write(HeifStreamWriter &writer) const
151 {
152 size_t boxStart = ReserveHeader(writer);
153
154 if (GetVersion() == HEIF_BOX_VERSION_ZERO) {
155 writer.Write16(itemId_);
156 } else {
157 writer.Write32(itemId_);
158 }
159
160 WriteCalculatedHeader(writer, boxStart);
161 return heif_error_ok;
162 }
163 } // namespace ImagePlugin
164 } // namespace OHOS
165