mirror of
https://github.com/ZLMediaKit/ZLMediaKit.git
synced 2024-11-23 19:20:53 +08:00
113 lines
3.7 KiB
C++
113 lines
3.7 KiB
C++
/*
|
|
* Copyright (c) 2016 The ZLMediaKit project authors. All Rights Reserved.
|
|
*
|
|
* This file is part of ZLMediaKit(https://github.com/xia-chu/ZLMediaKit).
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include "mk_h264_splitter.h"
|
|
#include "Http/HttpRequestSplitter.h"
|
|
#include "Extension/H264.h"
|
|
#include "Extension/H265.h"
|
|
|
|
using namespace mediakit;
|
|
|
|
class H264Splitter : public HttpRequestSplitter {
|
|
public:
|
|
using onH264 = std::function<void(const char *data, size_t len)>;
|
|
H264Splitter(bool h265 = false) { _h265 = h265; }
|
|
~H264Splitter() override;
|
|
void setOnSplitted(onH264 cb);
|
|
|
|
protected:
|
|
ssize_t onRecvHeader(const char *data, size_t len) override;
|
|
const char *onSearchPacketTail(const char *data, size_t len) override;
|
|
|
|
private:
|
|
bool _h265 = false;
|
|
onH264 _cb;
|
|
size_t _search_pos = 0;
|
|
};
|
|
|
|
void H264Splitter::setOnSplitted(H264Splitter::onH264 cb) {
|
|
_cb = std::move(cb);
|
|
}
|
|
|
|
H264Splitter::~H264Splitter() {
|
|
if (remainDataSize()) {
|
|
_cb(remainData(), remainDataSize());
|
|
}
|
|
}
|
|
|
|
ssize_t H264Splitter::onRecvHeader(const char *data, size_t len) {
|
|
_cb(data, len);
|
|
return 0;
|
|
}
|
|
|
|
static const char *onSearchPacketTail_l(const char *data, size_t len) {
|
|
for (size_t i = 2; len > 2 && i < len - 2; ++i) {
|
|
//判断0x00 00 01
|
|
if (data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 1) {
|
|
if (i > 0 && data[i - 1] == 0) {
|
|
//找到0x00 00 00 01
|
|
return data + i - 1;
|
|
}
|
|
return data + i;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const char *H264Splitter::onSearchPacketTail(const char *data, size_t len) {
|
|
auto last_frame = data + _search_pos;
|
|
auto next_frame = onSearchPacketTail_l(last_frame, len - _search_pos);
|
|
if (!next_frame) {
|
|
return nullptr;
|
|
}
|
|
|
|
auto last_frame_len = next_frame - last_frame;
|
|
Frame::Ptr frame;
|
|
if (_h265) {
|
|
frame = std::make_shared<H265FrameNoCacheAble>((char *) last_frame, last_frame_len, 0, 0, prefixSize(last_frame, last_frame_len));
|
|
} else {
|
|
frame = std::make_shared<H264FrameNoCacheAble>((char *) last_frame, last_frame_len, 0, 0, prefixSize(last_frame, last_frame_len));
|
|
}
|
|
if (frame->decodeAble()) {
|
|
_search_pos = 0;
|
|
return next_frame;
|
|
}
|
|
_search_pos += last_frame_len;
|
|
return nullptr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
API_EXPORT mk_h264_splitter API_CALL mk_h264_splitter_create(on_mk_h264_splitter_frame cb, void *user_data, int is_h265) {
|
|
return mk_h264_splitter_create2(cb, user_data, nullptr, is_h265);
|
|
}
|
|
|
|
API_EXPORT mk_h264_splitter API_CALL mk_h264_splitter_create2(on_mk_h264_splitter_frame cb, void *user_data, on_user_data_free user_data_free, int is_h265) {
|
|
assert(cb);
|
|
auto ret = new H264Splitter(is_h265);
|
|
std::shared_ptr<void> ptr(user_data, user_data_free ? user_data_free : [](void *) {});
|
|
ret->setOnSplitted([cb, ptr, ret](const char *data, size_t len) {
|
|
cb(ptr.get(), reinterpret_cast<mk_h264_splitter>(ret), data, len);
|
|
});
|
|
return reinterpret_cast<mk_h264_splitter>(ret);
|
|
}
|
|
|
|
API_EXPORT void API_CALL mk_h264_splitter_release(mk_h264_splitter ctx){
|
|
assert(ctx);
|
|
auto ptr = reinterpret_cast<H264Splitter *>(ctx);
|
|
delete ptr;
|
|
}
|
|
|
|
API_EXPORT void API_CALL mk_h264_splitter_input_data(mk_h264_splitter ctx, const char *data, int size) {
|
|
assert(ctx && data && size);
|
|
auto ptr = reinterpret_cast<H264Splitter *>(ctx);
|
|
ptr->input(data, size);
|
|
}
|