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
16import {expect} from 'deccjsunit/index'
17import camera from '@ohos.multimedia.camera'
18import media from '@ohos.multimedia.media'
19import * as mediaTestBase from './MediaTestBase.js';
20
21const VIDEO_TRACK = 'video_track';
22const AUDIO_TRACK = 'audio_track';
23const AUDIO_VIDEO_TYPE = 'audio_video';
24const ONLYVIDEO_TYPE = 'only_video';
25const DELTA_TIME = 1500;
26const BITRATE_DELTA_TIME = 20000;
27const PLAY_TIME = 1000;
28
29
30export async function initCaptureSession(videoOutPut, cameraManager, cameraDevice, previewOutput) {
31    let cameraInput = await cameraManager.createCameraInput(cameraDevice);
32    if (cameraInput != null) {
33        console.info('[camera] case createCameraInput success');
34    } else {
35        console.info('[camera] case createCameraInput failed');
36        return;
37    }
38    await cameraInput.open((err) => {
39        if(err){
40            console.info('[camera] cameraInput open Failed');
41            return
42        }
43        console.info('[camera] cameraInput open success');
44    })
45    let captureSession = await cameraManager.createCaptureSession();
46    await captureSession.beginConfig();
47    await captureSession.addInput(cameraInput);
48    await captureSession.addOutput(previewOutput);
49    await captureSession.addOutput(videoOutPut);
50    await captureSession.commitConfig();
51    await captureSession.start();
52    return captureSession;
53}
54
55export async function stopCaptureSession(captureSession) {
56    await captureSession.stop().then(() => {
57        console.info('[camera] case captureSession stop success');
58    });
59    await captureSession.release().then(() => {
60        console.info('[camera] case captureSession release success');
61    });
62}
63
64export function getTrackArray(videoType, recorderConfigFile, sourceType) {
65    if (videoType == AUDIO_VIDEO_TYPE) {
66        let audioTrack = new Array(recorderConfigFile.audioBitrate, recorderConfigFile.audioChannels,
67                                   'audio/mp4a-latm', recorderConfigFile.audioSampleRate);
68        let videoTrack = null;
69        if (sourceType == media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES) {
70            videoTrack = new Array('video/avc', recorderConfigFile.videoFrameHeight,
71            recorderConfigFile.videoFrameWidth);
72        } else {
73            if (recorderConfigFile.videoCodec == 'video/avc') {
74                videoTrack = new Array('video/avc', recorderConfigFile.videoFrameHeight,
75                recorderConfigFile.videoFrameWidth);
76            } else {
77                videoTrack = new Array('video/mp4v-es', recorderConfigFile.videoFrameHeight,
78                recorderConfigFile.videoFrameWidth);
79            }
80        }
81        let trackArray = new Array(videoTrack, audioTrack);
82        return trackArray;
83    } else if (videoType == ONLYVIDEO_TYPE) {
84        let videoTrack = null;
85        if (sourceType == media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES) {
86            videoTrack = new Array('video/avc', recorderConfigFile.videoFrameHeight,
87            recorderConfigFile.videoFrameWidth);
88        } else {
89            if (recorderConfigFile.videoCodec == 'video/avc') {
90                videoTrack = new Array('video/avc', recorderConfigFile.videoFrameHeight,
91                recorderConfigFile.videoFrameWidth);
92            } else {
93                videoTrack = new Array('video/mp4v-es', recorderConfigFile.videoFrameHeight,
94                recorderConfigFile.videoFrameWidth);
95            }
96        }
97        let trackArray = new Array(videoTrack);
98        return trackArray;
99    } else {
100        let audioTrack = new Array(recorderConfigFile.audioEncodeBitRate, recorderConfigFile.numberOfChannels,
101            'audio/mp4a-latm', recorderConfigFile.audioSampleRate);
102        let trackArray = new Array(audioTrack);
103        return trackArray;
104    }
105}
106
107export function checkDescription(obj, trackTpye, descriptionValue) {
108    let index = 0;
109    if (trackTpye == VIDEO_TRACK) {
110        console.info('case video codec_mime is  '+ obj['codec_mime']);
111        expect(obj['codec_mime']).assertEqual(descriptionValue[index++]);
112        console.info('case video height is  '+ obj['height']);
113        expect(obj['height']).assertEqual(descriptionValue[index++]);
114        console.info('case video width is  '+ obj['width']);
115        expect(obj['width']).assertEqual(descriptionValue[index++]);
116    } else {
117        console.info('case audio bitrate is  '+ obj['bitrate']);
118        expect(obj['bitrate']/3).assertLess(descriptionValue[index++]);
119        console.info('case audio channel_count is  '+ obj['channel_count']);
120        expect(obj['channel_count']).assertEqual(descriptionValue[index++]);
121        console.info('case audio codec_mime is  '+ obj['codec_mime']);
122        expect(obj['codec_mime']).assertEqual(descriptionValue[index++]);
123        console.info('case audio sample_rate is  '+ obj['sample_rate']);
124        if (descriptionValue[index] > 48000 && obj['sample_rate'] == 48000) {
125            index++;
126        } else {
127            expect(obj['sample_rate']).assertEqual(descriptionValue[index++]);
128        }
129    }
130}
131
132export async function checkVideos(playFdPath, duration, trackArray, playerSurfaceId) {
133    let videoPlayer = null;
134    let arrayDescription = null;
135    await media.createVideoPlayer().then((video) => {
136        if (typeof (video) != 'undefined') {
137            videoPlayer = video;
138            expect(videoPlayer.state).assertEqual('idle');
139        } else {
140            console.info('case createVideoPlayer is failed');
141            expect().assertFail();
142        }
143    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
144    console.info('[checkVideos] case checkVideos fdPath is :' + playFdPath);
145
146    videoPlayer.on('error', (error) => {
147        console.info(`case error called,errMessage is ${error.message}`);
148        expect().assertFail();
149        return;
150    });
151
152    videoPlayer.url = playFdPath;
153    let tarckType = undefined;
154    if (playerSurfaceId != null) {
155        tarckType = new Array(VIDEO_TRACK, AUDIO_TRACK);
156        await videoPlayer.setDisplaySurface(playerSurfaceId).then(() => {
157            console.info('case setDisplaySurface success');
158            expect(videoPlayer.state).assertEqual('idle');
159        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
160    } else {
161        tarckType = new Array(AUDIO_TRACK);
162    }
163    await videoPlayer.prepare().then(() => {
164        expect(videoPlayer.state).assertEqual('prepared');
165        expect(Math.abs(videoPlayer.duration - duration)).assertLess(DELTA_TIME);
166        console.info('case prepare called!!');
167    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
168
169    await videoPlayer.getTrackDescription().then((arrayList) => {
170        console.info('case getTrackDescription called!!');
171        if (typeof (arrayList) != 'undefined') {
172            arrayDescription = arrayList;
173        } else {
174            console.info('case getTrackDescription is failed');
175            expect().assertFail();
176        }
177    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
178
179    await videoPlayer.release().then(() => {
180        console.info('case release called!!');
181    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
182
183    expect(arrayDescription.length).assertEqual(trackArray.length);
184    for (let i = 0; i < arrayDescription.length; i++) {
185        checkDescription(arrayDescription[i], tarckType[i], trackArray[i]);
186    }
187}