ZLMediaKit/api/source/mk_player.cpp

225 lines
7.2 KiB
C++
Raw Permalink Normal View History

2019-12-18 11:47:49 +08:00
/*
2020-04-04 20:30:09 +08:00
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
2019-12-18 11:45:33 +08:00
*
* This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit).
2019-12-18 11:45:33 +08:00
*
2020-04-04 20:30:09 +08:00
* Use of this source code is governed by MIT license that can be found in the
* LICENSE file in the root of the source tree. All contributing project authors
* may be found in the AUTHORS file in the root of the source tree.
2019-12-18 11:45:33 +08:00
*/
#include "mk_player.h"
2019-12-18 11:45:33 +08:00
#include "Util/logger.h"
#include "Player/MediaPlayer.h"
#include "Extension/H264.h"
2019-12-18 11:45:33 +08:00
using namespace std;
using namespace toolkit;
using namespace mediakit;
2020-04-26 19:02:40 +08:00
class MediaPlayerForC : public std::enable_shared_from_this<MediaPlayerForC>{
public:
2022-12-02 14:43:06 +08:00
using Ptr = std::shared_ptr<MediaPlayerForC>;
2020-04-26 19:02:40 +08:00
MediaPlayerForC(){
_player = std::make_shared<MediaPlayer>();
}
~MediaPlayerForC() = default;
2020-04-26 19:02:40 +08:00
MediaPlayer *operator->(){
return _player.get();
}
void setup(){
weak_ptr<MediaPlayerForC> weak_self = shared_from_this();
_player->setOnPlayResult([weak_self](const SockException &ex){
auto strong_self = weak_self.lock();
if(strong_self){
strong_self->onEvent(false,ex);
}
});
_player->setOnShutdown([weak_self](const SockException &ex){
auto strong_self = weak_self.lock();
if(strong_self){
strong_self->onEvent(true,ex);
}
});
}
2022-05-25 15:38:32 +08:00
void unset() {
for (auto &track : _player->getTracks(false)) {
track->clear();
}
lock_guard<recursive_mutex> lck(_mtx);
_on_play = nullptr;
_on_shutdown = nullptr;
}
2020-04-26 19:02:40 +08:00
void onEvent(bool is_shutdown, const SockException &ex){
lock_guard<recursive_mutex> lck(_mtx);
2022-05-25 15:38:32 +08:00
if (is_shutdown) {
2020-04-26 19:02:40 +08:00
//播放中断
2022-05-25 15:38:32 +08:00
if (_on_shutdown) {
_on_shutdown(_on_shutdown_data.get(), ex.getErrCode(), ex.what(), nullptr, 0);
2020-04-26 19:02:40 +08:00
}
return;
}
//播放结果
2022-05-25 15:38:32 +08:00
if (_on_play) {
auto cpp_tracks = _player->getTracks(false);
mk_track tracks[TrackMax] = {nullptr};
int track_count = 0;
for (auto &track : cpp_tracks) {
tracks[track_count++] = (mk_track) &track;
2020-04-26 19:02:40 +08:00
}
_on_play(_on_play_data.get(), ex.getErrCode(), ex.what(), tracks, track_count);
2020-04-26 19:02:40 +08:00
}
}
void setOnEvent(on_mk_play_event cb, std::shared_ptr<void> user_data, int type) {
2020-04-26 19:02:40 +08:00
lock_guard<recursive_mutex> lck(_mtx);
if (type == 0) {
_on_play_data = std::move(user_data);
2020-04-26 19:02:40 +08:00
_on_play = cb;
} else {
_on_shutdown_data = std::move(user_data);
2020-04-26 19:02:40 +08:00
_on_shutdown = cb;
}
}
MediaPlayer::Ptr& getPlayer(){
return _player;
}
private:
MediaPlayer::Ptr _player;
recursive_mutex _mtx;
on_mk_play_event _on_play = nullptr;
on_mk_play_event _on_shutdown = nullptr;
std::shared_ptr<void> _on_play_data;
std::shared_ptr<void> _on_shutdown_data;
2020-04-26 19:02:40 +08:00
};
2019-12-18 11:45:33 +08:00
API_EXPORT mk_player API_CALL mk_player_create() {
2020-04-26 19:02:40 +08:00
MediaPlayerForC::Ptr *obj = new MediaPlayerForC::Ptr(new MediaPlayerForC());
(*obj)->setup();
return (mk_player)obj;
2019-12-18 11:45:33 +08:00
}
API_EXPORT void API_CALL mk_player_release(mk_player ctx) {
2020-03-20 11:51:24 +08:00
assert(ctx);
2020-04-26 19:02:40 +08:00
MediaPlayerForC::Ptr *obj = (MediaPlayerForC::Ptr *)ctx;
(*obj)->unset();
2020-03-20 11:51:24 +08:00
delete obj;
2019-12-18 11:45:33 +08:00
}
API_EXPORT void API_CALL mk_player_set_option(mk_player ctx,const char* key,const char *val){
2020-03-20 11:51:24 +08:00
assert(ctx && key && val);
2020-04-26 19:02:40 +08:00
MediaPlayerForC &obj = **((MediaPlayerForC::Ptr *)ctx);
auto player = obj.getPlayer();
2020-03-20 11:51:24 +08:00
string key_str(key), val_str(val);
player->getPoller()->async([key_str,val_str,player](){
//切换线程后再操作
(*player)[key_str] = val_str;
});
2019-12-18 11:45:33 +08:00
}
API_EXPORT void API_CALL mk_player_play(mk_player ctx, const char *url) {
2020-03-20 11:51:24 +08:00
assert(ctx && url);
2020-04-26 19:02:40 +08:00
MediaPlayerForC &obj = **((MediaPlayerForC::Ptr *)ctx);
auto player = obj.getPlayer();
2020-03-20 11:51:24 +08:00
string url_str(url);
player->getPoller()->async([url_str,player](){
//切换线程后再操作
player->play(url_str);
});
2019-12-18 11:45:33 +08:00
}
API_EXPORT void API_CALL mk_player_pause(mk_player ctx, int pause) {
2020-03-20 11:51:24 +08:00
assert(ctx);
2020-04-26 19:02:40 +08:00
MediaPlayerForC &obj = **((MediaPlayerForC::Ptr *)ctx);
auto player = obj.getPlayer();
2020-03-20 11:51:24 +08:00
player->getPoller()->async([pause,player](){
//切换线程后再操作
player->pause(pause);
});
2019-12-18 11:45:33 +08:00
}
API_EXPORT void API_CALL mk_player_speed(mk_player ctx, float speed) {
assert(ctx);
2021-08-12 16:07:31 +08:00
MediaPlayerForC &obj = **((MediaPlayerForC::Ptr *) ctx);
auto player = obj.getPlayer();
player->getPoller()->async([speed, player]() {
//切换线程后再操作
player->speed(speed);
2021-08-12 16:07:31 +08:00
});
}
2019-12-18 11:45:33 +08:00
API_EXPORT void API_CALL mk_player_seekto(mk_player ctx, float progress) {
assert(ctx);
2020-04-26 19:02:40 +08:00
MediaPlayerForC &obj = **((MediaPlayerForC::Ptr *)ctx);
auto player = obj.getPlayer();
2019-12-18 11:45:33 +08:00
player->getPoller()->async([progress,player](){
//切换线程后再操作
player->seekTo(progress);
});
}
2021-08-12 16:07:31 +08:00
API_EXPORT void API_CALL mk_player_seekto_pos(mk_player ctx, int seek_pos) {
assert(ctx);
2021-08-12 16:07:31 +08:00
MediaPlayerForC &obj = **((MediaPlayerForC::Ptr *) ctx);
auto player = obj.getPlayer();
2021-08-12 16:07:31 +08:00
player->getPoller()->async([seek_pos, player]() {
//切换线程后再操作
2021-08-12 16:07:31 +08:00
player->seekTo((uint32_t) seek_pos);
});
}
static void mk_player_set_on_event(mk_player ctx, on_mk_play_event cb, std::shared_ptr<void> user_data, int type) {
2020-04-27 09:18:46 +08:00
assert(ctx);
2020-04-26 19:02:40 +08:00
MediaPlayerForC &obj = **((MediaPlayerForC::Ptr *)ctx);
obj.setOnEvent(cb, std::move(user_data), type);
2019-12-18 11:45:33 +08:00
}
API_EXPORT void API_CALL mk_player_set_on_result(mk_player ctx, on_mk_play_event cb, void *user_data) {
mk_player_set_on_result2(ctx, cb, user_data, nullptr);
}
API_EXPORT void API_CALL mk_player_set_on_result2(mk_player ctx, on_mk_play_event cb, void *user_data, on_user_data_free user_data_free) {
std::shared_ptr<void> ptr(user_data, user_data_free ? user_data_free : [](void *) {});
mk_player_set_on_event(ctx, cb, std::move(ptr), 0);
2019-12-18 11:45:33 +08:00
}
API_EXPORT void API_CALL mk_player_set_on_shutdown(mk_player ctx, on_mk_play_event cb, void *user_data) {
mk_player_set_on_shutdown2(ctx, cb, user_data, nullptr);
}
API_EXPORT void API_CALL mk_player_set_on_shutdown2(mk_player ctx, on_mk_play_event cb, void *user_data, on_user_data_free user_data_free){
std::shared_ptr<void> ptr(user_data, user_data_free ? user_data_free : [](void *) {});
mk_player_set_on_event(ctx, cb, std::move(ptr), 1);
2019-12-18 11:45:33 +08:00
}
API_EXPORT float API_CALL mk_player_duration(mk_player ctx) {
2020-03-20 11:51:24 +08:00
assert(ctx);
2020-04-26 19:02:40 +08:00
MediaPlayerForC &obj = **((MediaPlayerForC::Ptr *)ctx);
return obj->getDuration();
2019-12-18 11:45:33 +08:00
}
API_EXPORT float API_CALL mk_player_progress(mk_player ctx) {
2020-03-20 11:51:24 +08:00
assert(ctx);
2020-04-26 19:02:40 +08:00
MediaPlayerForC &obj = **((MediaPlayerForC::Ptr *)ctx);
return obj->getProgress();
2019-12-18 11:45:33 +08:00
}
2021-08-12 20:55:11 +08:00
API_EXPORT int API_CALL mk_player_progress_pos(mk_player ctx) {
assert(ctx);
2021-08-12 20:55:11 +08:00
MediaPlayerForC &obj = **((MediaPlayerForC::Ptr *) ctx);
return obj->getProgressPos();
}
2019-12-18 11:45:33 +08:00
API_EXPORT float API_CALL mk_player_loss_rate(mk_player ctx, int track_type) {
2020-03-20 11:51:24 +08:00
assert(ctx);
2020-04-26 19:02:40 +08:00
MediaPlayerForC &obj = **((MediaPlayerForC::Ptr *)ctx);
return obj->getPacketLossRate((TrackType)track_type);
2019-12-18 11:45:33 +08:00
}