external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-02-15 04:42:04 +00:00
Code Issues Releases Wiki Activity

Merge branch '3.0release' into develop

Browse source
This commit is contained in:
winlin 2019-12-31 19:38:06 +08:00
commit 505f9808e4
7 changed files with 890 additions and 191 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
trunk/src/kernel/srs_kernel_buffer.cpp
View file

@ -94,6 +94,8 @@ bool SrsBuffer::require(int required_size)
void SrsBuffer::skip(int size)
{
srs_assert(p);
srs_assert(p + size >= bytes);
srs_assert(p + size <= bytes + nb_bytes);
p += size;
}

69
trunk/src/kernel/srs_kernel_mp4.cpp
View file

@ -368,11 +368,8 @@ srs_error_t SrsMp4Box::discovery(SrsBuffer* buf, SrsMp4Box** ppbox)
case SrsMp4BoxTypeSIDX: box = new SrsMp4SegmentIndexBox(); break;
// Skip some unknown boxes.
case SrsMp4BoxTypeFREE: case SrsMp4BoxTypeSKIP: case SrsMp4BoxTypePASP:
case SrsMp4BoxTypeUUID:
case SrsMp4BoxTypeUUID: default:
box = new SrsMp4FreeSpaceBox(type); break;
default:
err = srs_error_new(ERROR_MP4_BOX_ILLEGAL_TYPE, "illegal box type=%d", type);
break;
}
if (box) {
@ -1552,6 +1549,9 @@ SrsMp4MovieHeaderBox::~SrsMp4MovieHeaderBox()
uint64_t SrsMp4MovieHeaderBox::duration()
{
if (timescale <= 0) {
return 0;
}
return duration_in_tbn * 1000 / timescale;
}
@ -2587,6 +2587,11 @@ SrsMp4DataEntryBox::~SrsMp4DataEntryBox()
{
}
bool SrsMp4DataEntryBox::boxes_in_header()
{
return true;
}
SrsMp4DataEntryUrlBox::SrsMp4DataEntryUrlBox()
{
type = SrsMp4BoxTypeURL;
@ -2598,11 +2603,6 @@ SrsMp4DataEntryUrlBox::~SrsMp4DataEntryUrlBox()
int SrsMp4DataEntryUrlBox::nb_header()
{
// a 24-bit integer with flags; one flag is defined (x000001) which means that the media
// data is in the same file as the Movie Box containing this data reference.
if (location.empty()) {
return SrsMp4FullBox::nb_header();
}
return SrsMp4FullBox::nb_header()+srs_mp4_string_length(location);
}
@ -2619,11 +2619,9 @@ srs_error_t SrsMp4DataEntryUrlBox::encode_header(SrsBuffer* buf)
if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) {
return srs_error_wrap(err, "encode header");
}
if (!location.empty()) {
srs_mp4_string_write(buf, location);
}
srs_mp4_string_write(buf, location);
return err;
}
@ -2635,12 +2633,6 @@ srs_error_t SrsMp4DataEntryUrlBox::decode_header(SrsBuffer* buf)
return srs_error_wrap(err, "decode header");
}
// a 24-bit integer with flags; one flag is defined (x000001) which means that the media
// data is in the same file as the Movie Box containing this data reference.
if (flags == 0x01) {
return err;
}
if ((err = srs_mp4_string_read(buf, location, left_space(buf))) != srs_success) {
return srs_error_wrap(err, "url read location");
}
@ -2650,7 +2642,9 @@ srs_error_t SrsMp4DataEntryUrlBox::decode_header(SrsBuffer* buf)
stringstream& SrsMp4DataEntryUrlBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc)
{
ss << "URL: " << location;
SrsMp4FullBox::dumps_detail(ss, dc);
ss << ", URL: " << location;
if (location.empty()) {
ss << "Same file";
}
@ -2674,6 +2668,12 @@ int SrsMp4DataEntryUrnBox::nb_header()
srs_error_t SrsMp4DataEntryUrnBox::encode_header(SrsBuffer* buf)
{
srs_error_t err = srs_success;
// a 24-bit integer with flags; one flag is defined (x000001) which means that the media
// data is in the same file as the Movie Box containing this data reference.
if (location.empty()) {
flags = 0x01;
}
if ((err = SrsMp4DataEntryBox::encode_header(buf)) != srs_success) {
return srs_error_wrap(err, "encode entry");
@ -2706,7 +2706,16 @@ srs_error_t SrsMp4DataEntryUrnBox::decode_header(SrsBuffer* buf)
stringstream& SrsMp4DataEntryUrnBox::dumps_detail(stringstream& ss, SrsMp4DumpContext dc)
{
ss << "URN: " << name << ", " << location;
SrsMp4FullBox::dumps_detail(ss, dc);
ss << ", URL: " << location;
if (location.empty()) {
ss << "Same file";
}
if (!name.empty()) {
ss << ", " << name;
}
return ss;
}
@ -2821,8 +2830,7 @@ stringstream& SrsMp4DataReferenceBox::dumps_detail(stringstream& ss, SrsMp4DumpC
ss << ", " << entries.size() << " childs";
if (!entries.empty()) {
ss << "(+)" << endl;
srs_mp4_padding(ss, dc.indent());
srs_dumps_array(entries, ss, dc.indent(), srs_mp4_pfn_detail2, srs_mp4_delimiter_newline);
srs_dumps_array(entries, ss, dc.indent(), srs_mp4_pfn_box2, srs_mp4_delimiter_newline);
}
return ss;
}
@ -3475,7 +3483,11 @@ stringstream& SrsMp4DecoderConfigDescriptor::dumps_detail(stringstream& ss, SrsM
srs_mp4_padding(ss, dc.indent());
ss << "decoder specific";
return decSpecificInfo->dumps_detail(ss, dc.indent());
if (decSpecificInfo) {
decSpecificInfo->dumps_detail(ss, dc.indent());
}
return ss;
}
SrsMp4SLConfigDescriptor::SrsMp4SLConfigDescriptor()
@ -4554,6 +4566,7 @@ stringstream& SrsMp4UserDataBox::dumps_detail(stringstream& ss, SrsMp4DumpContex
SrsMp4SegmentIndexBox::SrsMp4SegmentIndexBox()
{
type = SrsMp4BoxTypeSIDX;
version = 0;
}
SrsMp4SegmentIndexBox::~SrsMp4SegmentIndexBox()
@ -4778,10 +4791,10 @@ srs_error_t SrsMp4SampleManager::load(SrsMp4MovieBox* moov)
SrsMp4Sample* SrsMp4SampleManager::at(uint32_t index)
{
if (index >= samples.size() - 1) {
return NULL;
if (index < samples.size()) {
return samples.at(index);
}
return samples.at(index);
return NULL;
}
void SrsMp4SampleManager::append(SrsMp4Sample* sample)

2
trunk/src/kernel/srs_kernel_mp4.hpp
View file

@ -1122,6 +1122,8 @@ public:
public:
SrsMp4DataEntryBox();
virtual ~SrsMp4DataEntryBox();
public:
virtual bool boxes_in_header();
};
// 8.7.2 Data Reference Box (url )

2
trunk/src/kernel/srs_kernel_ts.cpp
View file

@ -620,7 +620,7 @@ srs_error_t SrsTsPacket::decode(SrsBuffer* stream, SrsTsMessage** ppmsg)
payload = new SrsTsPayloadPES(this);
} else {
// left bytes as reserved.
stream->skip(nb_payload);
stream->skip(srs_min(stream->left(), nb_payload));
}
}

361
trunk/src/utest/srs_utest_kernel.cpp
View file

@ -40,37 +40,121 @@ using namespace std;
#define MAX_MOCK_DATA_SIZE 1024 * 1024
MockSrsFile::MockSrsFile()
{
_buf = new SrsBuffer(_data.bytes(), _data.length());
}
MockSrsFile::~MockSrsFile()
{
close();
}
srs_error_t MockSrsFile::open(std::string /*file*/)
{
srs_error_t err = srs_success;
return err;
}
void MockSrsFile::close()
{
srs_freep(_buf);
}
srs_error_t MockSrsFile::write(void* data, size_t count, ssize_t* pnwrite)
{
srs_error_t err = srs_success;
for (;;) {
if (_buf->left() >= (int)count) {
_buf->write_bytes((char*)data, count);
break;
}
// Append enough data and rebuild the buffer.
off_t pos = _buf->pos();
_data.append((const char*)data, count - _buf->left());
srs_freep(_buf);
_buf = new SrsBuffer(_data.bytes(), _data.length());
lseek(pos, SEEK_SET, NULL);
}
if (pnwrite) {
*pnwrite = count;
}
return err;
}
srs_error_t MockSrsFile::read(void* data, size_t count, ssize_t* pnread)
{
srs_error_t err = srs_success;
int limit = srs_min(_buf->left(), (int)count);
if (limit <= 0) {
return srs_error_new(-1, "EOF");
}
_buf->read_bytes((char*)data, limit);
if (pnread) {
*pnread = limit;
}
return err;
}
srs_error_t MockSrsFile::lseek(off_t offset, int whence, off_t* seeked)
{
srs_error_t err = srs_success;
if (whence == SEEK_SET) {
if (offset > _data.length()) {
return srs_error_new(-1, "Overflow");
}
if (_buf->data()) {
_buf->skip(offset - _buf->pos());
}
} else if (whence == SEEK_CUR) {
} else if (whence == SEEK_END) {
if (_buf->data()) {
_buf->skip(_buf->left());
}
}
if (seeked) {
*seeked = (off_t)_buf->pos();
}
return err;
}
MockSrsFileWriter::MockSrsFileWriter()
{
size = MAX_MOCK_DATA_SIZE;
data = new char[size];
offset = 0;
err = srs_success;
error_offset = -1;
opened = false;
uf = new MockSrsFile();
}
MockSrsFileWriter::~MockSrsFileWriter()
{
srs_freep(err);
srs_freep(data);
srs_freep(uf);
}
srs_error_t MockSrsFileWriter::open(string /*file*/)
srs_error_t MockSrsFileWriter::open(string file)
{
offset = 0;
if (err != srs_success) {
return srs_error_copy(err);
}
opened = true;
return srs_success;
return uf->open(file);
}
void MockSrsFileWriter::close()
{
opened = false;
uf->close();
}
bool MockSrsFileWriter::is_open()
@ -80,103 +164,89 @@ bool MockSrsFileWriter::is_open()
void MockSrsFileWriter::seek2(int64_t offset)
{
this->offset = offset;
lseek(offset, SEEK_SET, NULL);
}
int64_t MockSrsFileWriter::tellg()
{
off_t offset = 0;
lseek(0, SEEK_CUR, &offset);
return (int64_t)offset;
}
int64_t MockSrsFileWriter::filesize()
{
int64_t cur = tellg();
off_t offset = 0;
lseek(0, SEEK_END, &offset);
seek2(cur);
return offset;
}
char* MockSrsFileWriter::data()
{
return uf->_data.bytes();
}
srs_error_t MockSrsFileWriter::write(void* buf, size_t count, ssize_t* pnwrite)
{
if (err != srs_success) {
return srs_error_copy(err);
}
int nwriten = srs_min(MAX_MOCK_DATA_SIZE - offset, (int)count);
if (nwriten > 0) {
memcpy(data + offset, buf, nwriten);
if (error_offset >= 0 && tellg() >= error_offset) {
return srs_error_new(-1, "overflow");
}
if (pnwrite) {
*pnwrite = nwriten;
}
offset += nwriten;
size = srs_max(size, offset);
if (error_offset >= 0 && offset > error_offset) {
return srs_error_new(-1, "exceed offset");
}
return srs_success;
return uf->write(buf, count, pnwrite);
}
srs_error_t MockSrsFileWriter::lseek(off_t _offset, int whence, off_t* seeked)
srs_error_t MockSrsFileWriter::lseek(off_t offset, int whence, off_t* seeked)
{
if (whence == SEEK_SET) {
offset = (int)_offset;
if (error_offset >= 0 && offset > error_offset) {
return srs_error_new(-1, "overflow");
}
if (whence == SEEK_CUR) {
offset += (int)_offset;
}
if (whence == SEEK_END) {
offset = (int)(size + _offset);
}
if (seeked) {
*seeked = (off_t)offset;
}
return srs_success;
return uf->lseek(offset, whence, seeked);
}
void MockSrsFileWriter::mock_reset_offset()
{
offset = 0;
seek2(0);
}
MockSrsFileReader::MockSrsFileReader()
{
data = new char[MAX_MOCK_DATA_SIZE];
size = 0;
offset = 0;
opened = false;
seekable = true;
uf = new MockSrsFile();
}
MockSrsFileReader::MockSrsFileReader(const char* src, int nb_src)
{
data = NULL;
size = nb_src;
if (nb_src > 0) {
data = new char[nb_src];
memcpy(data, src, nb_src);
}
offset = 0;
opened = false;
seekable = true;
uf = new MockSrsFile();
uf->write((void*)src, nb_src, NULL);
uf->lseek(0, SEEK_SET, NULL);
}
MockSrsFileReader::~MockSrsFileReader()
{
srs_freep(data);
srs_freep(uf);
}
srs_error_t MockSrsFileReader::open(string /*file*/)
srs_error_t MockSrsFileReader::open(string file)
{
offset = 0;
opened = true;
return srs_success;
return uf->open(file);
}
void MockSrsFileReader::close()
{
offset = 0;
uf->close();
}
bool MockSrsFileReader::is_open()
@ -186,77 +256,56 @@ bool MockSrsFileReader::is_open()
int64_t MockSrsFileReader::tellg()
{
off_t offset = 0;
lseek(0, SEEK_CUR, &offset);
return offset;
}
void MockSrsFileReader::skip(int64_t _size)
{
offset += _size;
int64_t offset = tellg() + _size;
lseek(offset, SEEK_SET, NULL);
}
int64_t MockSrsFileReader::seek2(int64_t _offset)
{
if (!seekable) {
return -1;
}
offset = (int)_offset;
off_t offset = 0;
lseek(_offset, SEEK_SET, &offset);
return offset;
}
int64_t MockSrsFileReader::filesize()
{
return size;
int64_t cur = tellg();
off_t offset = 0;
lseek(0, SEEK_END, &offset);
seek2(cur);
return offset;
}
srs_error_t MockSrsFileReader::read(void* buf, size_t count, ssize_t* pnread)
{
int s = srs_min(size - offset, (int)count);
if (s <= 0) {
return srs_error_new(ERROR_SYSTEM_FILE_EOF, "EOF left=%d", s);
}
memcpy(buf, data + offset, s);
offset += s;
if (pnread) {
*pnread = s;
}
return srs_success;
return uf->read(buf, count, pnread);
}
srs_error_t MockSrsFileReader::lseek(off_t _offset, int whence, off_t* seeked)
srs_error_t MockSrsFileReader::lseek(off_t offset, int whence, off_t* seeked)
{
if (whence == SEEK_SET) {
offset = (int)_offset;
if (!seekable) {
return srs_error_new(-1, "unseekable");
}
if (whence == SEEK_CUR) {
offset += (int)_offset;
}
if (whence == SEEK_END) {
offset = (int)(size + _offset);
}
if (seeked) {
*seeked = (off_t)offset;
}
return srs_success;
return uf->lseek(offset, whence, seeked);
}
void MockSrsFileReader::mock_append_data(const char* _data, int _size)
void MockSrsFileReader::mock_append_data(const char* data, int size)
{
int s = srs_min(MAX_MOCK_DATA_SIZE - offset, _size);
memcpy(data + offset, _data, s);
size += s;
offset += s;
uf->write((void*)data, size, NULL);
}
void MockSrsFileReader::mock_reset_offset()
{
offset = 0;
seek2(0);
}
MockBufferReader::MockBufferReader(const char* data)
@ -596,10 +645,10 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteHeader)
char pts[] = { (char)0x00, (char)0x00, (char)0x00, (char)0x00 };
EXPECT_TRUE(ERROR_SUCCESS == enc.write_header());
ASSERT_TRUE(9 + 4 == fs.offset);
ASSERT_TRUE(9 + 4 == fs.tellg());
EXPECT_TRUE(srs_bytes_equals(flv_header, fs.data, 9));
EXPECT_TRUE(srs_bytes_equals(pts, fs.data + 9, 4));
EXPECT_TRUE(srs_bytes_equals(flv_header, fs.data(), 9));
EXPECT_TRUE(srs_bytes_equals(pts, fs.data() + 9, 4));
// customer header
flv_header[3] = 0xF0;
@ -609,10 +658,10 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteHeader)
fs.mock_reset_offset();
EXPECT_TRUE(ERROR_SUCCESS == enc.write_header(flv_header));
ASSERT_TRUE(9 + 4 == fs.offset);
ASSERT_TRUE(9 + 4 == fs.tellg());
EXPECT_TRUE(srs_bytes_equals(flv_header, fs.data, 9));
EXPECT_TRUE(srs_bytes_equals(pts, fs.data + 9, 4));
EXPECT_TRUE(srs_bytes_equals(flv_header, fs.data(), 9));
EXPECT_TRUE(srs_bytes_equals(pts, fs.data() + 9, 4));
}
/**
@ -641,12 +690,12 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteMetadata)
char pts[] = { (char)0x00, (char)0x00, (char)0x00, (char)19 };
ASSERT_TRUE(ERROR_SUCCESS == enc.write_metadata(18, md, 8));
ASSERT_TRUE(11 + 8 + 4 == fs.offset);
ASSERT_TRUE(11 + 8 + 4 == fs.tellg());
EXPECT_TRUE(srs_bytes_equals(tag_header, fs.data, 11));
EXPECT_TRUE(srs_bytes_equals(md, fs.data + 11, 8));
EXPECT_TRUE(srs_bytes_equals(tag_header, fs.data(), 11));
EXPECT_TRUE(srs_bytes_equals(md, fs.data() + 11, 8));
EXPECT_TRUE(true); // donot know why, if not add it, the print is disabled.
EXPECT_TRUE(srs_bytes_equals(pts, fs.data + 19, 4));
EXPECT_TRUE(srs_bytes_equals(pts, fs.data() + 19, 4));
}
/**
@ -675,12 +724,12 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteAudio)
char pts[] = { (char)0x00, (char)0x00, (char)0x00, (char)19 };
ASSERT_TRUE(ERROR_SUCCESS == enc.write_audio(0x30, audio, 8));
ASSERT_TRUE(11 + 8 + 4 == fs.offset);
ASSERT_TRUE(11 + 8 + 4 == fs.tellg());
EXPECT_TRUE(srs_bytes_equals(tag_header, fs.data, 11));
EXPECT_TRUE(srs_bytes_equals(audio, fs.data + 11, 8));
EXPECT_TRUE(srs_bytes_equals(tag_header, fs.data(), 11));
EXPECT_TRUE(srs_bytes_equals(audio, fs.data() + 11, 8));
EXPECT_TRUE(true); // donot know why, if not add it, the print is disabled.
EXPECT_TRUE(srs_bytes_equals(pts, fs.data + 11 + 8, 4));
EXPECT_TRUE(srs_bytes_equals(pts, fs.data() + 11 + 8, 4));
}
/**
@ -709,12 +758,12 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteVideo)
char pts[] = { (char)0x00, (char)0x00, (char)0x00, (char)19 };
ASSERT_TRUE(ERROR_SUCCESS == enc.write_video(0x30, video, 8));
ASSERT_TRUE(11 + 8 + 4 == fs.offset);
ASSERT_TRUE(11 + 8 + 4 == fs.tellg());
EXPECT_TRUE(srs_bytes_equals(tag_header, fs.data, 11));
EXPECT_TRUE(srs_bytes_equals(video, fs.data + 11, 8));
EXPECT_TRUE(srs_bytes_equals(tag_header, fs.data(), 11));
EXPECT_TRUE(srs_bytes_equals(video, fs.data() + 11, 8));
EXPECT_TRUE(true); // donot know why, if not add it, the print is disabled.
EXPECT_TRUE(srs_bytes_equals(pts, fs.data + 11 + 8, 4));
EXPECT_TRUE(srs_bytes_equals(pts, fs.data() + 11 + 8, 4));
}
/**
@ -1478,13 +1527,13 @@ VOID TEST(KernelFlvTest, FlvVSDecoderSeek)
(char)0x00, (char)0x00, (char)0x00, // StreamID UI24 Always 0.
};
fs.mock_append_data(tag_header, 11);
EXPECT_TRUE(11 == fs.offset);
EXPECT_TRUE(11 == fs.tellg());
EXPECT_TRUE(ERROR_SUCCESS == dec.seek2(0));
EXPECT_TRUE(0 == fs.offset);
EXPECT_TRUE(0 == fs.tellg());
EXPECT_TRUE(ERROR_SUCCESS == dec.seek2(5));
EXPECT_TRUE(5 == fs.offset);
EXPECT_TRUE(5 == fs.tellg());
}
VOID TEST(KernelFLVTest, CoverFLVVodError)
@ -2805,15 +2854,15 @@ VOID TEST(KernelAACTest, TransmaxRTMP2AAC)
EXPECT_TRUE(srs_success == err);
srs_freep(err);
EXPECT_EQ(8, f.offset);
EXPECT_EQ((char)0xff, f.data[0]);
EXPECT_EQ((char)0xf1, f.data[1]);
EXPECT_EQ((char)0x50, f.data[2]);
EXPECT_EQ((char)0x80, f.data[3]);
EXPECT_EQ((char)0x01, f.data[4]);
EXPECT_EQ((char)0x00, f.data[5]);
EXPECT_EQ((char)0xfc, f.data[6]);
EXPECT_EQ((char)0xcb, f.data[7]);
EXPECT_EQ(8, f.tellg());
EXPECT_EQ((char)0xff, f.data()[0]);
EXPECT_EQ((char)0xf1, f.data()[1]);
EXPECT_EQ((char)0x50, f.data()[2]);
EXPECT_EQ((char)0x80, f.data()[3]);
EXPECT_EQ((char)0x01, f.data()[4]);
EXPECT_EQ((char)0x00, f.data()[5]);
EXPECT_EQ((char)0xfc, f.data()[6]);
EXPECT_EQ((char)0xcb, f.data()[7]);
}
if (true) {
@ -3915,7 +3964,7 @@ VOID TEST(KernelFLVTest, CoverAll)
SrsSharedPtrMessage* msgs = &m;
EXPECT_TRUE(srs_success == mux.write_tags(&msgs, 1));
EXPECT_EQ(16, f.offset);
EXPECT_EQ(16, f.tellg());
}
#endif
}
@ -3992,7 +4041,7 @@ VOID TEST(KernelMp3Test, CoverAll)
EXPECT_TRUE(srs_success == m.initialize(&f));
EXPECT_TRUE(srs_success == m.write_header());
EXPECT_EQ((char)0x49, f.data[0]);
EXPECT_EQ((char)0x49, f.data()[0]);
}
if (true) {
@ -4002,7 +4051,7 @@ VOID TEST(KernelMp3Test, CoverAll)
EXPECT_TRUE(srs_success == m.initialize(&f));
EXPECT_TRUE(srs_success == m.write_audio(0, (char*)"\x20\x01", 2));
EXPECT_EQ((char)0x01, f.data[0]);
EXPECT_EQ((char)0x01, f.data()[0]);
}
if (true) {
@ -4020,16 +4069,6 @@ VOID TEST(KernelMp3Test, CoverAll)
srs_freep(err);
}
if (true) {
SrsMp3Transmuxer m;
MockSrsFileWriter f;
f.offset = -1;
srs_error_t err = m.initialize(&f);
EXPECT_TRUE(srs_success != err);
srs_freep(err);
}
if (true) {
SrsMp3Transmuxer m;
MockSrsFileWriter f;
@ -4641,7 +4680,7 @@ VOID TEST(KernelMP4Test, CoverMP4Codec)
EXPECT_TRUE(srs_success == enc.flush());
if (true) {
MockSrsFileReader fr((const char*)f.data, f.size);
MockSrsFileReader fr((const char*)f.data(), f.filesize());
SrsMp4Decoder dec;
EXPECT_TRUE(srs_success == dec.initialize(&fr));
@ -4649,13 +4688,39 @@ VOID TEST(KernelMP4Test, CoverMP4Codec)
uint16_t ft, ct;
uint32_t dts, pts, nb_sample;
uint8_t* sample;
EXPECT_TRUE(srs_success == dec.read_sample(&ht, &ft, &ct, &dts, &pts, &sample, &nb_sample));
EXPECT_EQ(0, (int)dts);
EXPECT_EQ(41, nb_sample);
EXPECT_EQ(SrsMp4HandlerTypeVIDE, ht);
EXPECT_EQ(SrsAudioAacFrameTraitSequenceHeader, ct);
srs_freepa(sample);
EXPECT_TRUE(srs_success == dec.read_sample(&ht, &ft, &ct, &dts, &pts, &sample, &nb_sample));
EXPECT_EQ(0, (int)dts);
EXPECT_EQ(2, nb_sample);
EXPECT_EQ(SrsMp4HandlerTypeSOUN, ht);
EXPECT_EQ(SrsAudioAacFrameTraitSequenceHeader, ct);
srs_freepa(sample);
EXPECT_TRUE(srs_success == dec.read_sample(&ht, &ft, &ct, &dts, &pts, &sample, &nb_sample));
EXPECT_EQ(0, (int)dts);
EXPECT_EQ(87, nb_sample);
EXPECT_EQ(SrsMp4HandlerTypeSOUN, ht);
EXPECT_NE(SrsAudioAacFrameTraitSequenceHeader, ct);
srs_freepa(sample);
EXPECT_TRUE(srs_success == dec.read_sample(&ht, &ft, &ct, &dts, &pts, &sample, &nb_sample));
EXPECT_EQ(0, (int)dts);
EXPECT_EQ(127, nb_sample);
EXPECT_EQ(SrsMp4HandlerTypeVIDE, ht);
EXPECT_NE(SrsAudioAacFrameTraitSequenceHeader, ct);
srs_freepa(sample);
}
if (true) {
SrsMp4BoxReader br;
MockSrsFileReader fr((const char*)f.data, f.size);
MockSrsFileReader fr((const char*)f.data(), f.filesize());
EXPECT_TRUE(srs_success == br.initialize(&fr));
SrsSimpleStream stream;

40
trunk/src/utest/srs_utest_kernel.hpp
View file

@ -34,24 +34,29 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include <srs_kernel_buffer.hpp>
#include <srs_protocol_stream.hpp>
#include <srs_kernel_ts.hpp>
#include <srs_kernel_stream.hpp>
class MockBufferReader: public ISrsReader
class MockSrsFile
{
private:
std::string str;
public:
MockBufferReader(const char* data);
virtual ~MockBufferReader();
SrsBuffer* _buf;
SrsSimpleStream _data;
public:
virtual srs_error_t read(void* buf, size_t size, ssize_t* nread);
MockSrsFile();
virtual ~MockSrsFile();
public:
virtual srs_error_t open(std::string file);
virtual void close();
public:
virtual srs_error_t write(void* data, size_t count, ssize_t* pnwrite);
virtual srs_error_t read(void* data, size_t count, ssize_t* pnread);
virtual srs_error_t lseek(off_t offset, int whence, off_t* seeked);
};
class MockSrsFileWriter : public SrsFileWriter
{
public:
char* data;
int size;
int offset;
MockSrsFile* uf;
srs_error_t err;
// Error if exceed this offset.
int error_offset;
@ -67,6 +72,8 @@ public:
virtual bool is_open();
virtual void seek2(int64_t offset);
virtual int64_t tellg();
virtual int64_t filesize();
virtual char* data();
public:
virtual srs_error_t write(void* buf, size_t count, ssize_t* pnwrite);
virtual srs_error_t lseek(off_t offset, int whence, off_t* seeked);
@ -78,9 +85,7 @@ public:
class MockSrsFileReader : public SrsFileReader
{
public:
char* data;
int size;
int offset;
MockSrsFile* uf;
bool opened;
// Could seek.
bool seekable;
@ -107,6 +112,17 @@ public:
void mock_reset_offset();
};
class MockBufferReader: public ISrsReader
{
private:
std::string str;
public:
MockBufferReader(const char* data);
virtual ~MockBufferReader();
public:
virtual srs_error_t read(void* buf, size_t size, ssize_t* nread);
};
class MockSrsCodec : public ISrsCodec
{
public:

605
trunk/src/utest/srs_utest_mp4.cpp
View file

@ -25,6 +25,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include <sstream>
using namespace std;
#include <srs_utest_kernel.hpp>
#include <srs_kernel_error.hpp>
#include <srs_kernel_mp4.hpp>
#include <srs_core_autofree.hpp>
@ -388,9 +389,9 @@ VOID TEST(KernelMp4Test, UUIDBoxDecode)
if (true) {
uint8_t data[24];
SrsBuffer b((char*)data, sizeof(data));
b.write_4bytes(8); b.write_4bytes(SrsMp4BoxTypeUUID); b.skip(-24);
b.write_4bytes(8); b.write_4bytes(SrsMp4BoxTypeUUID); b.skip(-8);
SrsMp4Box box;
HELPER_ASSERT_FAILED(box.decode(&b));
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
if (true) {
@ -1236,3 +1237,603 @@ VOID TEST(KernelMp4Test, HDLRBox)
}
}
VOID TEST(KernelMp4Test, URLBox)
{
srs_error_t err;
if (true) {
char buf[12+1];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4DataEntryUrlBox box;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps(ss, dc);
string v = ss.str();
EXPECT_STREQ("url , 13B, FB(4B,V0,0x01), URL: Same file", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4DataEntryUrlBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[12+2];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4DataEntryUrnBox box;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps(ss, dc);
string v = ss.str();
EXPECT_STREQ("urn , 14B, FB(4B,V0,0x01), URL: Same file", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4DataEntryUrnBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
SrsMp4DataReferenceBox box;
SrsMp4DataEntryUrnBox* urn = new SrsMp4DataEntryUrnBox();
box.append(urn);
EXPECT_TRUE(urn == box.entry_at(0));
}
if (true) {
char buf[12+4 + 12+2];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4DataReferenceBox box;
SrsMp4DataEntryUrnBox* urn = new SrsMp4DataEntryUrnBox();
box.append(urn);
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps(ss, dc);
string v = ss.str();
EXPECT_STREQ("dref, 30B, FB(4B), 1 childs(+)\n urn , 14B, FB(4B,V0,0x01), URL: Same file\n", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4DataReferenceBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
SrsMp4SampleTableBox box;
SrsMp4CompositionTime2SampleBox* ctts = new SrsMp4CompositionTime2SampleBox();
box.set_ctts(ctts);
EXPECT_TRUE(ctts == box.ctts());
}
}
VOID TEST(KernelMp4Test, SampleDescBox)
{
srs_error_t err;
if (true) {
char buf[8+8+70];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4VisualSampleEntry box;
box.data_reference_index = 1;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps(ss, dc);
string v = ss.str();
EXPECT_STREQ("avc1, 86B, refs#1, size=0x0\n", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4VisualSampleEntry box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[8];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4AvccBox box;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps(ss, dc);
string v = ss.str();
EXPECT_STREQ("avcC, 8B, AVC Config: 0B\n \n", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4AvccBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[8+8+20];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4AudioSampleEntry box;
box.data_reference_index = 1;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps(ss, dc);
string v = ss.str();
EXPECT_STREQ("mp4a, 36B, refs#1, 2 channels, 16 bits, 0 Hz\n", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4AudioSampleEntry box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
}
VOID TEST(KernelMp4Test, SpecificInfoBox)
{
srs_error_t err;
if (true) {
char buf[2+2];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4DecoderSpecificInfo box;
box.asc.resize(2);
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", tag=0x05, ASC 2B\n 0x00, 0x00", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4DecoderSpecificInfo box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[2+13];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4DecoderConfigDescriptor box;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", tag=0x04, type=0, stream=0\n decoder specific", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4DecoderConfigDescriptor box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[2+21];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4ES_Descriptor box;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", tag=0x03, ID=0\n decoder config, tag=0x04, type=0, stream=0\n decoder specific", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4DecoderConfigDescriptor box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
}
VOID TEST(KernelMp4Test, STSDBox)
{
srs_error_t err;
if (true) {
char buf[32];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4SampleDescriptionBox box;
box.entries.push_back(new SrsMp4SampleEntry());
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", FB(4B), 1 childs(+)\n ", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4SampleDescriptionBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[24];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4DecodingTime2SampleBox box;
box.entries.push_back(SrsMp4SttsEntry());
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", FB(4B), 1 childs (+)\n count=0, delta=0", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4DecodingTime2SampleBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[24];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4CompositionTime2SampleBox box;
box.entries.push_back(SrsMp4CttsEntry());
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", FB(4B), 1 childs (+)\n count=0, offset=0", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4CompositionTime2SampleBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[16];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4SyncSampleBox box;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", FB(4B), count=0", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4SyncSampleBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[16];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4Sample2ChunkBox box;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", FB(4B), 0 childs (+)", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4Sample2ChunkBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[16];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4ChunkOffsetBox box;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", FB(4B), 0 childs (+)", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4ChunkOffsetBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[16];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4ChunkLargeOffsetBox box;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", FB(4B), 0 childs (+)", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4ChunkLargeOffsetBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[20];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4SampleSizeBox box;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", FB(4B), size=0, 0 childs (+)", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4SampleSizeBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[10];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4UserDataBox box;
box.data.resize(2);
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", total 2B\n 0x00, 0x00", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4UserDataBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[32];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4SegmentIndexBox box;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_TRUE(v.length() > 0);
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4SegmentIndexBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
char buf[108];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4MovieHeaderBox box;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", FB(4B), 0ms, TBN=0, nTID=0", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4MovieHeaderBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
if (true) {
SrsMp4TrackBox box;
SrsMp4TrackHeaderBox* tkhd = new SrsMp4TrackHeaderBox();
box.set_tkhd(tkhd);
EXPECT_TRUE(tkhd == box.tkhd());
}
if (true) {
char buf[16];
SrsBuffer b(buf, sizeof(buf));
if (true) {
SrsMp4CompositionTime2SampleBox box;
EXPECT_EQ(sizeof(buf), box.nb_bytes());
HELPER_EXPECT_SUCCESS(box.encode(&b));
stringstream ss;
SrsMp4DumpContext dc;
box.dumps_detail(ss, dc);
string v = ss.str();
EXPECT_STREQ(", FB(4B), 0 childs (+)", v.c_str());
}
if (true) {
b.skip(-1 * b.pos());
SrsMp4CompositionTime2SampleBox box;
HELPER_EXPECT_SUCCESS(box.decode(&b));
}
}
}
VOID TEST(KernelMp4Test, SrsMp4M2tsInitEncoder)
{
srs_error_t err;
if (true) {
MockSrsFileWriter fw;
HELPER_ASSERT_SUCCESS(fw.open("test.mp4"));
SrsMp4M2tsInitEncoder enc;
HELPER_ASSERT_SUCCESS(enc.initialize(&fw));
SrsFormat fmt;
EXPECT_TRUE(srs_success == fmt.initialize());
uint8_t raw[] = {
0x17,
0x00, 0x00, 0x00, 0x00, 0x01, 0x64, 0x00, 0x20, 0xff, 0xe1, 0x00, 0x19, 0x67, 0x64, 0x00, 0x20,
0xac, 0xd9, 0x40, 0xc0, 0x29, 0xb0, 0x11, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03, 0x00,
0x32, 0x0f, 0x18, 0x31, 0x96, 0x01, 0x00, 0x05, 0x68, 0xeb, 0xec, 0xb2, 0x2c
};
EXPECT_TRUE(srs_success == fmt.on_video(0, (char*)raw, sizeof(raw)));
HELPER_ASSERT_SUCCESS(enc.write(&fmt, true, 1));
EXPECT_TRUE(fw.filesize() > 0);
}
if (true) {
MockSrsFileWriter fw;
HELPER_ASSERT_SUCCESS(fw.open("test.mp4"));
SrsMp4M2tsInitEncoder enc;
HELPER_ASSERT_SUCCESS(enc.initialize(&fw));
SrsFormat fmt;
EXPECT_TRUE(srs_success == fmt.initialize());
uint8_t raw[] = {
0xaf, 0x00, 0x12, 0x10
};
EXPECT_TRUE(srs_success == fmt.on_audio(0, (char*)raw, sizeof(raw)));
HELPER_ASSERT_SUCCESS(enc.write(&fmt, false, 1));
EXPECT_TRUE(fw.filesize() > 0);
}
}