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
19namespace OHOS::AVSession {
20bool 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        WriteDrmSchemes(parcel) &&
45        parcel.WriteParcelable(mediaImage_.get()) &&
46        parcel.WriteParcelable(avQueueImage_.get());
47}
48
49AVMetaData *AVMetaData::Unmarshalling(Parcel& data)
50{
51    std::string mask;
52    CHECK_AND_RETURN_RET_LOG(data.ReadString(mask) && mask.length() == META_KEY_MAX, nullptr, "mask not valid");
53    CHECK_AND_RETURN_RET_LOG(mask.find_first_not_of("01") == std::string::npos, nullptr, "mask string not 0 or 1");
54    auto *result = new (std::nothrow) AVMetaData();
55    CHECK_AND_RETURN_RET_LOG(result != nullptr, nullptr, "new AVMetaData failed");
56    result->metaMask_ = MetaMaskType(mask);
57
58    if (!UnmarshallingCheckParamTask(data, result)) {
59        delete result;
60        result = nullptr;
61        return nullptr;
62    }
63    if (!UnmarshallingCheckImageTask(data, result)) {
64        delete result;
65        result = nullptr;
66        return nullptr;
67    }
68    return result;
69}
70
71bool AVMetaData::UnmarshallingCheckParamTask(Parcel& data, AVMetaData *result)
72{
73    bool isParamUnsupport = (!data.ReadString(result->assetId_) ||
74        !data.ReadString(result->title_) ||
75        !data.ReadString(result->artist_) ||
76        !data.ReadString(result->author_) ||
77        !data.ReadString(result->avQueueName_) ||
78        !data.ReadString(result->avQueueId_) ||
79        !data.ReadString(result->avQueueImageUri_) ||
80        !data.ReadString(result->album_) ||
81        !data.ReadString(result->writer_) ||
82        !data.ReadString(result->composer_) ||
83        !data.ReadInt64(result->duration_) ||
84        !data.ReadString(result->mediaImageUri_) ||
85        !data.ReadDouble(result->publishDate_) ||
86        !data.ReadString(result->subTitle_) ||
87        !data.ReadString(result->description_) ||
88        !data.ReadString(result->lyric_) ||
89        !data.ReadString(result->previousAssetId_) ||
90        !data.ReadString(result->nextAssetId_) ||
91        !data.ReadInt32(result->skipIntervals_) ||
92        !data.ReadInt32(result->filter_) ||
93        !data.ReadInt32(result->displayTags_) ||
94        !ReadDrmSchemes(data, result));
95    if (isParamUnsupport)  {
96        SLOGE("read AVMetaData failed");
97        return false;
98    }
99    return true;
100}
101
102bool AVMetaData::UnmarshallingCheckImageTask(Parcel& data, AVMetaData *result)
103{
104    result->mediaImage_ = std::shared_ptr<AVSessionPixelMap>(data.ReadParcelable<AVSessionPixelMap>());
105    if (result->metaMask_.test(META_KEY_MEDIA_IMAGE) && result->mediaImage_ == nullptr) {
106        SLOGE("read PixelMap failed");
107        return false;
108    }
109    result->avQueueImage_ = std::shared_ptr<AVSessionPixelMap>(data.ReadParcelable<AVSessionPixelMap>());
110    if (result->metaMask_.test(META_KEY_AVQUEUE_IMAGE) && result->avQueueImage_ == nullptr) {
111        SLOGE("read avqueue PixelMap failed");
112        return false;
113    }
114    return true;
115}
116
117bool AVMetaData::MarshallingExceptImg(MessageParcel& data, const AVMetaData metaIn)
118{
119    bool ret = data.WriteString(metaIn.metaMask_.to_string()) &&
120        data.WriteString(metaIn.assetId_) &&
121        data.WriteString(metaIn.title_) &&
122        data.WriteString(metaIn.artist_) &&
123        data.WriteString(metaIn.author_) &&
124        data.WriteString(metaIn.avQueueName_) &&
125        data.WriteString(metaIn.avQueueId_) &&
126        data.WriteString(metaIn.avQueueImageUri_) &&
127        data.WriteString(metaIn.album_) &&
128        data.WriteString(metaIn.writer_) &&
129        data.WriteString(metaIn.composer_) &&
130        data.WriteInt64(metaIn.duration_) &&
131        data.WriteString(metaIn.mediaImageUri_) &&
132        data.WriteDouble(metaIn.publishDate_) &&
133        data.WriteString(metaIn.subTitle_) &&
134        data.WriteString(metaIn.description_) &&
135        data.WriteString(metaIn.lyric_) &&
136        data.WriteString(metaIn.previousAssetId_) &&
137        data.WriteString(metaIn.nextAssetId_) &&
138        data.WriteInt32(metaIn.skipIntervals_) &&
139        data.WriteInt32(metaIn.filter_) &&
140        data.WriteInt32(metaIn.mediaLength_) &&
141        data.WriteInt32(metaIn.avQueueLength_) &&
142        data.WriteInt32(metaIn.displayTags_) &&
143        WriteDrmSchemes(data, metaIn);
144    SLOGD("MarshallingExceptImg without small img ret %{public}d", static_cast<int>(ret));
145    return ret;
146}
147
148bool AVMetaData::UnmarshallingExceptImg(MessageParcel& data, AVMetaData& metaOut)
149{
150    std::string mask;
151    data.ReadString(mask);
152    int32_t maskSize = static_cast<int32_t>(mask.size());
153    if (maskSize <= 0 || maskSize > META_KEY_MAX) {
154        SLOGE("get err mask, return");
155        return false;
156    }
157    SLOGD("get mask with %{public}s", mask.c_str());
158    for (int32_t i = 0; i < maskSize; ++i) {
159        if (mask[i] == '1') {
160            metaOut.metaMask_.flip(maskSize - i - 1);
161        }
162    }
163
164    bool ret = !data.ReadString(metaOut.assetId_) ||
165        !data.ReadString(metaOut.title_) ||
166        !data.ReadString(metaOut.artist_) ||
167        !data.ReadString(metaOut.author_) ||
168        !data.ReadString(metaOut.avQueueName_) ||
169        !data.ReadString(metaOut.avQueueId_) ||
170        !data.ReadString(metaOut.avQueueImageUri_) ||
171        !data.ReadString(metaOut.album_) ||
172        !data.ReadString(metaOut.writer_) ||
173        !data.ReadString(metaOut.composer_) ||
174        !data.ReadInt64(metaOut.duration_) ||
175        !data.ReadString(metaOut.mediaImageUri_) ||
176        !data.ReadDouble(metaOut.publishDate_) ||
177        !data.ReadString(metaOut.subTitle_) ||
178        !data.ReadString(metaOut.description_) ||
179        !data.ReadString(metaOut.lyric_) ||
180        !data.ReadString(metaOut.previousAssetId_) ||
181        !data.ReadString(metaOut.nextAssetId_) ||
182        !data.ReadInt32(metaOut.skipIntervals_) ||
183        !data.ReadInt32(metaOut.filter_) ||
184        !data.ReadInt32(metaOut.mediaLength_) ||
185        !data.ReadInt32(metaOut.avQueueLength_) ||
186        !data.ReadInt32(metaOut.displayTags_) ||
187        !ReadDrmSchemes(data, metaOut);
188    SLOGD("UnmarshallingExceptImg with drm but no small img ret %{public}d", static_cast<int>(ret));
189    return ret;
190}
191
192bool AVMetaData::WriteDrmSchemes(Parcel& parcel) const
193{
194    CHECK_AND_RETURN_RET_LOG(parcel.WriteInt32(drmSchemes_.size()), false,
195        "write drmSchemes size failed");
196    for (auto drmScheme : drmSchemes_) {
197        CHECK_AND_RETURN_RET_LOG(parcel.WriteString(drmScheme), false, "write drmScheme failed");
198    }
199    return true;
200}
201
202bool AVMetaData::WriteDrmSchemes(MessageParcel& parcel, const AVMetaData metaData)
203{
204    CHECK_AND_RETURN_RET_LOG(parcel.WriteInt32(metaData.drmSchemes_.size()), false,
205        "write drmSchemes size failed");
206    for (auto drmScheme : metaData.drmSchemes_) {
207        CHECK_AND_RETURN_RET_LOG(parcel.WriteString(drmScheme), false, "write drmScheme failed");
208    }
209    return true;
210}
211
212bool AVMetaData::ReadDrmSchemes(Parcel& parcel, AVMetaData *metaData)
213{
214    int32_t drmSchemesLen = 0;
215    CHECK_AND_RETURN_RET_LOG(parcel.ReadInt32(drmSchemesLen), false, "read drmSchemesLen failed");
216    std::vector<std::string> drmSchemes;
217    int32_t maxDrmSchemesLen = 10;
218    CHECK_AND_RETURN_RET_LOG((drmSchemesLen >= 0) &&
219        (drmSchemesLen <= maxDrmSchemesLen), false, "drmSchemesLen is illegal");
220    for (int i = 0; i < drmSchemesLen; i++) {
221        std::string drmScheme;
222        CHECK_AND_RETURN_RET_LOG(parcel.ReadString(drmScheme), false, "read drmScheme failed");
223        drmSchemes.emplace_back(drmScheme);
224    }
225    metaData->drmSchemes_ = drmSchemes;
226    return true;
227}
228
229bool AVMetaData::ReadDrmSchemes(MessageParcel& parcel, AVMetaData& metaData)
230{
231    int32_t drmSchemesLen = 0;
232    CHECK_AND_RETURN_RET_LOG(parcel.ReadInt32(drmSchemesLen), false, "read drmSchemesLen failed");
233    std::vector<std::string> drmSchemes;
234    int32_t maxDrmSchemesLen = 10;
235    CHECK_AND_RETURN_RET_LOG((drmSchemesLen >= 0) &&
236        (drmSchemesLen <= maxDrmSchemesLen), false, "drmSchemesLen is illegal");
237    for (int i = 0; i < drmSchemesLen; i++) {
238        std::string drmScheme;
239        CHECK_AND_RETURN_RET_LOG(parcel.ReadString(drmScheme), false, "read drmScheme failed");
240        drmSchemes.emplace_back(drmScheme);
241    }
242    metaData.drmSchemes_ = drmSchemes;
243    return true;
244}
245
246void AVMetaData::SetAssetId(const std::string& assetId)
247{
248    assetId_ = assetId;
249    metaMask_.set(META_KEY_ASSET_ID);
250}
251
252std::string AVMetaData::GetAssetId() const
253{
254    return assetId_;
255}
256
257void AVMetaData::SetTitle(const std::string& title)
258{
259    title_ = title;
260    metaMask_.set(META_KEY_TITLE);
261}
262
263std::string AVMetaData::GetTitle() const
264{
265    return title_;
266}
267
268void AVMetaData::SetArtist(const std::string& artist)
269{
270    artist_ = artist;
271    metaMask_.set(META_KEY_ARTIST);
272}
273
274std::string AVMetaData::GetArtist() const
275{
276    return artist_;
277}
278
279void AVMetaData::SetAuthor(const std::string& author)
280{
281    author_ = author;
282    metaMask_.set(META_KEY_AUTHOR);
283}
284
285std::string AVMetaData::GetAuthor() const
286{
287    return author_;
288}
289
290void AVMetaData::SetAVQueueName(const std::string& avQueueName)
291{
292    avQueueName_ = avQueueName;
293    metaMask_.set(META_KEY_AVQUEUE_NAME);
294}
295
296std::string AVMetaData::GetAVQueueName() const
297{
298    return avQueueName_;
299}
300
301void AVMetaData::SetAVQueueId(const std::string& avQueueId)
302{
303    avQueueId_ = avQueueId;
304    metaMask_.set(META_KEY_AVQUEUE_ID);
305}
306
307std::string AVMetaData::GetAVQueueId() const
308{
309    return avQueueId_;
310}
311
312void AVMetaData::SetAVQueueImage(const std::shared_ptr<AVSessionPixelMap>& avQueueImage)
313{
314    avQueueImage_ = avQueueImage;
315    metaMask_.set(META_KEY_AVQUEUE_IMAGE);
316}
317
318std::shared_ptr<AVSessionPixelMap> AVMetaData::GetAVQueueImage() const
319{
320    return avQueueImage_;
321}
322
323void AVMetaData::SetAVQueueImageUri(const std::string& avQueueImageUri)
324{
325    avQueueImageUri_ = avQueueImageUri;
326    metaMask_.set(META_KEY_AVQUEUE_IMAGE_URI);
327}
328
329std::string AVMetaData::GetAVQueueImageUri() const
330{
331    return avQueueImageUri_;
332}
333
334void AVMetaData::SetAlbum(const std::string& album)
335{
336    album_ = album;
337    metaMask_.set(META_KEY_ALBUM);
338}
339
340std::string AVMetaData::GetAlbum() const
341{
342    return album_;
343}
344
345void AVMetaData::SetWriter(const std::string& writer)
346{
347    writer_ = writer;
348    metaMask_.set(META_KEY_WRITER);
349}
350
351std::string AVMetaData::GetWriter() const
352{
353    return writer_;
354}
355
356void AVMetaData::SetComposer(const std::string& composer)
357{
358    composer_ = composer;
359    metaMask_.set(META_KEY_COMPOSER);
360}
361
362std::string AVMetaData::GetComposer() const
363{
364    return composer_;
365}
366
367void AVMetaData::SetDuration(int64_t duration)
368{
369    if (duration < AVMetaData::DURATION_ALWAYS_PLAY) {
370        SLOGW("invalid duration");
371    }
372    duration_ = duration;
373    metaMask_.set(META_KEY_DURATION);
374}
375
376int64_t AVMetaData::GetDuration() const
377{
378    return duration_;
379}
380
381void AVMetaData::SetMediaImage(const std::shared_ptr<AVSessionPixelMap>& mediaImage)
382{
383    mediaImage_ = mediaImage;
384    metaMask_.set(META_KEY_MEDIA_IMAGE);
385}
386
387std::shared_ptr<AVSessionPixelMap> AVMetaData::GetMediaImage() const
388{
389    return mediaImage_;
390}
391
392void AVMetaData::SetMediaImageUri(const std::string& mediaImageUri)
393{
394    mediaImageUri_ = mediaImageUri;
395    metaMask_.set(META_KEY_MEDIA_IMAGE_URI);
396}
397
398std::string AVMetaData::GetMediaImageUri() const
399{
400    return mediaImageUri_;
401}
402
403void AVMetaData::SetPublishDate(double date)
404{
405    if (date < 0) {
406        SLOGW("invalid publish date");
407    }
408    publishDate_ = date;
409    metaMask_.set(META_KEY_PUBLISH_DATE);
410}
411
412double AVMetaData::GetPublishDate() const
413{
414    return publishDate_;
415}
416
417void AVMetaData::SetSubTitle(const std::string& subTitle)
418{
419    subTitle_ = subTitle;
420    metaMask_.set(META_KEY_SUBTITLE);
421}
422
423std::string AVMetaData::GetSubTitle() const
424{
425    return subTitle_;
426}
427
428void AVMetaData::SetDescription(const std::string& description)
429{
430    description_ = description;
431    metaMask_.set(META_KEY_DESCRIPTION);
432}
433
434std::string AVMetaData::GetDescription() const
435{
436    return description_;
437}
438
439void AVMetaData::SetLyric(const std::string& lyric)
440{
441    lyric_ = lyric;
442    metaMask_.set(META_KEY_LYRIC);
443}
444
445std::string AVMetaData::GetLyric() const
446{
447    return lyric_;
448}
449
450void AVMetaData::SetPreviousAssetId(const std::string& assetId)
451{
452    previousAssetId_ = assetId;
453    metaMask_.set(META_KEY_PREVIOUS_ASSET_ID);
454}
455
456std::string AVMetaData::GetPreviousAssetId() const
457{
458    return previousAssetId_;
459}
460
461void AVMetaData::SetNextAssetId(const std::string& assetId)
462{
463    nextAssetId_ = assetId;
464    metaMask_.set(META_KEY_NEXT_ASSET_ID);
465}
466
467std::string AVMetaData::GetNextAssetId() const
468{
469    return nextAssetId_;
470}
471
472void AVMetaData::SetSkipIntervals(int32_t skipIntervals)
473{
474    SLOGD("SetSkipIntervals %{public}d", static_cast<int32_t>(skipIntervals));
475    skipIntervals_ = skipIntervals;
476    metaMask_.set(META_KEY_SKIP_INTERVALS);
477}
478
479int32_t AVMetaData::GetSkipIntervals() const
480{
481    SLOGD("GetSkipIntervals %{public}d", static_cast<int32_t>(skipIntervals_));
482    return skipIntervals_;
483}
484
485void AVMetaData::SetFilter(int32_t filter)
486{
487    SLOGD("SetFilter %{public}d", static_cast<int32_t>(filter));
488    filter_ = filter;
489    metaMask_.set(META_KEY_FILTER);
490}
491
492int32_t AVMetaData::GetFilter() const
493{
494    SLOGD("GetFilter %{public}d", static_cast<int32_t>(filter_));
495    return filter_;
496}
497
498void AVMetaData::SetMediaLength(int32_t mediaLength)
499{
500    mediaLength_ = mediaLength;
501}
502
503int32_t AVMetaData::GetMediaLength() const
504{
505    return mediaLength_;
506}
507
508void AVMetaData::SetAVQueueLength(int32_t avQueueLength)
509{
510    avQueueLength_ = avQueueLength;
511}
512
513int32_t AVMetaData::GetAVQueueLength() const
514{
515    return avQueueLength_;
516}
517
518void AVMetaData::SetDisplayTags(int32_t displayTags)
519{
520    SLOGD("SetDisplayTags %{public}d", static_cast<int32_t>(displayTags));
521    displayTags_ = displayTags;
522    metaMask_.set(META_KEY_DISPLAY_TAGS);
523}
524
525int32_t AVMetaData::GetDisplayTags() const
526{
527    SLOGD("GetDisplayTags %{public}d", static_cast<int32_t>(displayTags_));
528    return displayTags_;
529}
530
531void AVMetaData::SetDrmSchemes(std::vector<std::string> drmSchemes)
532{
533    drmSchemes_ = drmSchemes;
534    metaMask_.set(META_KEY_DRM_SCHEMES);
535}
536
537std::vector<std::string> AVMetaData::GetDrmSchemes() const
538{
539    return drmSchemes_;
540}
541
542AVMetaData::MetaMaskType AVMetaData::GetMetaMask() const
543{
544    return metaMask_;
545}
546
547void AVMetaData::Reset()
548{
549    metaMask_.reset();
550    assetId_ = "";
551    title_ = "";
552    artist_ = "";
553    author_ = "";
554    avQueueName_ = "";
555    avQueueId_ = "";
556    avQueueImage_ = nullptr;
557    avQueueImageUri_ = "";
558    album_ = "";
559    writer_ = "";
560    composer_ = "";
561    duration_ = 0;
562    mediaImage_ = nullptr;
563    mediaImageUri_ = "";
564    publishDate_ = 0;
565    subTitle_ = "";
566    description_ = "";
567    lyric_ = "";
568    previousAssetId_ = "";
569    nextAssetId_ = "";
570    skipIntervals_ = SECONDS_15;
571    displayTags_ = 0;
572    drmSchemes_.clear();
573}
574
575bool AVMetaData::CopyToByMask(MetaMaskType& mask, AVMetaData& metaOut) const
576{
577    bool result = false;
578    auto intersection = metaMask_ & mask;
579    for (int i = 0; i < META_KEY_MAX; i++) {
580        if (intersection.test(i)) {
581            cloneActions[i](*this, metaOut);
582            metaOut.metaMask_.set(i);
583            result = true;
584        }
585    }
586
587    return result;
588}
589
590bool AVMetaData::CopyFrom(const AVMetaData& metaIn)
591{
592    if (metaIn.assetId_.empty()) {
593        SLOGE("assetId is empty");
594        return false;
595    }
596
597    if (metaIn.assetId_ != assetId_) {
598        SLOGE("assetId not equal here");
599        *this = metaIn;
600        return true;
601    }
602
603    bool result = false;
604    for (int i = 0; i < META_KEY_MAX; i++) {
605        if (metaIn.metaMask_.test(i)) {
606            cloneActions[i](metaIn, *this);
607            metaMask_.set(i);
608            result = true;
609        }
610    }
611
612    return result;
613}
614
615bool AVMetaData::EqualWithUri(const AVMetaData& metaData)
616{
617    if (metaData.mediaImage_ != nullptr) {
618        SLOGI("Current fun cannot determine whether mediaImage_ is equal,\
619            not perform subsequent judgments when mediaImage_ is not null.");
620        return false;
621    }
622
623    return (assetId_ == metaData.assetId_)
624        && (title_ == metaData.title_)
625        && (artist_ == metaData.artist_)
626        && (author_ == metaData.author_)
627        && (avQueueName_ == metaData.avQueueName_)
628        && (avQueueId_ == metaData.avQueueId_)
629        && (avQueueImageUri_ == metaData.avQueueImageUri_)
630        && (album_ == metaData.album_)
631        && (writer_ == metaData.writer_)
632        && (composer_ == metaData.composer_)
633        && (duration_ == metaData.duration_)
634        && (mediaImageUri_ == metaData.mediaImageUri_)
635        && (publishDate_ == metaData.publishDate_)
636        && (subTitle_ == metaData.subTitle_)
637        && (description_ == metaData.description_)
638        && (lyric_ == metaData.lyric_)
639        && (previousAssetId_ == metaData.previousAssetId_)
640        && (nextAssetId_ == metaData.nextAssetId_)
641        && (skipIntervals_ == metaData.skipIntervals_)
642        && (filter_ == metaData.filter_)
643        && (displayTags_ == metaData.displayTags_)
644        && (drmSchemes_ == metaData.drmSchemes_);
645}
646
647bool AVMetaData::IsValid() const
648{
649    return duration_ >= AVMetaData::DURATION_ALWAYS_PLAY && publishDate_ >= 0
650        && displayTags_ <= AVMetaData::DISPLAY_TAG_ALL;
651}
652
653void AVMetaData::CloneAssetId(const AVMetaData& from, AVMetaData& to)
654{
655    to.assetId_ = from.assetId_;
656}
657
658void AVMetaData::CloneTitle(const AVMetaData& from, AVMetaData& to)
659{
660    to.title_ = from.title_;
661}
662
663void AVMetaData::CloneArtist(const AVMetaData& from, AVMetaData& to)
664{
665    to.artist_ = from.artist_;
666}
667
668void AVMetaData::CloneAuthor(const AVMetaData& from, AVMetaData& to)
669{
670    to.author_ = from.author_;
671}
672
673void AVMetaData::CloneAVQueueName(const AVMetaData& from, AVMetaData& to)
674{
675    to.avQueueName_ = from.avQueueName_;
676}
677
678void AVMetaData::CloneAVQueueId(const AVMetaData& from, AVMetaData& to)
679{
680    to.avQueueId_ = from.avQueueId_;
681}
682
683void AVMetaData::CloneAVQueueImage(const AVMetaData& from, AVMetaData& to)
684{
685    to.avQueueImage_ = from.avQueueImage_;
686}
687
688void AVMetaData::CloneAVQueueImageUri(const AVMetaData& from, AVMetaData& to)
689{
690    to.avQueueImageUri_ = from.avQueueImageUri_;
691}
692
693void AVMetaData::CloneAlbum(const AVMetaData& from, AVMetaData& to)
694{
695    to.album_ = from.album_;
696}
697
698void AVMetaData::CloneWriter(const AVMetaData& from, AVMetaData& to)
699{
700    to.writer_ = from.writer_;
701}
702
703void AVMetaData::CloneComposer(const AVMetaData& from, AVMetaData& to)
704{
705    to.composer_ = from.composer_;
706}
707
708void AVMetaData::CloneDuration(const AVMetaData& from, AVMetaData& to)
709{
710    to.duration_ = from.duration_;
711}
712
713void AVMetaData::CloneMediaImage(const AVMetaData& from, AVMetaData& to)
714{
715    to.mediaImage_ = from.mediaImage_;
716}
717
718void AVMetaData::CloneMediaImageUri(const AVMetaData& from, AVMetaData& to)
719{
720    to.mediaImageUri_ = from.mediaImageUri_;
721}
722
723void AVMetaData::ClonePublishData(const AVMetaData& from, AVMetaData& to)
724{
725    to.publishDate_ = from.publishDate_;
726}
727
728void AVMetaData::CloneSubTitle(const AVMetaData& from, AVMetaData& to)
729{
730    to.subTitle_ = from.subTitle_;
731}
732
733void AVMetaData::CloneDescription(const AVMetaData& from, AVMetaData& to)
734{
735    to.description_ = from.description_;
736}
737
738void AVMetaData::CloneLyric(const AVMetaData& from, AVMetaData& to)
739{
740    to.lyric_ = from.lyric_;
741}
742
743void AVMetaData::ClonePreviousAssetId(const AVMetaData& from, AVMetaData& to)
744{
745    to.previousAssetId_ = from.previousAssetId_;
746}
747
748void AVMetaData::CloneNextAssetId(const AVMetaData& from, AVMetaData& to)
749{
750    to.nextAssetId_ = from.nextAssetId_;
751}
752
753void AVMetaData::CloneSkipIntervals(const AVMetaData& from, AVMetaData& to)
754{
755    to.skipIntervals_ = from.skipIntervals_;
756}
757
758void AVMetaData::CloneFilter(const AVMetaData& from, AVMetaData& to)
759{
760    to.filter_ = from.filter_;
761}
762
763void AVMetaData::CloneDisplayTags(const AVMetaData& from, AVMetaData& to)
764{
765    to.displayTags_ = from.displayTags_;
766}
767
768void AVMetaData::CloneDrmSchemes(const AVMetaData& from, AVMetaData& to)
769{
770    to.drmSchemes_ = from.drmSchemes_;
771}
772} // namespace OHOS::AVSession
773