1// /*
2//  * Copyright (c) 2023-2023 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 <memory>
17
18#include "foundation/utils/constants.h"
19#include "gtest/gtest.h"
20#include "plugin/plugins/ffmpeg_adapter/demuxer/ffmpeg_track_meta.h"
21
22using namespace testing::ext;
23
24namespace OHOS {
25namespace Media {
26namespace Test {
27using namespace Plugin;
28using namespace Plugin::Ffmpeg;
29using namespace std;
30
31void propagateAVSampleFormats(const AVStream& avStream,
32                              const shared_ptr<AVFormatContext>& avFormatContextPtr,
33                              const shared_ptr<AVCodecContext>& avCodecContextPtr,
34                              Meta& meta)
35{
36    AVSampleFormat avSampleFormats[] = {AV_SAMPLE_FMT_NONE, AV_SAMPLE_FMT_U8};
37    for (auto avSampleFormat : avSampleFormats) {
38        avCodecContextPtr->sample_fmt = avSampleFormat;
39        ConvertAVStreamToMetaInfo(avStream, avFormatContextPtr, avCodecContextPtr, meta);
40    }
41}
42
43void propagateFrameSize(const AVStream& avStream,
44                        const shared_ptr<AVFormatContext>& avFormatContextPtr,
45                        const shared_ptr<AVCodecContext>& avCodecContextPtr,
46                        Meta& meta)
47{
48    int fameSizes[] = {0, 2073600};
49    for (auto frameSize : fameSizes) {
50        avCodecContextPtr->frame_size = frameSize;
51        avStream.codecpar->frame_size = frameSize;
52        propagateAVSampleFormats(avStream, avFormatContextPtr, avCodecContextPtr, meta);
53    }
54}
55
56void propagateChannelLayouts(const AVStream& avStream,
57                             const shared_ptr<AVFormatContext>& avFormatContextPtr,
58                             const shared_ptr<AVCodecContext>& avCodecContextPtr,
59                             Meta& meta)
60{
61    int channelLayoutsNum = 12;
62    for (int shift = 0, channelLayout = 0; shift <= channelLayoutsNum; shift++) {
63        channelLayout = channelLayout << shift;
64        avCodecContextPtr->channel_layout = channelLayout;
65        propagateFrameSize(avStream, avFormatContextPtr, avCodecContextPtr, meta);
66    }
67}
68
69void propagateChannels(const AVStream& avStream,
70                       const shared_ptr<AVFormatContext>& avFormatContextPtr,
71                       const shared_ptr<AVCodecContext>& avCodecContextPtr,
72                       Meta& meta)
73{
74    int channels[] = {0, 1, 2, 3, 4, 6, 8, 10, 12, 14, 16, 24};
75    for (auto channel : channels) {
76        avCodecContextPtr->channels = channel;
77        propagateChannelLayouts(avStream, avFormatContextPtr, avCodecContextPtr, meta);
78    }
79}
80
81void propagateBitRate(const AVStream& avStream,
82                      const shared_ptr<AVFormatContext>& avFormatContextPtr,
83                      const shared_ptr<AVCodecContext>& avCodecContextPtr,
84                      Meta& meta)
85{
86    int bitRates[] = {0, 14400};
87    for (auto bitRate : bitRates) {
88        avCodecContextPtr->bit_rate = bitRate;
89        propagateChannels(avStream, avFormatContextPtr, avCodecContextPtr, meta);
90    }
91}
92
93void propagateExtraData(const AVStream& avStream,
94                        const shared_ptr<AVFormatContext>& avFormatContextPtr,
95                        const shared_ptr<AVCodecContext>& avCodecContextPtr,
96                        Meta& meta)
97{
98    int extraDataSize = avCodecContextPtr->extradata_size;
99    avCodecContextPtr->extradata = new uint8_t[extraDataSize];
100
101    uint8_t extraDatasInValid[] = {0x2A, 0xE6};
102    for (int index = 0; index < extraDataSize; index++) {
103        avCodecContextPtr->extradata[index] = extraDatasInValid[index];
104    }
105    propagateBitRate(avStream, avFormatContextPtr, avCodecContextPtr, meta);
106
107    uint8_t extraDatasValid[] = {0x8A, 0xE6};
108    for (int index = 0; index < extraDataSize; index++) {
109        avCodecContextPtr->extradata[index] = extraDatasValid[index];
110    }
111    propagateBitRate(avStream, avFormatContextPtr, avCodecContextPtr, meta);
112
113    delete[] avCodecContextPtr->extradata;
114}
115
116HWTEST(FFmpegDemuxerTrackMetaTest, test_ffmpetrack_meta, TestSize.Level1)
117{
118    AVStream avStream;
119
120    avStream.codecpar = new AVCodecParameters();
121    avStream.codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
122
123    const shared_ptr<AVFormatContext> avFormatContextPtr = make_shared<AVFormatContext>();
124    const shared_ptr<AVCodecContext> avCodecContextPtr = make_shared<AVCodecContext>();
125    Meta meta;
126
127    AVCodecID codecIds[] = {AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_U16LE, AV_CODEC_ID_PCM_U16BE,
128        AV_CODEC_ID_PCM_S24LE, AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_S8, AV_CODEC_ID_PCM_U8, AV_CODEC_ID_MP1,
129        AV_CODEC_ID_MP2, AV_CODEC_ID_MP3, AV_CODEC_ID_AAC, AV_CODEC_ID_AAC_LATM, AV_CODEC_ID_VORBIS, AV_CODEC_ID_FLAC,
130        AV_CODEC_ID_APE};
131
132    int extraDataSizes[] = {0, 2};
133
134    for (auto codecId : codecIds) {
135        avStream.codecpar->codec_id = codecId;
136        for (auto extraDataSize : extraDataSizes) {
137            avCodecContextPtr->extradata_size = extraDataSize;
138            propagateExtraData(avStream, avFormatContextPtr, avCodecContextPtr, meta);
139        }
140    }
141
142    std::string mimeType;
143    meta.Get<Tag::MIME>(mimeType);
144
145    EXPECT_EQ(mimeType, MEDIA_MIME_AUDIO_APE);
146
147    delete avStream.codecpar;
148}
149}
150}
151}
152