1 /*
2 * Copyright (c) 2022 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 "avmeta_data.h"
17 #include "avsession_log.h"
18
19 namespace OHOS::AVSession {
Marshalling(Parcel & parcel) const20 bool AVMetaData::Marshalling(Parcel& parcel) const
21 {
22 return parcel.WriteString(metaMask_.to_string()) &&
23 parcel.WriteString(assetId_) &&
24 parcel.WriteString(title_) &&
25 parcel.WriteString(artist_) &&
26 parcel.WriteString(author_) &&
27 parcel.WriteString(avQueueName_) &&
28 parcel.WriteString(avQueueId_) &&
29 parcel.WriteString(avQueueImageUri_) &&
30 parcel.WriteString(album_) &&
31 parcel.WriteString(writer_) &&
32 parcel.WriteString(composer_) &&
33 parcel.WriteInt64(duration_) &&
34 parcel.WriteString(mediaImageUri_) &&
35 parcel.WriteDouble(publishDate_) &&
36 parcel.WriteString(subTitle_) &&
37 parcel.WriteString(description_) &&
38 parcel.WriteString(lyric_) &&
39 parcel.WriteString(previousAssetId_) &&
40 parcel.WriteString(nextAssetId_) &&
41 parcel.WriteInt32(skipIntervals_) &&
42 parcel.WriteInt32(filter_) &&
43 parcel.WriteInt32(displayTags_) &&
44 parcel.WriteParcelable(mediaImage_.get()) &&
45 parcel.WriteParcelable(avQueueImage_.get());
46 }
47
Unmarshalling(Parcel & data)48 AVMetaData *AVMetaData::Unmarshalling(Parcel& data)
49 {
50 std::string mask;
51 CHECK_AND_RETURN_RET_LOG(data.ReadString(mask) && mask.length() == META_KEY_MAX, nullptr, "mask not valid");
52 CHECK_AND_RETURN_RET_LOG(mask.find_first_not_of("01") == std::string::npos, nullptr, "mask string not 0 or 1");
53 auto *result = new (std::nothrow) AVMetaData();
54 CHECK_AND_RETURN_RET_LOG(result != nullptr, nullptr, "new AVMetaData failed");
55 result->metaMask_ = MetaMaskType(mask);
56 if (!UnmarshallingCheckParamTask(data, result)) {
57 delete result;
58 return nullptr;
59 }
60 if (!UnmarshallingCheckImageTask(data, result)) {
61 delete result;
62 return nullptr;
63 }
64 return result;
65 }
66
UnmarshallingCheckParamTask(Parcel & data,AVMetaData * result)67 bool AVMetaData::UnmarshallingCheckParamTask(Parcel& data, AVMetaData *result)
68 {
69 bool isParamSupport = (!data.ReadString(result->assetId_) ||
70 !data.ReadString(result->title_) ||
71 !data.ReadString(result->artist_) ||
72 !data.ReadString(result->author_) ||
73 !data.ReadString(result->avQueueName_) ||
74 !data.ReadString(result->avQueueId_) ||
75 !data.ReadString(result->avQueueImageUri_) ||
76 !data.ReadString(result->album_) ||
77 !data.ReadString(result->writer_) ||
78 !data.ReadString(result->composer_) ||
79 !data.ReadInt64(result->duration_) ||
80 !data.ReadString(result->mediaImageUri_) ||
81 !data.ReadDouble(result->publishDate_) ||
82 !data.ReadString(result->subTitle_) ||
83 !data.ReadString(result->description_) ||
84 !data.ReadString(result->lyric_) ||
85 !data.ReadString(result->previousAssetId_) ||
86 !data.ReadString(result->nextAssetId_) ||
87 !data.ReadInt32(result->skipIntervals_) ||
88 !data.ReadInt32(result->filter_) ||
89 !data.ReadInt32(result->displayTags_));
90 if (isParamSupport) {
91 SLOGE("read AVMetaData failed");
92 return false;
93 }
94 return true;
95 }
96
UnmarshallingCheckImageTask(Parcel & data,AVMetaData * result)97 bool AVMetaData::UnmarshallingCheckImageTask(Parcel& data, AVMetaData *result)
98 {
99 result->mediaImage_ = std::shared_ptr<AVSessionPixelMap>(data.ReadParcelable<AVSessionPixelMap>());
100 if (result->metaMask_.test(META_KEY_MEDIA_IMAGE) && result->mediaImage_ == nullptr) {
101 SLOGE("read PixelMap failed");
102 return false;
103 }
104 result->avQueueImage_ = std::shared_ptr<AVSessionPixelMap>(data.ReadParcelable<AVSessionPixelMap>());
105 if (result->metaMask_.test(META_KEY_AVQUEUE_IMAGE) && result->avQueueImage_ == nullptr) {
106 SLOGE("read PixelMap failed");
107 return false;
108 }
109 return true;
110 }
111
MarshallingExceptImg(MessageParcel & data,const AVMetaData metaIn)112 bool AVMetaData::MarshallingExceptImg(MessageParcel& data, const AVMetaData metaIn)
113 {
114 return data.WriteString(metaIn.metaMask_.to_string()) &&
115 data.WriteString(metaIn.assetId_) &&
116 data.WriteString(metaIn.title_) &&
117 data.WriteString(metaIn.artist_) &&
118 data.WriteString(metaIn.author_) &&
119 data.WriteString(metaIn.avQueueName_) &&
120 data.WriteString(metaIn.avQueueId_) &&
121 data.WriteString(metaIn.avQueueImageUri_) &&
122 data.WriteString(metaIn.album_) &&
123 data.WriteString(metaIn.writer_) &&
124 data.WriteString(metaIn.composer_) &&
125 data.WriteInt64(metaIn.duration_) &&
126 data.WriteString(metaIn.mediaImageUri_) &&
127 data.WriteDouble(metaIn.publishDate_) &&
128 data.WriteString(metaIn.subTitle_) &&
129 data.WriteString(metaIn.description_) &&
130 data.WriteString(metaIn.lyric_) &&
131 data.WriteString(metaIn.previousAssetId_) &&
132 data.WriteString(metaIn.nextAssetId_) &&
133 data.WriteInt32(metaIn.skipIntervals_) &&
134 data.WriteInt32(metaIn.filter_) &&
135 data.WriteInt32(metaIn.mediaLength_) &&
136 data.WriteInt32(metaIn.avQueueLength_) &&
137 data.WriteInt32(metaIn.displayTags_);
138 }
139
UnmarshallingExceptImg(MessageParcel & data,AVMetaData & metaOut)140 bool AVMetaData::UnmarshallingExceptImg(MessageParcel& data, AVMetaData& metaOut)
141 {
142 std::string mask;
143 data.ReadString(mask);
144 int32_t maskSize = static_cast<int32_t>(mask.size());
145 if (maskSize <= 0 || maskSize > META_KEY_MAX) {
146 SLOGE("get err mask, return");
147 return false;
148 }
149 SLOGI("get mask with %{public}s", mask.c_str());
150 for (int32_t i = 0; i < maskSize; ++i) {
151 if (mask[i] == '1') {
152 metaOut.metaMask_.flip(maskSize - i - 1);
153 }
154 }
155
156 return !data.ReadString(metaOut.assetId_) ||
157 !data.ReadString(metaOut.title_) ||
158 !data.ReadString(metaOut.artist_) ||
159 !data.ReadString(metaOut.author_) ||
160 !data.ReadString(metaOut.avQueueName_) ||
161 !data.ReadString(metaOut.avQueueId_) ||
162 !data.ReadString(metaOut.avQueueImageUri_) ||
163 !data.ReadString(metaOut.album_) ||
164 !data.ReadString(metaOut.writer_) ||
165 !data.ReadString(metaOut.composer_) ||
166 !data.ReadInt64(metaOut.duration_) ||
167 !data.ReadString(metaOut.mediaImageUri_) ||
168 !data.ReadDouble(metaOut.publishDate_) ||
169 !data.ReadString(metaOut.subTitle_) ||
170 !data.ReadString(metaOut.description_) ||
171 !data.ReadString(metaOut.lyric_) ||
172 !data.ReadString(metaOut.previousAssetId_) ||
173 !data.ReadString(metaOut.nextAssetId_) ||
174 !data.ReadInt32(metaOut.skipIntervals_) ||
175 !data.ReadInt32(metaOut.filter_) ||
176 !data.ReadInt32(metaOut.mediaLength_) ||
177 !data.ReadInt32(metaOut.avQueueLength_) ||
178 !data.ReadInt32(metaOut.displayTags_);
179 }
180
SetAssetId(const std::string & assetId)181 void AVMetaData::SetAssetId(const std::string& assetId)
182 {
183 assetId_ = assetId;
184 metaMask_.set(META_KEY_ASSET_ID);
185 }
186
GetAssetId() const187 std::string AVMetaData::GetAssetId() const
188 {
189 return assetId_;
190 }
191
SetTitle(const std::string & title)192 void AVMetaData::SetTitle(const std::string& title)
193 {
194 title_ = title;
195 metaMask_.set(META_KEY_TITLE);
196 }
197
GetTitle() const198 std::string AVMetaData::GetTitle() const
199 {
200 return title_;
201 }
202
SetArtist(const std::string & artist)203 void AVMetaData::SetArtist(const std::string& artist)
204 {
205 artist_ = artist;
206 metaMask_.set(META_KEY_ARTIST);
207 }
208
GetArtist() const209 std::string AVMetaData::GetArtist() const
210 {
211 return artist_;
212 }
213
SetAuthor(const std::string & author)214 void AVMetaData::SetAuthor(const std::string& author)
215 {
216 author_ = author;
217 metaMask_.set(META_KEY_AUTHOR);
218 }
219
GetAuthor() const220 std::string AVMetaData::GetAuthor() const
221 {
222 return author_;
223 }
224
SetAVQueueName(const std::string & avQueueName)225 void AVMetaData::SetAVQueueName(const std::string& avQueueName)
226 {
227 avQueueName_ = avQueueName;
228 metaMask_.set(META_KEY_AVQUEUE_NAME);
229 }
230
GetAVQueueName() const231 std::string AVMetaData::GetAVQueueName() const
232 {
233 return avQueueName_;
234 }
235
SetAVQueueId(const std::string & avQueueId)236 void AVMetaData::SetAVQueueId(const std::string& avQueueId)
237 {
238 avQueueId_ = avQueueId;
239 metaMask_.set(META_KEY_AVQUEUE_ID);
240 }
241
GetAVQueueId() const242 std::string AVMetaData::GetAVQueueId() const
243 {
244 return avQueueId_;
245 }
246
SetAVQueueImage(const std::shared_ptr<AVSessionPixelMap> & avQueueImage)247 void AVMetaData::SetAVQueueImage(const std::shared_ptr<AVSessionPixelMap>& avQueueImage)
248 {
249 avQueueImage_ = avQueueImage;
250 metaMask_.set(META_KEY_AVQUEUE_IMAGE);
251 }
252
GetAVQueueImage() const253 std::shared_ptr<AVSessionPixelMap> AVMetaData::GetAVQueueImage() const
254 {
255 return avQueueImage_;
256 }
257
SetAVQueueImageUri(const std::string & avQueueImageUri)258 void AVMetaData::SetAVQueueImageUri(const std::string& avQueueImageUri)
259 {
260 avQueueImageUri_ = avQueueImageUri;
261 metaMask_.set(META_KEY_AVQUEUE_IMAGE_URI);
262 }
263
GetAVQueueImageUri() const264 std::string AVMetaData::GetAVQueueImageUri() const
265 {
266 return avQueueImageUri_;
267 }
268
SetAlbum(const std::string & album)269 void AVMetaData::SetAlbum(const std::string& album)
270 {
271 album_ = album;
272 metaMask_.set(META_KEY_ALBUM);
273 }
274
GetAlbum() const275 std::string AVMetaData::GetAlbum() const
276 {
277 return album_;
278 }
279
SetWriter(const std::string & writer)280 void AVMetaData::SetWriter(const std::string& writer)
281 {
282 writer_ = writer;
283 metaMask_.set(META_KEY_WRITER);
284 }
285
GetWriter() const286 std::string AVMetaData::GetWriter() const
287 {
288 return writer_;
289 }
290
SetComposer(const std::string & composer)291 void AVMetaData::SetComposer(const std::string& composer)
292 {
293 composer_ = composer;
294 metaMask_.set(META_KEY_COMPOSER);
295 }
296
GetComposer() const297 std::string AVMetaData::GetComposer() const
298 {
299 return composer_;
300 }
301
SetDuration(int64_t duration)302 void AVMetaData::SetDuration(int64_t duration)
303 {
304 if (duration < AVMetaData::DURATION_ALWAYS_PLAY) {
305 SLOGW("invalid duration");
306 }
307 duration_ = duration;
308 metaMask_.set(META_KEY_DURATION);
309 }
310
GetDuration() const311 int64_t AVMetaData::GetDuration() const
312 {
313 return duration_;
314 }
315
SetMediaImage(const std::shared_ptr<AVSessionPixelMap> & mediaImage)316 void AVMetaData::SetMediaImage(const std::shared_ptr<AVSessionPixelMap>& mediaImage)
317 {
318 mediaImage_ = mediaImage;
319 metaMask_.set(META_KEY_MEDIA_IMAGE);
320 }
321
GetMediaImage() const322 std::shared_ptr<AVSessionPixelMap> AVMetaData::GetMediaImage() const
323 {
324 return mediaImage_;
325 }
326
SetMediaImageUri(const std::string & mediaImageUri)327 void AVMetaData::SetMediaImageUri(const std::string& mediaImageUri)
328 {
329 mediaImageUri_ = mediaImageUri;
330 metaMask_.set(META_KEY_MEDIA_IMAGE_URI);
331 }
332
GetMediaImageUri() const333 std::string AVMetaData::GetMediaImageUri() const
334 {
335 return mediaImageUri_;
336 }
337
SetPublishDate(double date)338 void AVMetaData::SetPublishDate(double date)
339 {
340 if (date < 0) {
341 SLOGW("invalid publish date");
342 }
343 publishDate_ = date;
344 metaMask_.set(META_KEY_PUBLISH_DATE);
345 }
346
GetPublishDate() const347 double AVMetaData::GetPublishDate() const
348 {
349 return publishDate_;
350 }
351
SetSubTitle(const std::string & subTitle)352 void AVMetaData::SetSubTitle(const std::string& subTitle)
353 {
354 subTitle_ = subTitle;
355 metaMask_.set(META_KEY_SUBTITLE);
356 }
357
GetSubTitle() const358 std::string AVMetaData::GetSubTitle() const
359 {
360 return subTitle_;
361 }
362
SetDescription(const std::string & description)363 void AVMetaData::SetDescription(const std::string& description)
364 {
365 description_ = description;
366 metaMask_.set(META_KEY_DESCRIPTION);
367 }
368
GetDescription() const369 std::string AVMetaData::GetDescription() const
370 {
371 return description_;
372 }
373
SetLyric(const std::string & lyric)374 void AVMetaData::SetLyric(const std::string& lyric)
375 {
376 lyric_ = lyric;
377 metaMask_.set(META_KEY_LYRIC);
378 }
379
GetLyric() const380 std::string AVMetaData::GetLyric() const
381 {
382 return lyric_;
383 }
384
SetPreviousAssetId(const std::string & assetId)385 void AVMetaData::SetPreviousAssetId(const std::string& assetId)
386 {
387 previousAssetId_ = assetId;
388 metaMask_.set(META_KEY_PREVIOUS_ASSET_ID);
389 }
390
GetPreviousAssetId() const391 std::string AVMetaData::GetPreviousAssetId() const
392 {
393 return previousAssetId_;
394 }
395
SetNextAssetId(const std::string & assetId)396 void AVMetaData::SetNextAssetId(const std::string& assetId)
397 {
398 nextAssetId_ = assetId;
399 metaMask_.set(META_KEY_NEXT_ASSET_ID);
400 }
401
GetNextAssetId() const402 std::string AVMetaData::GetNextAssetId() const
403 {
404 return nextAssetId_;
405 }
406
SetSkipIntervals(int32_t skipIntervals)407 void AVMetaData::SetSkipIntervals(int32_t skipIntervals)
408 {
409 SLOGD("SetSkipIntervals %{public}d", static_cast<int32_t>(skipIntervals));
410 skipIntervals_ = skipIntervals;
411 metaMask_.set(META_KEY_SKIP_INTERVALS);
412 }
413
GetSkipIntervals() const414 int32_t AVMetaData::GetSkipIntervals() const
415 {
416 SLOGD("GetSkipIntervals %{public}d", static_cast<int32_t>(skipIntervals_));
417 return skipIntervals_;
418 }
419
SetFilter(int32_t filter)420 void AVMetaData::SetFilter(int32_t filter)
421 {
422 SLOGD("SetFilter %{public}d", static_cast<int32_t>(filter));
423 filter_ = filter;
424 metaMask_.set(META_KEY_FILTER);
425 }
426
GetFilter() const427 int32_t AVMetaData::GetFilter() const
428 {
429 SLOGD("GetFilter %{public}d", static_cast<int32_t>(filter_));
430 return filter_;
431 }
432
SetMediaLength(int32_t mediaLength)433 void AVMetaData::SetMediaLength(int32_t mediaLength)
434 {
435 mediaLength_ = mediaLength;
436 }
437
GetMediaLength() const438 int32_t AVMetaData::GetMediaLength() const
439 {
440 return mediaLength_;
441 }
442
SetAVQueueLength(int32_t avQueueLength)443 void AVMetaData::SetAVQueueLength(int32_t avQueueLength)
444 {
445 avQueueLength_ = avQueueLength;
446 }
447
GetAVQueueLength() const448 int32_t AVMetaData::GetAVQueueLength() const
449 {
450 return avQueueLength_;
451 }
452
SetDisplayTags(int32_t displayTags)453 void AVMetaData::SetDisplayTags(int32_t displayTags)
454 {
455 SLOGD("SetDisplayTags %{public}d", static_cast<int32_t>(displayTags));
456 displayTags_ = displayTags;
457 metaMask_.set(META_KEY_DISPLAY_TAGS);
458 }
459
GetDisplayTags() const460 int32_t AVMetaData::GetDisplayTags() const
461 {
462 SLOGD("GetDisplayTags %{public}d", static_cast<int32_t>(displayTags_));
463 return displayTags_;
464 }
465
GetMetaMask() const466 AVMetaData::MetaMaskType AVMetaData::GetMetaMask() const
467 {
468 return metaMask_;
469 }
470
Reset()471 void AVMetaData::Reset()
472 {
473 metaMask_.reset();
474 assetId_ = "";
475 title_ = "";
476 artist_ = "";
477 author_ = "";
478 avQueueName_ = "";
479 avQueueId_ = "";
480 avQueueImage_ = nullptr;
481 avQueueImageUri_ = "";
482 album_ = "";
483 writer_ = "";
484 composer_ = "";
485 duration_ = 0;
486 mediaImage_ = nullptr;
487 mediaImageUri_ = "";
488 publishDate_ = 0;
489 subTitle_ = "";
490 description_ = "";
491 lyric_ = "";
492 previousAssetId_ = "";
493 nextAssetId_ = "";
494 displayTags_ = 0;
495 }
496
CopyToByMask(MetaMaskType & mask,AVMetaData & metaOut) const497 bool AVMetaData::CopyToByMask(MetaMaskType& mask, AVMetaData& metaOut) const
498 {
499 bool result = false;
500 auto intersection = metaMask_ & mask;
501 for (int i = 0; i < META_KEY_MAX; i++) {
502 if (intersection.test(i)) {
503 cloneActions[i](*this, metaOut);
504 metaOut.metaMask_.set(i);
505 result = true;
506 }
507 }
508
509 return result;
510 }
511
CopyFrom(const AVMetaData & metaIn)512 bool AVMetaData::CopyFrom(const AVMetaData& metaIn)
513 {
514 if (metaIn.assetId_.empty()) {
515 SLOGE("assetId is empty");
516 return false;
517 }
518
519 if (metaIn.assetId_ != assetId_) {
520 SLOGD("assetId not equal");
521 *this = metaIn;
522 return true;
523 }
524
525 bool result = false;
526 for (int i = 0; i < META_KEY_MAX; i++) {
527 if (metaIn.metaMask_.test(i)) {
528 cloneActions[i](metaIn, *this);
529 metaMask_.set(i);
530 result = true;
531 }
532 }
533
534 return result;
535 }
536
IsValid() const537 bool AVMetaData::IsValid() const
538 {
539 return duration_ >= AVMetaData::DURATION_ALWAYS_PLAY && publishDate_ >= 0
540 && displayTags_ <= AVMetaData::DISPLAY_TAG_ALL;
541 }
542
CloneAssetId(const AVMetaData & from,AVMetaData & to)543 void AVMetaData::CloneAssetId(const AVMetaData& from, AVMetaData& to)
544 {
545 to.assetId_ = from.assetId_;
546 }
547
CloneTitle(const AVMetaData & from,AVMetaData & to)548 void AVMetaData::CloneTitle(const AVMetaData& from, AVMetaData& to)
549 {
550 to.title_ = from.title_;
551 }
552
CloneArtist(const AVMetaData & from,AVMetaData & to)553 void AVMetaData::CloneArtist(const AVMetaData& from, AVMetaData& to)
554 {
555 to.artist_ = from.artist_;
556 }
557
CloneAuthor(const AVMetaData & from,AVMetaData & to)558 void AVMetaData::CloneAuthor(const AVMetaData& from, AVMetaData& to)
559 {
560 to.author_ = from.author_;
561 }
562
CloneAVQueueName(const AVMetaData & from,AVMetaData & to)563 void AVMetaData::CloneAVQueueName(const AVMetaData& from, AVMetaData& to)
564 {
565 to.avQueueName_ = from.avQueueName_;
566 }
567
CloneAVQueueId(const AVMetaData & from,AVMetaData & to)568 void AVMetaData::CloneAVQueueId(const AVMetaData& from, AVMetaData& to)
569 {
570 to.avQueueId_ = from.avQueueId_;
571 }
572
CloneAVQueueImage(const AVMetaData & from,AVMetaData & to)573 void AVMetaData::CloneAVQueueImage(const AVMetaData& from, AVMetaData& to)
574 {
575 to.avQueueImage_ = from.avQueueImage_;
576 }
577
CloneAVQueueImageUri(const AVMetaData & from,AVMetaData & to)578 void AVMetaData::CloneAVQueueImageUri(const AVMetaData& from, AVMetaData& to)
579 {
580 to.avQueueImageUri_ = from.avQueueImageUri_;
581 }
582
CloneAlbum(const AVMetaData & from,AVMetaData & to)583 void AVMetaData::CloneAlbum(const AVMetaData& from, AVMetaData& to)
584 {
585 to.album_ = from.album_;
586 }
587
CloneWriter(const AVMetaData & from,AVMetaData & to)588 void AVMetaData::CloneWriter(const AVMetaData& from, AVMetaData& to)
589 {
590 to.writer_ = from.writer_;
591 }
592
CloneComposer(const AVMetaData & from,AVMetaData & to)593 void AVMetaData::CloneComposer(const AVMetaData& from, AVMetaData& to)
594 {
595 to.composer_ = from.composer_;
596 }
597
CloneDuration(const AVMetaData & from,AVMetaData & to)598 void AVMetaData::CloneDuration(const AVMetaData& from, AVMetaData& to)
599 {
600 to.duration_ = from.duration_;
601 }
602
CloneMediaImage(const AVMetaData & from,AVMetaData & to)603 void AVMetaData::CloneMediaImage(const AVMetaData& from, AVMetaData& to)
604 {
605 to.mediaImage_ = from.mediaImage_;
606 }
607
CloneMediaImageUri(const AVMetaData & from,AVMetaData & to)608 void AVMetaData::CloneMediaImageUri(const AVMetaData& from, AVMetaData& to)
609 {
610 to.mediaImageUri_ = from.mediaImageUri_;
611 }
612
ClonePublishData(const AVMetaData & from,AVMetaData & to)613 void AVMetaData::ClonePublishData(const AVMetaData& from, AVMetaData& to)
614 {
615 to.publishDate_ = from.publishDate_;
616 }
617
CloneSubTitle(const AVMetaData & from,AVMetaData & to)618 void AVMetaData::CloneSubTitle(const AVMetaData& from, AVMetaData& to)
619 {
620 to.subTitle_ = from.subTitle_;
621 }
622
CloneDescription(const AVMetaData & from,AVMetaData & to)623 void AVMetaData::CloneDescription(const AVMetaData& from, AVMetaData& to)
624 {
625 to.description_ = from.description_;
626 }
627
CloneLyric(const AVMetaData & from,AVMetaData & to)628 void AVMetaData::CloneLyric(const AVMetaData& from, AVMetaData& to)
629 {
630 to.lyric_ = from.lyric_;
631 }
632
ClonePreviousAssetId(const AVMetaData & from,AVMetaData & to)633 void AVMetaData::ClonePreviousAssetId(const AVMetaData& from, AVMetaData& to)
634 {
635 to.previousAssetId_ = from.previousAssetId_;
636 }
637
CloneNextAssetId(const AVMetaData & from,AVMetaData & to)638 void AVMetaData::CloneNextAssetId(const AVMetaData& from, AVMetaData& to)
639 {
640 to.nextAssetId_ = from.nextAssetId_;
641 }
642
CloneSkipIntervals(const AVMetaData & from,AVMetaData & to)643 void AVMetaData::CloneSkipIntervals(const AVMetaData& from, AVMetaData& to)
644 {
645 to.skipIntervals_ = from.skipIntervals_;
646 }
647
CloneFilter(const AVMetaData & from,AVMetaData & to)648 void AVMetaData::CloneFilter(const AVMetaData& from, AVMetaData& to)
649 {
650 to.filter_ = from.filter_;
651 }
652
CloneDisplayTags(const AVMetaData & from,AVMetaData & to)653 void AVMetaData::CloneDisplayTags(const AVMetaData& from, AVMetaData& to)
654 {
655 to.displayTags_ = from.displayTags_;
656 }
657 } // namespace OHOS::AVSession
658