458 lines
15 KiB
C++
458 lines
15 KiB
C++
#define LOG_TAG "AmlMpTest"
|
|
#include "AmlMpTest.h"
|
|
#include <utils/AmlMpLog.h>
|
|
#include <utils/AmlMpUtils.h>
|
|
#include "TestUrlList.h"
|
|
#include "../amlMpTestSupporter/TestModule.h"
|
|
#include <AmlMpTestSupporter.h>
|
|
#include <pthread.h>
|
|
#include <getopt.h>
|
|
#include "source/Source.h"
|
|
#include <Aml_MP/Aml_MP.h>
|
|
#include "string.h"
|
|
#include "../../player/Aml_MP_PlayerImpl.h"
|
|
|
|
using namespace aml_mp;
|
|
|
|
void AmlMpBase::videoDecoding(const std::string & url, bool mStart, bool mSourceReceiver)
|
|
{
|
|
MLOGI("----------VideoDecodingTest START----------\n");
|
|
createMpTestSupporter();
|
|
mpTestSupporter->setDataSource(url);
|
|
mpTestSupporter->prepare();
|
|
sptr<ProgramInfo> mProgramInfo = mpTestSupporter->getProgramInfo();
|
|
if (mProgramInfo == nullptr)
|
|
{
|
|
printf("Format for this stream is not ts.");
|
|
return;
|
|
}
|
|
mProgramInfo->scrambled=true;
|
|
mPlayMode = AmlMpTestSupporter::START_VIDEO_START_AUDIO;
|
|
mpTestSupporter->startPlay(mPlayMode, mStart, mSourceReceiver);
|
|
void *player = getPlayer();
|
|
//set videoParams
|
|
Aml_MP_VideoParams videoParams;
|
|
memset(&videoParams, 0, sizeof(videoParams));
|
|
videoParams.videoCodec = mProgramInfo->videoCodec;
|
|
videoParams.pid = mProgramInfo->videoPid;
|
|
EXPECT_EQ(Aml_MP_Player_SetVideoParams(player, &videoParams), AML_MP_OK);
|
|
//start decoding
|
|
EXPECT_EQ(Aml_MP_Player_StartVideoDecoding(player), AML_MP_OK);
|
|
if (!mSourceReceiver) {
|
|
waitPlaying(1 * 1000ll);
|
|
}else {
|
|
EXPECT_FALSE(waitPlaying(1 * 1000ll));
|
|
EXPECT_FALSE(waitPlayingErrors());
|
|
}
|
|
//stop decoding
|
|
EXPECT_EQ(Aml_MP_Player_StopVideoDecoding(player), AML_MP_OK);
|
|
stopPlaying();
|
|
MLOGI("----------VideoDecodingTest END----------\n");
|
|
}
|
|
|
|
void AmlMpBase::audioDecoding(const std::string & url, bool mStart, bool mSourceReceiver)
|
|
{
|
|
MLOGI("----------AudioDecodingTest START----------\n");
|
|
createMpTestSupporter();
|
|
mpTestSupporter->setDataSource(url);
|
|
mpTestSupporter->prepare();
|
|
sptr<ProgramInfo> mProgramInfo = mpTestSupporter->getProgramInfo();
|
|
if (mProgramInfo == nullptr)
|
|
{
|
|
printf("Format for this stream is not ts.");
|
|
return;
|
|
}
|
|
mProgramInfo->scrambled=true;
|
|
mPlayMode = AmlMpTestSupporter::START_AUDIO_START_VIDEO;
|
|
mpTestSupporter->startPlay(mPlayMode, mStart, mSourceReceiver);
|
|
void *player = getPlayer();
|
|
//set audioParams
|
|
Aml_MP_AudioParams audioParams;
|
|
memset(&audioParams, 0, sizeof(audioParams));
|
|
audioParams.audioCodec = mProgramInfo->audioCodec;
|
|
audioParams.pid = mProgramInfo->audioPid;
|
|
EXPECT_EQ(Aml_MP_Player_SetAudioParams(player, &audioParams), AML_MP_OK);
|
|
//start decoding
|
|
EXPECT_EQ(Aml_MP_Player_StartAudioDecoding(player), AML_MP_OK);
|
|
if (!mSourceReceiver) {
|
|
waitPlaying(1 * 1000ll);
|
|
}else {
|
|
EXPECT_FALSE(waitPlaying(1 * 1000ll));
|
|
}
|
|
//stop decoding
|
|
EXPECT_EQ(Aml_MP_Player_StopAudioDecoding(player), AML_MP_OK);
|
|
stopPlaying();
|
|
MLOGI("----------AudioDecodingTest END----------\n");
|
|
}
|
|
|
|
void AmlMpBase::FCCAndPIPTest(const std::string & url, bool mPIP)
|
|
{
|
|
MLOGI("----------FCCAndPIPTest START----------\n");
|
|
#ifdef ANDROID
|
|
createMpTestSupporter();
|
|
char demuxInfo[30];
|
|
sprintf(demuxInfo, "?demuxid=%d&sourceid=%d", 1, 0);
|
|
std::string finalUrl = url + demuxInfo;
|
|
mpTestSupporter->setDataSource(finalUrl);
|
|
mpTestSupporter->prepare();
|
|
sptr<ProgramInfo> mProgramInfo = mpTestSupporter->getProgramInfo();
|
|
if (mProgramInfo == nullptr)
|
|
{
|
|
printf("Format for this stream is not ts.");
|
|
return;
|
|
}
|
|
mProgramInfo->scrambled=true;
|
|
if (mPIP) {
|
|
AmlMpTestSupporter::DisplayParam displayParam;
|
|
displayParam.x = AML_MP_VIDEO_WINDOW_X;
|
|
displayParam.y = AML_MP_VIDEO_WINDOW_Y;
|
|
displayParam.width = AML_MP_VIDEO_WINDOW_WIDTH;
|
|
displayParam.height = AML_MP_VIDEO_WINDOW_HEIGHT;
|
|
displayParam.zorder = AML_MP_VIDEO_WINDOW_ZORDER_1;
|
|
displayParam.videoMode = AML_MP_VIDEO_MODE_1;
|
|
mpTestSupporter->setDisplayParam(displayParam);
|
|
}
|
|
mProgramInfo->videoPid = 640;
|
|
mProgramInfo->audioPid = 641;
|
|
mpTestSupporter->mChannelId = AML_MP_CHANNEL_ID_MAIN;
|
|
mpTestSupporter->startPlay();
|
|
//void *player = getPlayer();
|
|
if (mPIP) {
|
|
EXPECT_FALSE(waitPlayingErrors());
|
|
}
|
|
|
|
createMpTestSupporter2();
|
|
sprintf(demuxInfo, "?demuxid=%d&sourceid=%d", 0, 0);
|
|
finalUrl = url + demuxInfo;
|
|
mpTestSupporter2->setDataSource(finalUrl);
|
|
mpTestSupporter2->prepare();
|
|
sptr<ProgramInfo> mProgramInfo2 = mpTestSupporter2->getProgramInfo();
|
|
if (mProgramInfo2 == nullptr)
|
|
{
|
|
printf("Format for this stream is not ts.");
|
|
return;
|
|
}
|
|
mProgramInfo2->videoPid = 620;
|
|
mProgramInfo2->audioPid = 621;
|
|
mpTestSupporter2->mChannelId = AML_MP_CHANNEL_ID_PIP;
|
|
if (!mPIP) {
|
|
mpTestSupporter2->mWorkMode = AML_MP_PLAYER_MODE_CACHING_ONLY;
|
|
}
|
|
mpTestSupporter2->startPlay();
|
|
if (mPIP) {
|
|
EXPECT_FALSE(waitPlayingErrors());
|
|
} else {
|
|
waitPlaying();
|
|
}
|
|
if (!mPIP) {
|
|
//cache->no surface
|
|
mWorkMode = AML_MP_PLAYER_MODE_CACHING_ONLY;
|
|
mpTestSupporter->setWindow(false);
|
|
mpTestSupporter->setParameter(AML_MP_PLAYER_PARAMETER_WORK_MODE, &mWorkMode);
|
|
//normal->surface
|
|
mWorkMode = AML_MP_PLAYER_MODE_NORMAL;
|
|
mpTestSupporter2->setParameter(AML_MP_PLAYER_PARAMETER_WORK_MODE, &mWorkMode);
|
|
mpTestSupporter2->setWindow();
|
|
waitPlaying(2 * 1000ll);
|
|
EXPECT_FALSE(waitPlayingErrors());
|
|
}
|
|
stopPlaying();
|
|
#endif
|
|
MLOGI("----------FCCAndPIPTest END----------\n");
|
|
}
|
|
|
|
TEST_F(AmlMpTest, PlayerStartStopTest)
|
|
{
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
MLOGI("----------PlayerStartTest START----------\n");
|
|
createMpTestSupporter();
|
|
mpTestSupporter->setDataSource(url);
|
|
mpTestSupporter->prepare();
|
|
sptr<ProgramInfo> mProgramInfo = mpTestSupporter->getProgramInfo();
|
|
if (mProgramInfo == nullptr)
|
|
{
|
|
printf("Format for this stream is not ts.");
|
|
continue;
|
|
}
|
|
mProgramInfo->scrambled=true;
|
|
mpTestSupporter->startPlay();
|
|
void *player = getPlayer();
|
|
EXPECT_EQ(Aml_MP_Player_Start(player), -2);
|
|
EXPECT_FALSE(waitPlayingErrors());
|
|
EXPECT_EQ(Aml_MP_Player_Stop(player), AML_MP_OK);
|
|
stopPlaying();
|
|
MLOGI("----------PlayerStartTest END----------\n");
|
|
}
|
|
}
|
|
|
|
TEST_F(AmlMpTest, VideoDecodingTest)
|
|
{
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
videoDecoding(url, false, false);
|
|
}
|
|
}
|
|
|
|
TEST_F(AmlMpTest, VideoDecodingTest1)
|
|
{
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
videoDecoding(url, false, true);
|
|
}
|
|
}
|
|
|
|
TEST_F(AmlMpTest, AudioDecodingTest)
|
|
{
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
audioDecoding(url, false, false);
|
|
}
|
|
}
|
|
|
|
TEST_F(AmlMpTest, AudioDecodingTest1)
|
|
{
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
audioDecoding(url, false, true);
|
|
}
|
|
}
|
|
|
|
TEST_F(AmlMpTest, SubtitleDecodingTest)
|
|
{
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
MLOGI("----------SubtitleDecodingTest START----------\n");
|
|
createMpTestSupporter();
|
|
mpTestSupporter->setDataSource(url);
|
|
mpTestSupporter->prepare();
|
|
sptr<ProgramInfo> mProgramInfo = mpTestSupporter->getProgramInfo();
|
|
if (mProgramInfo == nullptr)
|
|
{
|
|
printf("Format for this stream is not ts.");
|
|
continue;
|
|
}
|
|
mProgramInfo->scrambled=true;
|
|
mPlayMode = AmlMpTestSupporter::START_ALL_STOP_ALL;
|
|
mpTestSupporter->startPlay(mPlayMode, false);
|
|
void *player = getPlayer();
|
|
//set subtitleParams
|
|
Aml_MP_SubtitleParams subtitleParams{};
|
|
subtitleParams.subtitleCodec = mProgramInfo->subtitleCodec;
|
|
switch (subtitleParams.subtitleCodec) {
|
|
case AML_MP_SUBTITLE_CODEC_DVB:
|
|
subtitleParams.pid = mProgramInfo->subtitlePid;
|
|
subtitleParams.compositionPageId = mProgramInfo->compositionPageId;
|
|
subtitleParams.ancillaryPageId = mProgramInfo->ancillaryPageId;
|
|
break;
|
|
case AML_MP_SUBTITLE_CODEC_TELETEXT:
|
|
subtitleParams.pid = mProgramInfo->subtitlePid;
|
|
break;
|
|
case AML_MP_SUBTITLE_CODEC_SCTE27:
|
|
subtitleParams.pid = mProgramInfo->subtitlePid;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
EXPECT_EQ(Aml_MP_Player_SetSubtitleParams(player, &subtitleParams), AML_MP_OK);
|
|
//start decoding
|
|
EXPECT_EQ(Aml_MP_Player_StartSubtitleDecoding(player), AML_MP_OK);
|
|
waitPlaying(1 * 1000ll);
|
|
//stop decoding
|
|
EXPECT_EQ(Aml_MP_Player_StopSubtitleDecoding(player), AML_MP_OK);
|
|
stopPlaying();
|
|
MLOGI("----------SubtitleDecodingTest END----------\n");
|
|
}
|
|
}
|
|
|
|
TEST_F(AmlMpTest, PauseResumeTest)
|
|
{
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
MLOGI("----------PauseResumeTest START----------\n");
|
|
createMpTestSupporter();
|
|
mpTestSupporter->setDataSource(url);
|
|
mpTestSupporter->prepare();
|
|
sptr<ProgramInfo> mProgramInfo = mpTestSupporter->getProgramInfo();
|
|
if (mProgramInfo == nullptr)
|
|
{
|
|
printf("Format for this stream is not ts.");
|
|
continue;
|
|
}
|
|
mProgramInfo->scrambled=true;
|
|
mpTestSupporter->startPlay();
|
|
void *player = getPlayer();
|
|
EXPECT_FALSE(waitPlayingErrors(5 * 1000ll));
|
|
EXPECT_EQ(Aml_MP_Player_Pause(player), AML_MP_OK);
|
|
EXPECT_FALSE(waitPlaying(2 * 1000ll));
|
|
//check pause
|
|
std::string frame_before = get_frame_count_checkpoint();
|
|
EXPECT_FALSE(waitPlaying(5 * 1000ll));
|
|
std::string frame_after = get_frame_count_checkpoint();
|
|
EXPECT_EQ(frame_before, frame_after);
|
|
EXPECT_EQ(Aml_MP_Player_Resume(player), AML_MP_OK);
|
|
//check resume
|
|
EXPECT_FALSE(waitPlayingErrors());
|
|
stopPlaying();
|
|
MLOGI("----------PauseResumeTest END----------\n");
|
|
}
|
|
}
|
|
|
|
TEST_F(AmlMpTest, FlushTest)
|
|
{
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
MLOGI("----------FlushTest START----------\n");
|
|
createMpTestSupporter();
|
|
mpTestSupporter->setDataSource(url);
|
|
mpTestSupporter->prepare();
|
|
sptr<ProgramInfo> mProgramInfo = mpTestSupporter->getProgramInfo();
|
|
if (mProgramInfo == nullptr)
|
|
{
|
|
printf("Format for this stream is not ts.");
|
|
continue;
|
|
}
|
|
mProgramInfo->scrambled=true;
|
|
mpTestSupporter->startPlay();
|
|
void *player = getPlayer();
|
|
EXPECT_EQ(Aml_MP_Player_Flush(player), AML_MP_OK);
|
|
EXPECT_FALSE(waitPlayingErrors(5 * 1000ll));
|
|
stopPlaying();
|
|
MLOGI("----------FlushTest END----------\n");
|
|
}
|
|
}
|
|
|
|
TEST_F(AmlMpTest, PlaybackRateTest)
|
|
{
|
|
float rate[] = {-10.0, -2.0, 2.0, 5.0, 0.5, 0.9};
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
MLOGI("----------PlaybackRateTest START----------\n");
|
|
startPlaying(url);
|
|
if (mRet == 0)
|
|
{
|
|
checkHasVideo(url);
|
|
EXPECT_FALSE(waitPlayingErrors(5 * 1000ll));
|
|
void *player = getPlayer();
|
|
for (size_t i = 0; i < sizeof(rate)/sizeof(rate[0]); i++)
|
|
{
|
|
EXPECT_EQ(Aml_MP_Player_SetPlaybackRate(player, rate[i]), AML_MP_OK);
|
|
EXPECT_TRUE(waitVideoChangedEvent(kWaitVideoChangedMs));
|
|
EXPECT_FALSE(waitPlaying(3 * 1000ll));
|
|
}
|
|
}
|
|
stopPlaying();
|
|
MLOGI("----------PlaybackRateTest END----------\n");
|
|
}
|
|
}
|
|
|
|
TEST_F(AmlMpTest, PlaybackRateTest1)
|
|
{
|
|
float rate[] = {-1.5, -1.0, -0.5};
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
MLOGI("----------PlaybackRateTest1 START----------\n");
|
|
startPlaying(url);
|
|
if (mRet == 0)
|
|
{
|
|
checkHasVideo(url);
|
|
EXPECT_FALSE(waitPlayingErrors(5 * 1000ll));
|
|
void *player = getPlayer();
|
|
for (size_t i = 0; i < sizeof(rate)/sizeof(rate[0]); i++)
|
|
{
|
|
EXPECT_EQ(Aml_MP_Player_SetPlaybackRate(player, rate[i]), AML_MP_ERROR_BAD_VALUE);
|
|
EXPECT_FALSE(waitPlayingErrors());
|
|
}
|
|
}
|
|
stopPlaying();
|
|
MLOGI("----------PlaybackRateTest1 END----------\n");
|
|
}
|
|
}
|
|
|
|
TEST_F(AmlMpTest, PlaybackRateTest2)
|
|
{
|
|
float rate = 0.0;
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
MLOGI("----------PlaybackRateTest2 START----------\n");
|
|
startPlaying(url);
|
|
if (mRet == 0)
|
|
{
|
|
checkHasVideo(url);
|
|
EXPECT_FALSE(waitPlayingErrors(5 * 1000ll));
|
|
void *player = getPlayer();
|
|
EXPECT_EQ(Aml_MP_Player_SetPlaybackRate(player, rate), AML_MP_OK);
|
|
EXPECT_FALSE(waitPlaying(3 * 1000ll));
|
|
std::string frame_before = get_frame_count_checkpoint();
|
|
EXPECT_FALSE(waitPlaying(3 * 1000ll));
|
|
std::string frame_after = get_frame_count_checkpoint();
|
|
EXPECT_EQ(frame_before, frame_after);
|
|
}
|
|
stopPlaying();
|
|
MLOGI("----------PlaybackRateTest2 END----------\n");
|
|
}
|
|
}
|
|
|
|
TEST_F(AmlMpTest, AVSyncModeTest)
|
|
{
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
MLOGI("----------AVSyncModeTest START----------\n");
|
|
//enum
|
|
for (Aml_MP_AVSyncSource avsyncsourceEnum = AML_MP_AVSYNC_SOURCE_DEFAULT; avsyncsourceEnum <= AML_MP_AVSYNC_SOURCE_PCR; avsyncsourceEnum = (Aml_MP_AVSyncSource) (avsyncsourceEnum + 1))
|
|
{
|
|
MLOGI("avsyncsourceEnum is %d \n", avsyncsourceEnum);
|
|
createMpTestSupporter();
|
|
mpTestSupporter->setDataSource(url);
|
|
mpTestSupporter->prepare();
|
|
sptr<ProgramInfo> mProgramInfo = mpTestSupporter->getProgramInfo();
|
|
if (mProgramInfo == nullptr)
|
|
{
|
|
printf("Format for this stream is not ts.");
|
|
continue;
|
|
}
|
|
mProgramInfo->scrambled=true;
|
|
mpTestSupporter->setAVSyncSource(avsyncsourceEnum);
|
|
mpTestSupporter->startPlay();
|
|
checkHasVideo(url);
|
|
void *player = getPlayer();
|
|
EXPECT_EQ(Aml_MP_Player_SetAVSyncSource(player, avsyncsourceEnum), AML_MP_OK);
|
|
EXPECT_FALSE(waitPlayingErrors());
|
|
stopPlaying();
|
|
}
|
|
MLOGI("----------AVSyncModeTest END----------\n");
|
|
}
|
|
}
|
|
|
|
TEST_F(AmlMpTest, PIPTest)
|
|
{
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
FCCAndPIPTest(url, true);
|
|
}
|
|
}
|
|
|
|
TEST_F(AmlMpTest, FCCTest)
|
|
{
|
|
//FCC: normal,cache(no surface)->cache,normal
|
|
std::string url;
|
|
for (auto &url: mUrls)
|
|
{
|
|
FCCAndPIPTest(url, false);
|
|
}
|
|
}
|
|
|