diff --git a/.augment-guidelines b/.augment-guidelines
index 5f9fd49e5..fdc55b2ee 100644
--- a/.augment-guidelines
+++ b/.augment-guidelines
@@ -164,7 +164,7 @@ code_patterns:
naming_conventions:
- pattern: "field_naming"
- description: "MANDATORY - All class and struct fields must end with underscore (_)"
+ description: "MANDATORY - All class and struct fields (member variables) must end with underscore (_), but NOT functions/methods"
usage: |
WRONG: Fields without underscore
class SrsBuffer {
@@ -175,17 +175,19 @@ code_patterns:
bool enabled;
};
- CORRECT: Fields with underscore
+ CORRECT: Fields with underscore, functions without underscore
class SrsBuffer {
private:
char *p_;
int size_;
public:
bool enabled_;
+ public:
+ srs_error_t initialize();
};
- scope: "Applies to ALL fields (private, protected, public) in both classes and structs"
+ scope: "Applies ONLY to fields (member variables) in classes and structs - NOT to functions, methods, or parameters"
exceptions: "Only applies to SRS-defined classes/structs - do NOT change 3rd party code like llhttp"
- rationale: "Consistent naming convention across SRS codebase for better code readability and maintenance"
+ rationale: "Consistent naming convention across SRS codebase for better code readability and maintenance - underscore distinguishes member variables from local variables and parameters"
commenting_style:
- pattern: "C++ style comments"
diff --git a/trunk/configure b/trunk/configure
index bb8c7dc37..1e12cf5fc 100755
--- a/trunk/configure
+++ b/trunk/configure
@@ -378,7 +378,7 @@ if [[ $SRS_UTEST == YES ]]; then
"srs_utest_mp4" "srs_utest_service" "srs_utest_app" "srs_utest_rtc" "srs_utest_config2"
"srs_utest_protocol" "srs_utest_protocol2" "srs_utest_kernel2" "srs_utest_protocol3"
"srs_utest_st" "srs_utest_rtc2" "srs_utest_rtc3" "srs_utest_fmp4" "srs_utest_source_lock"
- "srs_utest_stream_token" "srs_utest_rtc_recv_track" "srs_utest_st2")
+ "srs_utest_stream_token" "srs_utest_rtc_recv_track" "srs_utest_st2" "srs_utest_hevc_structs")
# Always include SRT utest
MODULE_FILES+=("srs_utest_srt")
if [[ $SRS_GB28181 == YES ]]; then
diff --git a/trunk/doc/CHANGELOG.md b/trunk/doc/CHANGELOG.md
index e73f301ad..fd4565d2b 100644
--- a/trunk/doc/CHANGELOG.md
+++ b/trunk/doc/CHANGELOG.md
@@ -7,6 +7,7 @@ The changelog for SRS.
## SRS 7.0 Changelog
+* v7.0, 2025-09-07, Merge [#4479](https://github.com/ossrs/srs/pull/4479): AI: Fix naming problem in kernel module. v7.0.82 (#4479)
* v7.0, 2025-09-06, Merge [#4478](https://github.com/ossrs/srs/pull/4478): AI: Add more utests for kernel module. v7.0.81 (#4478)
* v7.0, 2025-09-06, Merge [#4475](https://github.com/ossrs/srs/pull/4475): AI: Support anonymous coroutine with code block. v7.0.80 (#4475)
* v7.0, 2025-09-05, Merge [#4474](https://github.com/ossrs/srs/pull/4474): WebRTC: Fix race condition in RTC nack timer callbacks. v7.0.79 (#4474)
diff --git a/trunk/src/app/srs_app_conn.cpp b/trunk/src/app/srs_app_conn.cpp
index fd86ba936..0df8c4333 100644
--- a/trunk/src/app/srs_app_conn.cpp
+++ b/trunk/src/app/srs_app_conn.cpp
@@ -179,7 +179,7 @@ ISrsResource *SrsResourceManager::at(int index)
ISrsResource *SrsResourceManager::find_by_id(std::string id)
{
- ++_srs_pps_ids->sugar;
+ ++_srs_pps_ids->sugar_;
map::iterator it = conns_id_.find(id);
return (it != conns_id_.end()) ? it->second : NULL;
}
@@ -188,18 +188,18 @@ ISrsResource *SrsResourceManager::find_by_fast_id(uint64_t id)
{
SrsResourceFastIdItem *item = &conns_level0_cache_[(id | id >> 32) % nn_level0_cache_];
if (item->available && item->fast_id == id) {
- ++_srs_pps_fids_level0->sugar;
+ ++_srs_pps_fids_level0->sugar_;
return item->impl;
}
- ++_srs_pps_fids->sugar;
+ ++_srs_pps_fids->sugar_;
map::iterator it = conns_fast_id_.find(id);
return (it != conns_fast_id_.end()) ? it->second : NULL;
}
ISrsResource *SrsResourceManager::find_by_name(std::string name)
{
- ++_srs_pps_ids->sugar;
+ ++_srs_pps_ids->sugar_;
map::iterator it = conns_name_.find(name);
return (it != conns_name_.end()) ? it->second : NULL;
}
@@ -334,7 +334,7 @@ void SrsResourceManager::do_clear()
i, conn->desc().c_str(), conn, (int)conns_.size(), (int)copy.size(), (int)zombies_.size());
}
- ++_srs_pps_dispose->sugar;
+ ++_srs_pps_dispose->sugar_;
dispose(conn);
}
diff --git a/trunk/src/app/srs_app_dash.cpp b/trunk/src/app/srs_app_dash.cpp
index 3cec13ada..04ae7ab9c 100644
--- a/trunk/src/app/srs_app_dash.cpp
+++ b/trunk/src/app/srs_app_dash.cpp
@@ -117,26 +117,26 @@ srs_error_t SrsFragmentedMp4::write(SrsMediaPacket *shared_msg, SrsFormat *forma
srs_error_t err = srs_success;
if (shared_msg->is_audio()) {
- uint8_t *sample = (uint8_t *)format->raw;
- uint32_t nb_sample = (uint32_t)format->nb_raw;
+ uint8_t *sample = (uint8_t *)format->raw_;
+ uint32_t nb_sample = (uint32_t)format->nb_raw_;
- uint32_t dts = (uint32_t)shared_msg->timestamp;
+ uint32_t dts = (uint32_t)shared_msg->timestamp_;
err = enc->write_sample(SrsMp4HandlerTypeSOUN, 0x00, dts, dts, sample, nb_sample);
} else if (shared_msg->is_video()) {
- SrsVideoAvcFrameType frame_type = format->video->frame_type;
- uint32_t cts = (uint32_t)format->video->cts;
+ SrsVideoAvcFrameType frame_type = format->video_->frame_type_;
+ uint32_t cts = (uint32_t)format->video_->cts_;
- uint32_t dts = (uint32_t)shared_msg->timestamp;
+ uint32_t dts = (uint32_t)shared_msg->timestamp_;
uint32_t pts = dts + cts;
- uint8_t *sample = (uint8_t *)format->raw;
- uint32_t nb_sample = (uint32_t)format->nb_raw;
+ uint8_t *sample = (uint8_t *)format->raw_;
+ uint32_t nb_sample = (uint32_t)format->nb_raw_;
err = enc->write_sample(SrsMp4HandlerTypeVIDE, frame_type, dts, pts, sample, nb_sample);
} else {
return err;
}
- append(shared_msg->timestamp);
+ append(shared_msg->timestamp_);
return err;
}
@@ -258,7 +258,7 @@ srs_error_t SrsMpdWriter::write(SrsFormat *format, SrsFragmentWindow *afragments
ss << " " << endl;
- if (format->acodec && !afragments->empty()) {
+ if (format->acodec_ && !afragments->empty()) {
int start_index = srs_max(0, afragments->size() - window_size_);
ss << " " << endl;
ss << " " << endl;
@@ -277,10 +277,10 @@ srs_error_t SrsMpdWriter::write(SrsFormat *format, SrsFragmentWindow *afragments
ss << " " << endl;
}
- if (format->vcodec && !vfragments->empty()) {
+ if (format->vcodec_ && !vfragments->empty()) {
int start_index = srs_max(0, vfragments->size() - window_size_);
- int w = format->vcodec->width;
- int h = format->vcodec->height;
+ int w = format->vcodec_->width_;
+ int h = format->vcodec_->height_;
ss << " " << endl;
ss << " " << endl;
ss << " timestamp;
+ audio_dts = shared_audio->timestamp_;
if (!acurrent) {
acurrent = new SrsFragmentedMp4();
@@ -510,7 +510,7 @@ srs_error_t SrsDashController::on_audio(SrsMediaPacket *shared_audio, SrsFormat
// The video is reaped, audio must be reaped right now to align the timestamp of video.
video_reaped_ = false;
// Append current timestamp to calculate right duration.
- acurrent->append(shared_audio->timestamp);
+ acurrent->append(shared_audio->timestamp_);
if ((err = acurrent->reap(audio_dts)) != srs_success) {
return srs_error_wrap(err, "reap current");
}
@@ -562,7 +562,7 @@ srs_error_t SrsDashController::on_video(SrsMediaPacket *shared_video, SrsFormat
return refresh_init_mp4(shared_video, format);
}
- video_dts = shared_video->timestamp;
+ video_dts = shared_video->timestamp_;
if (!vcurrent) {
vcurrent = new SrsFragmentedMp4();
@@ -577,10 +577,10 @@ srs_error_t SrsDashController::on_video(SrsMediaPacket *shared_video, SrsFormat
mpd->set_availability_start_time(srs_time_now_cached() - first_dts_ * SRS_UTIME_MILLISECONDS);
}
- bool reopen = format->video->frame_type == SrsVideoAvcFrameTypeKeyFrame && vcurrent->duration() >= fragment;
+ bool reopen = format->video_->frame_type_ == SrsVideoAvcFrameTypeKeyFrame && vcurrent->duration() >= fragment;
if (reopen) {
// Append current timestamp to calculate right duration.
- vcurrent->append(shared_video->timestamp);
+ vcurrent->append(shared_video->timestamp_);
if ((err = vcurrent->reap(video_dts)) != srs_success) {
return srs_error_wrap(err, "reap current");
}
@@ -630,7 +630,7 @@ srs_error_t SrsDashController::refresh_mpd(SrsFormat *format)
srs_error_t err = srs_success;
// TODO: FIXME: Support pure audio streaming.
- if (!format || !format->acodec || !format->vcodec) {
+ if (!format || !format->acodec_ || !format->vcodec_) {
return err;
}
@@ -645,7 +645,7 @@ srs_error_t SrsDashController::refresh_init_mp4(SrsMediaPacket *msg, SrsFormat *
{
srs_error_t err = srs_success;
- if (msg->size() <= 0 || (msg->is_video() && !format->vcodec->is_avc_codec_ok()) || (msg->is_audio() && !format->acodec->is_aac_codec_ok())) {
+ if (msg->size() <= 0 || (msg->is_video() && !format->vcodec_->is_avc_codec_ok()) || (msg->is_audio() && !format->acodec_->is_aac_codec_ok())) {
srs_warn("DASH: Ignore empty sequence header.");
return err;
}
@@ -804,7 +804,7 @@ srs_error_t SrsDash::on_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
return err;
}
- if (!format->acodec) {
+ if (!format->acodec_) {
return err;
}
@@ -826,7 +826,7 @@ srs_error_t SrsDash::on_video(SrsMediaPacket *shared_video, SrsFormat *format)
return err;
}
- if (!format->vcodec) {
+ if (!format->vcodec_) {
return err;
}
diff --git a/trunk/src/app/srs_app_dvr.cpp b/trunk/src/app/srs_app_dvr.cpp
index c0f36c5b3..6bd4e2219 100644
--- a/trunk/src/app/srs_app_dvr.cpp
+++ b/trunk/src/app/srs_app_dvr.cpp
@@ -217,7 +217,7 @@ string SrsDvrSegmenter::generate_path()
srs_error_t SrsDvrSegmenter::on_update_duration(SrsMediaPacket *msg)
{
- fragment->append(msg->timestamp);
+ fragment->append(msg->timestamp_);
return srs_success;
}
@@ -372,7 +372,7 @@ srs_error_t SrsDvrFlvSegmenter::encode_audio(SrsMediaPacket *audio, SrsFormat *f
char *payload = audio->payload();
int size = audio->size();
- if ((err = enc->write_audio(audio->timestamp, payload, size)) != srs_success) {
+ if ((err = enc->write_audio(audio->timestamp_, payload, size)) != srs_success) {
return srs_error_wrap(err, "write audio");
}
@@ -385,8 +385,8 @@ srs_error_t SrsDvrFlvSegmenter::encode_video(SrsMediaPacket *video, SrsFormat *f
char *payload = video->payload();
int size = video->size();
- bool sh = (format->video->avc_packet_type == SrsVideoAvcFrameTraitSequenceHeader);
- bool keyframe = (!sh && format->video->frame_type == SrsVideoAvcFrameTypeKeyFrame);
+ bool sh = (format->video_->avc_packet_type_ == SrsVideoAvcFrameTraitSequenceHeader);
+ bool keyframe = (!sh && format->video_->frame_type_ == SrsVideoAvcFrameTypeKeyFrame);
if (keyframe) {
has_keyframe = true;
@@ -398,7 +398,7 @@ srs_error_t SrsDvrFlvSegmenter::encode_video(SrsMediaPacket *video, SrsFormat *f
return err;
}
- if ((err = enc->write_video(video->timestamp, payload, size)) != srs_success) {
+ if ((err = enc->write_video(video->timestamp_, payload, size)) != srs_success) {
return srs_error_wrap(err, "write video");
}
@@ -448,23 +448,23 @@ srs_error_t SrsDvrMp4Segmenter::encode_audio(SrsMediaPacket *audio, SrsFormat *f
{
srs_error_t err = srs_success;
- SrsAudioCodecId sound_format = format->acodec->id;
- SrsAudioSampleRate sound_rate = format->acodec->sound_rate;
- SrsAudioSampleBits sound_size = format->acodec->sound_size;
- SrsAudioChannels channels = format->acodec->sound_type;
+ SrsAudioCodecId sound_format = format->acodec_->id_;
+ SrsAudioSampleRate sound_rate = format->acodec_->sound_rate_;
+ SrsAudioSampleBits sound_size = format->acodec_->sound_size_;
+ SrsAudioChannels channels = format->acodec_->sound_type_;
- SrsAudioAacFrameTrait ct = format->audio->aac_packet_type;
+ SrsAudioAacFrameTrait ct = format->audio_->aac_packet_type_;
if (ct == SrsAudioAacFrameTraitSequenceHeader || ct == SrsAudioMp3FrameTraitSequenceHeader) {
- enc->acodec = sound_format;
- enc->sample_rate = sound_rate;
- enc->sound_bits = sound_size;
- enc->channels = channels;
+ enc->acodec_ = sound_format;
+ enc->sample_rate_ = sound_rate;
+ enc->sound_bits_ = sound_size;
+ enc->channels_ = channels;
}
- uint8_t *sample = (uint8_t *)format->raw;
- uint32_t nb_sample = (uint32_t)format->nb_raw;
+ uint8_t *sample = (uint8_t *)format->raw_;
+ uint32_t nb_sample = (uint32_t)format->nb_raw_;
- uint32_t dts = (uint32_t)audio->timestamp;
+ uint32_t dts = (uint32_t)audio->timestamp_;
if ((err = enc->write_sample(format, SrsMp4HandlerTypeSOUN, 0x00, ct, dts, dts, sample, nb_sample)) != srs_success) {
return srs_error_wrap(err, "write sample");
}
@@ -476,21 +476,21 @@ srs_error_t SrsDvrMp4Segmenter::encode_video(SrsMediaPacket *video, SrsFormat *f
{
srs_error_t err = srs_success;
- SrsVideoAvcFrameType frame_type = format->video->frame_type;
- SrsVideoCodecId codec_id = format->vcodec->id;
+ SrsVideoAvcFrameType frame_type = format->video_->frame_type_;
+ SrsVideoCodecId codec_id = format->vcodec_->id_;
- SrsVideoAvcFrameTrait ct = format->video->avc_packet_type;
- uint32_t cts = (uint32_t)format->video->cts;
+ SrsVideoAvcFrameTrait ct = format->video_->avc_packet_type_;
+ uint32_t cts = (uint32_t)format->video_->cts_;
if (ct == SrsVideoAvcFrameTraitSequenceHeader) {
- enc->vcodec = codec_id;
+ enc->vcodec_ = codec_id;
}
- uint32_t dts = (uint32_t)video->timestamp;
+ uint32_t dts = (uint32_t)video->timestamp_;
uint32_t pts = dts + cts;
- uint8_t *sample = (uint8_t *)format->raw;
- uint32_t nb_sample = (uint32_t)format->nb_raw;
+ uint8_t *sample = (uint8_t *)format->raw_;
+ uint32_t nb_sample = (uint32_t)format->nb_raw_;
if ((err = enc->write_sample(format, SrsMp4HandlerTypeVIDE, frame_type, ct, dts, pts, sample, nb_sample)) != srs_success) {
return srs_error_wrap(err, "write sample");
}
diff --git a/trunk/src/app/srs_app_edge.cpp b/trunk/src/app/srs_app_edge.cpp
index fd0686b0a..0fdd8b004 100644
--- a/trunk/src/app/srs_app_edge.cpp
+++ b/trunk/src/app/srs_app_edge.cpp
@@ -339,7 +339,7 @@ srs_error_t SrsEdgeFlvUpstream::decode_message(SrsRtmpCommonMessage *msg, SrsRtm
SrsRtmpCommand *packet = NULL;
SrsBuffer stream(msg->payload(), msg->size());
- SrsMessageHeader &header = msg->header;
+ SrsMessageHeader &header = msg->header_;
if (header.is_amf0_data() || header.is_amf3_data()) {
std::string command;
@@ -619,21 +619,21 @@ srs_error_t SrsEdgeIngester::process_publish_message(SrsRtmpCommonMessage *msg,
srs_error_t err = srs_success;
// process audio packet
- if (msg->header.is_audio()) {
+ if (msg->header_.is_audio()) {
if ((err = source_->on_audio(msg)) != srs_success) {
return srs_error_wrap(err, "source consume audio");
}
}
// process video packet
- if (msg->header.is_video()) {
+ if (msg->header_.is_video()) {
if ((err = source_->on_video(msg)) != srs_success) {
return srs_error_wrap(err, "source consume video");
}
}
// process aggregate packet
- if (msg->header.is_aggregate()) {
+ if (msg->header_.is_aggregate()) {
if ((err = source_->on_aggregate(msg)) != srs_success) {
return srs_error_wrap(err, "source consume aggregate");
}
@@ -641,7 +641,7 @@ srs_error_t SrsEdgeIngester::process_publish_message(SrsRtmpCommonMessage *msg,
}
// process onMetaData
- if (msg->header.is_amf0_data() || msg->header.is_amf3_data()) {
+ if (msg->header_.is_amf0_data() || msg->header_.is_amf3_data()) {
SrsRtmpCommand *pkt_raw = NULL;
if ((err = upstream->decode_message(msg, &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "decode message");
@@ -660,7 +660,7 @@ srs_error_t SrsEdgeIngester::process_publish_message(SrsRtmpCommonMessage *msg,
}
// call messages, for example, reject, redirect.
- if (msg->header.is_amf0_command() || msg->header.is_amf3_command()) {
+ if (msg->header_.is_amf0_command() || msg->header_.is_amf3_command()) {
SrsRtmpCommand *pkt_raw = NULL;
if ((err = upstream->decode_message(msg, &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "decode message");
@@ -919,14 +919,14 @@ srs_error_t SrsEdgeForwarder::proxy(SrsRtmpCommonMessage *msg)
// the msg is auto free by source,
// so we just ignore, or copy then send it.
- if (msg->size() <= 0 || msg->header.is_set_chunk_size() || msg->header.is_window_ackledgement_size() || msg->header.is_ackledgement()) {
+ if (msg->size() <= 0 || msg->header_.is_set_chunk_size() || msg->header_.is_window_ackledgement_size() || msg->header_.is_ackledgement()) {
return err;
}
SrsMediaPacket copy;
msg->to_msg(©);
- copy.stream_id = sdk->sid();
+ copy.stream_id_ = sdk->sid();
if ((err = queue->enqueue(copy.copy())) != srs_success) {
return srs_error_wrap(err, "enqueue message");
}
diff --git a/trunk/src/app/srs_app_gb28181.cpp b/trunk/src/app/srs_app_gb28181.cpp
index 46896e239..6eabd570d 100644
--- a/trunk/src/app/srs_app_gb28181.cpp
+++ b/trunk/src/app/srs_app_gb28181.cpp
@@ -145,12 +145,12 @@ void SrsGbSession::on_ps_pack(SrsPackContext *ctx, SrsPsPacket *ps, const std::v
SrsTsMessage *msg = *it;
// Group all videos to one video.
- if (msg->sid == SrsTsPESStreamIdVideoCommon) {
+ if (msg->sid_ == SrsTsPESStreamIdVideoCommon) {
video->ps_helper_ = msg->ps_helper_;
- video->dts = msg->dts;
- video->pts = msg->pts;
- video->sid = msg->sid;
- video->payload->append(msg->payload);
+ video->dts_ = msg->dts_;
+ video->pts_ = msg->pts_;
+ video->sid_ = msg->sid_;
+ video->payload_->append(msg->payload_);
continue;
}
@@ -163,7 +163,7 @@ void SrsGbSession::on_ps_pack(SrsPackContext *ctx, SrsPsPacket *ps, const std::v
}
// Send the generated video message.
- if (video->payload->length() > 0) {
+ if (video->payload_->length() > 0) {
srs_error_t err = muxer_->on_ts_message(video.get());
if (err != srs_success) {
srs_warn("Muxer: Ignore video err %s", srs_error_desc(err).c_str());
@@ -672,15 +672,15 @@ srs_error_t SrsMpegpsQueue::push(SrsMediaPacket *msg)
// TODO: FIXME: use right way.
for (int i = 0; i < 10; i++) {
- if (msgs.find(msg->timestamp) == msgs.end()) {
+ if (msgs.find(msg->timestamp_) == msgs.end()) {
break;
}
// adjust the ts, add 1ms.
- msg->timestamp += 1;
+ msg->timestamp_ += 1;
if (i >= 100) {
- srs_warn("Muxer: free the msg for dts exists, dts=%" PRId64, msg->timestamp);
+ srs_warn("Muxer: free the msg for dts exists, dts=%" PRId64, msg->timestamp_);
srs_freep(msg);
return err;
}
@@ -694,7 +694,7 @@ srs_error_t SrsMpegpsQueue::push(SrsMediaPacket *msg)
nb_videos++;
}
- msgs[msg->timestamp] = msg;
+ msgs[msg->timestamp_] = msg;
return err;
}
@@ -765,8 +765,8 @@ srs_error_t SrsGbMuxer::on_ts_message(SrsTsMessage *msg)
{
srs_error_t err = srs_success;
- SrsBuffer avs(msg->payload->bytes(), msg->payload->length());
- if (msg->sid == SrsTsPESStreamIdVideoCommon) {
+ SrsBuffer avs(msg->payload_->bytes(), msg->payload_->length());
+ if (msg->sid_ == SrsTsPESStreamIdVideoCommon) {
if ((err = on_ts_video(msg, &avs)) != srs_success) {
return srs_error_wrap(err, "ts: consume video");
}
@@ -811,8 +811,8 @@ srs_error_t SrsGbMuxer::mux_h264(SrsTsMessage *msg, SrsBuffer *avs)
srs_error_t err = srs_success;
// ts tbn to flv tbn.
- uint32_t dts = (uint32_t)(msg->dts / 90);
- uint32_t pts = (uint32_t)(msg->dts / 90);
+ uint32_t dts = (uint32_t)(msg->dts_ / 90);
+ uint32_t pts = (uint32_t)(msg->dts_ / 90);
// send each frame.
while (!avs->empty()) {
@@ -972,8 +972,8 @@ srs_error_t SrsGbMuxer::mux_h265(SrsTsMessage *msg, SrsBuffer *avs)
srs_error_t err = srs_success;
// ts tbn to flv tbn.
- uint32_t dts = (uint32_t)(msg->dts / 90);
- uint32_t pts = (uint32_t)(msg->dts / 90);
+ uint32_t dts = (uint32_t)(msg->dts_ / 90);
+ uint32_t pts = (uint32_t)(msg->dts_ / 90);
// send each frame.
while (!avs->empty()) {
@@ -1154,7 +1154,7 @@ srs_error_t SrsGbMuxer::on_ts_audio(SrsTsMessage *msg, SrsBuffer *avs)
}
// ts tbn to flv tbn.
- uint32_t dts = (uint32_t)(msg->dts / 90);
+ uint32_t dts = (uint32_t)(msg->dts_ / 90);
// send each frame.
while (!avs->empty()) {
@@ -1242,7 +1242,7 @@ srs_error_t SrsGbMuxer::rtmp_write_packet(char type, uint32_t timestamp, char *d
srs_trace("Muxer: send msg %s age=%d, dts=%" PRId64 ", size=%d",
msg->is_audio() ? "A" : msg->is_video() ? "V"
: "N",
- pprint_->age(), msg->timestamp, msg->size());
+ pprint_->age(), msg->timestamp_, msg->size());
}
// send out encoded msg.
@@ -1346,12 +1346,12 @@ srs_error_t SrsPackContext::on_ts_message(SrsTsMessage *msg)
//}
// Correct DTS/PS to the last one.
- if (!msgs_.empty() && (!msg->dts || !msg->pts)) {
+ if (!msgs_.empty() && (!msg->dts_ || !msg->pts_)) {
SrsTsMessage *last = msgs_.back();
- if (!msg->dts)
- msg->dts = last->dts;
- if (!msg->pts)
- msg->pts = last->pts;
+ if (!msg->dts_)
+ msg->dts_ = last->dts_;
+ if (!msg->pts_)
+ msg->pts_ = last->pts_;
}
// uint8_t* p = (uint8_t*)msg->payload->bytes();
@@ -1424,14 +1424,14 @@ srs_error_t SrsRecoverablePsContext::decode_rtp(SrsBuffer *stream, int reserved,
memmove(dst, src, reserved);
// The payload also should skip back to the reserved bytes.
- rtp_raw->payload -= reserved;
- rtp_raw->nn_payload += reserved;
+ rtp_raw->payload_ -= reserved;
+ rtp_raw->nn_payload_ += reserved;
// The stream also skip back to the not parsed bytes.
stream->skip(-1 * reserved);
}
- SrsBuffer b((char *)rtp_raw->payload, rtp_raw->nn_payload);
+ SrsBuffer b((char *)rtp_raw->payload_, rtp_raw->nn_payload_);
// srs_trace("GB: Got RTP length=%d, payload=%d, seq=%u, ts=%d", length, rtp_raw->nn_payload, rtp.header.get_sequence(), rtp.header.get_timestamp());
ctx_.helper_.rtp_seq_ = rtp.header.get_sequence();
@@ -1488,7 +1488,7 @@ srs_error_t SrsRecoverablePsContext::enter_recover_mode(SrsBuffer *stream, ISrsP
uint16_t lsopm = h.pack_pre_msg_last_seq_;
SrsTsMessage *last = ctx_.last();
srs_warn("PS: Enter recover=%d, seq=%u, ts=%u, pt=%u, pack=%u, msgs=%u, lsopm=%u, last=%u/%u, bytes=[%s], pos=%d, left=%d for err %s",
- recover_, h.rtp_seq_, h.rtp_ts_, h.rtp_pt_, pack_seq, pack_msgs, lsopm, last->PES_packet_length, last->payload->length(),
+ recover_, h.rtp_seq_, h.rtp_ts_, h.rtp_pt_, pack_seq, pack_msgs, lsopm, last->PES_packet_length_, last->payload_->length(),
bytes.c_str(), npos, stream->left(), srs_error_desc(err).c_str());
// If RTP packet exceed SRS_GB_LARGE_PACKET, which is large packet, might be correct length and impossible to
diff --git a/trunk/src/app/srs_app_hds.cpp b/trunk/src/app/srs_app_hds.cpp
index ac2ba9bb5..9c3336a91 100644
--- a/trunk/src/app/srs_app_hds.cpp
+++ b/trunk/src/app/srs_app_hds.cpp
@@ -46,7 +46,7 @@ string serialFlv(SrsMediaPacket *msg)
SrsUniquePtr stream(new SrsBuffer(byte, size));
// tag header
- long long dts = msg->timestamp;
+ long long dts = msg->timestamp_;
char type = msg->is_video() ? 0x09 : 0x08;
stream->write_1bytes(type);
diff --git a/trunk/src/app/srs_app_hls.cpp b/trunk/src/app/srs_app_hls.cpp
index 33b552f75..70bcffec1 100644
--- a/trunk/src/app/srs_app_hls.cpp
+++ b/trunk/src/app/srs_app_hls.cpp
@@ -208,22 +208,22 @@ srs_error_t SrsHlsM4sSegment::write(SrsMediaPacket *shared_msg, SrsFormat *forma
srs_error_t err = srs_success;
if (shared_msg->is_audio()) {
- uint8_t *sample = (uint8_t *)format->raw;
- uint32_t nb_sample = (uint32_t)format->nb_raw;
+ uint8_t *sample = (uint8_t *)format->raw_;
+ uint32_t nb_sample = (uint32_t)format->nb_raw_;
- uint32_t dts = (uint32_t)shared_msg->timestamp;
+ uint32_t dts = (uint32_t)shared_msg->timestamp_;
if ((err = enc_.write_sample(SrsMp4HandlerTypeSOUN, 0x00, dts, dts, sample, nb_sample)) != srs_success) {
return srs_error_wrap(err, "m4s segment write audio sample");
}
} else if (shared_msg->is_video()) {
- SrsVideoAvcFrameType frame_type = format->video->frame_type;
- uint32_t cts = (uint32_t)format->video->cts;
+ SrsVideoAvcFrameType frame_type = format->video_->frame_type_;
+ uint32_t cts = (uint32_t)format->video_->cts_;
- uint32_t dts = (uint32_t)shared_msg->timestamp;
+ uint32_t dts = (uint32_t)shared_msg->timestamp_;
uint32_t pts = dts + cts;
- uint8_t *sample = (uint8_t *)format->raw;
- uint32_t nb_sample = (uint32_t)format->nb_raw;
+ uint8_t *sample = (uint8_t *)format->raw_;
+ uint32_t nb_sample = (uint32_t)format->nb_raw_;
if ((err = enc_.write_sample(SrsMp4HandlerTypeVIDE, frame_type, dts, pts, sample, nb_sample)) != srs_success) {
return srs_error_wrap(err, "m4s segment write video sample");
}
@@ -232,7 +232,7 @@ srs_error_t SrsHlsM4sSegment::write(SrsMediaPacket *shared_msg, SrsFormat *forma
return err;
}
- append(shared_msg->timestamp);
+ append(shared_msg->timestamp_);
return err;
}
@@ -585,7 +585,7 @@ srs_error_t SrsHlsFmp4Muxer::write_audio(SrsMediaPacket *shared_audio, SrsFormat
srs_error_t err = srs_success;
if (!current_) {
- if ((err = segment_open(shared_audio->timestamp * SRS_UTIME_MILLISECONDS)) != srs_success) {
+ if ((err = segment_open(shared_audio->timestamp_ * SRS_UTIME_MILLISECONDS)) != srs_success) {
return srs_error_wrap(err, "open segment");
}
}
@@ -595,7 +595,7 @@ srs_error_t SrsHlsFmp4Muxer::write_audio(SrsMediaPacket *shared_audio, SrsFormat
return srs_error_wrap(err, "segment close");
}
- if ((err = segment_open(shared_audio->timestamp * SRS_UTIME_MILLISECONDS)) != srs_success) {
+ if ((err = segment_open(shared_audio->timestamp_ * SRS_UTIME_MILLISECONDS)) != srs_success) {
return srs_error_wrap(err, "open segment");
}
}
@@ -608,10 +608,10 @@ srs_error_t SrsHlsFmp4Muxer::write_video(SrsMediaPacket *shared_video, SrsFormat
{
srs_error_t err = srs_success;
- video_dts_ = shared_video->timestamp;
+ video_dts_ = shared_video->timestamp_;
if (!current_) {
- if ((err = segment_open(shared_video->timestamp * SRS_UTIME_MILLISECONDS)) != srs_success) {
+ if ((err = segment_open(shared_video->timestamp_ * SRS_UTIME_MILLISECONDS)) != srs_success) {
return srs_error_wrap(err, "open segment");
}
}
@@ -622,7 +622,7 @@ srs_error_t SrsHlsFmp4Muxer::write_video(SrsMediaPacket *shared_video, SrsFormat
return srs_error_wrap(err, "segment close");
}
- if ((err = segment_open(shared_video->timestamp * SRS_UTIME_MILLISECONDS)) != srs_success) {
+ if ((err = segment_open(shared_video->timestamp_ * SRS_UTIME_MILLISECONDS)) != srs_success) {
return srs_error_wrap(err, "open segment");
}
}
@@ -1593,19 +1593,19 @@ srs_error_t SrsHlsMuxer::flush_audio(SrsTsMessageCache *cache)
return err;
}
- if (!cache->audio || cache->audio->payload->length() <= 0) {
+ if (!cache->audio_ || cache->audio_->payload_->length() <= 0) {
return err;
}
// update the duration of segment.
- update_duration(cache->audio->dts);
+ update_duration(cache->audio_->dts_);
- if ((err = current->tscw->write_audio(cache->audio)) != srs_success) {
+ if ((err = current->tscw->write_audio(cache->audio_)) != srs_success) {
return srs_error_wrap(err, "hls: write audio");
}
// write success, clear and free the msg
- srs_freep(cache->audio);
+ srs_freep(cache->audio_);
return err;
}
@@ -1620,21 +1620,21 @@ srs_error_t SrsHlsMuxer::flush_video(SrsTsMessageCache *cache)
return err;
}
- if (!cache->video || cache->video->payload->length() <= 0) {
+ if (!cache->video_ || cache->video_->payload_->length() <= 0) {
return err;
}
srs_assert(current);
// update the duration of segment.
- update_duration(cache->video->dts);
+ update_duration(cache->video_->dts_);
- if ((err = current->tscw->write_video(cache->video)) != srs_success) {
+ if ((err = current->tscw->write_video(cache->video_)) != srs_success) {
return srs_error_wrap(err, "hls: write video");
}
// write success, clear and free the msg
- srs_freep(cache->video);
+ srs_freep(cache->video_);
return err;
}
@@ -2053,24 +2053,24 @@ srs_error_t SrsHlsController::on_sequence_header(SrsMediaPacket *msg, SrsFormat
srs_error_t SrsHlsController::write_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
{
srs_error_t err = srs_success;
- SrsParsedAudioPacket *frame = format->audio;
+ SrsParsedAudioPacket *frame = format->audio_;
// Reset the aac samples counter when DTS jitter.
- if (previous_audio_dts > shared_audio->timestamp) {
- previous_audio_dts = shared_audio->timestamp;
+ if (previous_audio_dts > shared_audio->timestamp_) {
+ previous_audio_dts = shared_audio->timestamp_;
aac_samples = 0;
}
// The diff duration in ms between two FLV audio packets.
- int diff = ::abs((int)(shared_audio->timestamp - previous_audio_dts));
- previous_audio_dts = shared_audio->timestamp;
+ int diff = ::abs((int)(shared_audio->timestamp_ - previous_audio_dts));
+ previous_audio_dts = shared_audio->timestamp_;
// Guess the number of samples for each AAC frame.
// If samples is 1024, the sample-rate is 8000HZ, the diff should be 1024/8000s=128ms.
// If samples is 1024, the sample-rate is 44100HZ, the diff should be 1024/44100s=23ms.
// If samples is 2048, the sample-rate is 44100HZ, the diff should be 2048/44100s=46ms.
int nb_samples_per_frame = 0;
- int guessNumberOfSamples = diff * srs_flv_srates[format->acodec->sound_rate] / 1000;
+ int guessNumberOfSamples = diff * srs_flv_srates[format->acodec_->sound_rate_] / 1000;
if (guessNumberOfSamples > 0) {
if (guessNumberOfSamples < 960) {
nb_samples_per_frame = 960;
@@ -2085,19 +2085,19 @@ srs_error_t SrsHlsController::write_audio(SrsMediaPacket *shared_audio, SrsForma
// Recalc the DTS by the samples of AAC.
aac_samples += nb_samples_per_frame;
- int64_t dts = 90000 * aac_samples / srs_flv_srates[format->acodec->sound_rate];
+ int64_t dts = 90000 * aac_samples / srs_flv_srates[format->acodec_->sound_rate_];
// If directly turn FLV timestamp, overwrite the guessed DTS.
// @doc https://github.com/ossrs/srs/issues/1506#issuecomment-562063095
if (hls_dts_directly) {
- dts = shared_audio->timestamp * 90;
+ dts = shared_audio->timestamp_ * 90;
}
// Refresh the codec ASAP.
- if (muxer->latest_acodec() != frame->acodec()->id) {
+ if (muxer->latest_acodec() != frame->acodec()->id_) {
srs_trace("HLS: Switch audio codec %d(%s) to %d(%s)", muxer->latest_acodec(), srs_audio_codec_id2str(muxer->latest_acodec()).c_str(),
- frame->acodec()->id, srs_audio_codec_id2str(frame->acodec()->id).c_str());
- muxer->set_latest_acodec(frame->acodec()->id);
+ frame->acodec()->id_, srs_audio_codec_id2str(frame->acodec()->id_).c_str());
+ muxer->set_latest_acodec(frame->acodec()->id_);
}
// write audio to cache.
@@ -2107,7 +2107,7 @@ srs_error_t SrsHlsController::write_audio(SrsMediaPacket *shared_audio, SrsForma
// First, update the duration of the segment, as we might reap the segment. The duration should
// cover from the first frame to the last frame.
- muxer->update_duration(tsmc->audio->dts);
+ muxer->update_duration(tsmc->audio_->dts_);
// reap when current source is pure audio.
// it maybe changed when stream info changed,
@@ -2115,7 +2115,7 @@ srs_error_t SrsHlsController::write_audio(SrsMediaPacket *shared_audio, SrsForma
// pure audio again for audio disabled.
// so we reap event when the audio incoming when segment overflow.
// we use absolutely overflow of segment to make jwplayer/ffplay happy
- if (tsmc->audio && muxer->is_segment_absolutely_overflow()) {
+ if (tsmc->audio_ && muxer->is_segment_absolutely_overflow()) {
if ((err = reap_segment()) != srs_success) {
return srs_error_wrap(err, "hls: reap segment");
}
@@ -2123,8 +2123,8 @@ srs_error_t SrsHlsController::write_audio(SrsMediaPacket *shared_audio, SrsForma
// for pure audio, aggregate some frame to one.
// TODO: FIXME: Check whether it's necessary.
- if (muxer->pure_audio() && tsmc->audio) {
- if (dts - tsmc->audio->start_pts < SRS_CONSTS_HLS_PURE_AUDIO_AGGREGATE) {
+ if (muxer->pure_audio() && tsmc->audio_) {
+ if (dts - tsmc->audio_->start_pts_ < SRS_CONSTS_HLS_PURE_AUDIO_AGGREGATE) {
return err;
}
}
@@ -2143,14 +2143,14 @@ srs_error_t SrsHlsController::write_audio(SrsMediaPacket *shared_audio, SrsForma
srs_error_t SrsHlsController::write_video(SrsMediaPacket *shared_video, SrsFormat *format)
{
srs_error_t err = srs_success;
- SrsParsedVideoPacket *frame = format->video;
- int64_t dts = shared_video->timestamp * 90;
+ SrsParsedVideoPacket *frame = format->video_;
+ int64_t dts = shared_video->timestamp_ * 90;
// Refresh the codec ASAP.
- if (muxer->latest_vcodec() != frame->vcodec()->id) {
+ if (muxer->latest_vcodec() != frame->vcodec()->id_) {
srs_trace("HLS: Switch video codec %d(%s) to %d(%s)", muxer->latest_vcodec(), srs_video_codec_id2str(muxer->latest_vcodec()).c_str(),
- frame->vcodec()->id, srs_video_codec_id2str(frame->vcodec()->id).c_str());
- muxer->set_latest_vcodec(frame->vcodec()->id);
+ frame->vcodec()->id_, srs_video_codec_id2str(frame->vcodec()->id_).c_str());
+ muxer->set_latest_vcodec(frame->vcodec()->id_);
}
// write video to cache.
@@ -2160,14 +2160,14 @@ srs_error_t SrsHlsController::write_video(SrsMediaPacket *shared_video, SrsForma
// First, update the duration of the segment, as we might reap the segment. The duration should
// cover from the first frame to the last frame.
- muxer->update_duration(tsmc->video->dts);
+ muxer->update_duration(tsmc->video_->dts_);
// when segment overflow, reap if possible.
if (muxer->is_segment_overflow()) {
// do reap ts if any of:
// a. wait keyframe and got keyframe.
// b. always reap when not wait keyframe.
- if (!muxer->wait_keyframe() || frame->frame_type == SrsVideoAvcFrameTypeKeyFrame) {
+ if (!muxer->wait_keyframe() || frame->frame_type_ == SrsVideoAvcFrameTypeKeyFrame) {
// reap the segment, which will also flush the video.
if ((err = reap_segment()) != srs_success) {
return srs_error_wrap(err, "hls: reap segment");
@@ -2309,7 +2309,7 @@ srs_error_t SrsHlsMp4Controller::on_unpublish()
srs_error_t SrsHlsMp4Controller::write_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
{
srs_error_t err = srs_success;
- SrsParsedAudioPacket *frame = format->audio;
+ SrsParsedAudioPacket *frame = format->audio_;
// Ignore audio sequence header
if (format->is_aac_sequence_header() || format->is_mp3_sequence_header()) {
@@ -2317,13 +2317,13 @@ srs_error_t SrsHlsMp4Controller::write_audio(SrsMediaPacket *shared_audio, SrsFo
}
// Refresh the codec ASAP.
- if (muxer_->latest_acodec() != frame->acodec()->id) {
+ if (muxer_->latest_acodec() != frame->acodec()->id_) {
srs_trace("HLS: Switch audio codec %d(%s) to %d(%s)", muxer_->latest_acodec(), srs_audio_codec_id2str(muxer_->latest_acodec()).c_str(),
- frame->acodec()->id, srs_audio_codec_id2str(frame->acodec()->id).c_str());
- muxer_->set_latest_acodec(frame->acodec()->id);
+ frame->acodec()->id_, srs_audio_codec_id2str(frame->acodec()->id_).c_str());
+ muxer_->set_latest_acodec(frame->acodec()->id_);
}
- audio_dts_ = shared_audio->timestamp;
+ audio_dts_ = shared_audio->timestamp_;
if ((err = muxer_->write_audio(shared_audio, format)) != srs_success) {
return srs_error_wrap(err, "write audio");
@@ -2335,16 +2335,16 @@ srs_error_t SrsHlsMp4Controller::write_audio(SrsMediaPacket *shared_audio, SrsFo
srs_error_t SrsHlsMp4Controller::write_video(SrsMediaPacket *shared_video, SrsFormat *format)
{
srs_error_t err = srs_success;
- SrsParsedVideoPacket *frame = format->video;
+ SrsParsedVideoPacket *frame = format->video_;
// Refresh the codec ASAP.
- if (muxer_->latest_vcodec() != frame->vcodec()->id) {
+ if (muxer_->latest_vcodec() != frame->vcodec()->id_) {
srs_trace("HLS: Switch video codec %d(%s) to %d(%s)", muxer_->latest_vcodec(), srs_video_codec_id2str(muxer_->latest_vcodec()).c_str(),
- frame->vcodec()->id, srs_video_codec_id2str(frame->vcodec()->id).c_str());
- muxer_->set_latest_vcodec(frame->vcodec()->id);
+ frame->vcodec()->id_, srs_video_codec_id2str(frame->vcodec()->id_).c_str());
+ muxer_->set_latest_vcodec(frame->vcodec()->id_);
}
- video_dts_ = shared_video->timestamp;
+ video_dts_ = shared_video->timestamp_;
if ((err = muxer_->write_video(shared_video, format)) != srs_success) {
return srs_error_wrap(err, "write video");
@@ -2366,7 +2366,7 @@ srs_error_t SrsHlsMp4Controller::on_sequence_header(SrsMediaPacket *msg, SrsForm
}
if (msg->is_audio()) {
- if (format->acodec->aac_extra_data.size() == 0) {
+ if (format->acodec_->aac_extra_data_.size() == 0) {
srs_trace("the audio codec's aac extra data is empty");
return err;
}
@@ -2635,7 +2635,7 @@ srs_error_t SrsHls::on_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
// Ignore if no format->acodec, it means the codec is not parsed, or unknown codec.
// @issue https://github.com/ossrs/srs/issues/1506#issuecomment-562079474
// TODO: format->acodec is always not-nil, remove this check.
- if (!format->acodec) {
+ if (!format->acodec_) {
return err;
}
@@ -2645,13 +2645,13 @@ srs_error_t SrsHls::on_audio(SrsMediaPacket *shared_audio, SrsFormat *format)
SrsUniquePtr audio(shared_audio->copy());
// ts support audio codec: aac/mp3
- SrsAudioCodecId acodec = format->acodec->id;
+ SrsAudioCodecId acodec = format->acodec_->id_;
if (acodec != SrsAudioCodecIdAAC && acodec != SrsAudioCodecIdMP3) {
return err;
}
// ignore sequence header
- srs_assert(format->audio);
+ srs_assert(format->audio_);
// TODO: verify mp3 play by HLS.
if (format->is_aac_sequence_header() || format->is_mp3_sequence_header()) {
return controller->on_sequence_header(audio.get(), format);
@@ -2681,7 +2681,7 @@ srs_error_t SrsHls::on_video(SrsMediaPacket *shared_video, SrsFormat *format)
// Ignore if no format->vcodec, it means the codec is not parsed, or unknown codec.
// @issue https://github.com/ossrs/srs/issues/1506#issuecomment-562079474
- if (!format->vcodec) {
+ if (!format->vcodec_) {
return err;
}
@@ -2692,13 +2692,13 @@ srs_error_t SrsHls::on_video(SrsMediaPacket *shared_video, SrsFormat *format)
// ignore info frame,
// @see https://github.com/ossrs/srs/issues/288#issuecomment-69863909
- srs_assert(format->video);
- if (format->video->frame_type == SrsVideoAvcFrameTypeVideoInfoFrame) {
+ srs_assert(format->video_);
+ if (format->video_->frame_type_ == SrsVideoAvcFrameTypeVideoInfoFrame) {
return err;
}
- srs_assert(format->vcodec);
- if (format->vcodec->id != SrsVideoCodecIdAVC && format->vcodec->id != SrsVideoCodecIdHEVC) {
+ srs_assert(format->vcodec_);
+ if (format->vcodec_->id_ != SrsVideoCodecIdAVC && format->vcodec_->id_ != SrsVideoCodecIdHEVC) {
return err;
}
diff --git a/trunk/src/app/srs_app_hourglass.cpp b/trunk/src/app/srs_app_hourglass.cpp
index 342bb2386..f81d9e68a 100644
--- a/trunk/src/app/srs_app_hourglass.cpp
+++ b/trunk/src/app/srs_app_hourglass.cpp
@@ -109,7 +109,7 @@ srs_error_t SrsHourGlass::cycle()
srs_utime_t interval = it->second;
if (interval == 0 || (total_elapse % interval) == 0) {
- ++_srs_pps_timer->sugar;
+ ++_srs_pps_timer->sugar_;
if ((err = handler->notify(event, interval, total_elapse)) != srs_success) {
return srs_error_wrap(err, "notify");
@@ -179,7 +179,7 @@ srs_error_t SrsFastTimer::cycle()
return srs_error_wrap(err, "quit");
}
- ++_srs_pps_timer->sugar;
+ ++_srs_pps_timer->sugar_;
for (int i = 0; i < (int)handlers_.size(); i++) {
ISrsFastTimer *timer = handlers_.at(i);
@@ -219,23 +219,23 @@ srs_error_t SrsClockWallMonitor::on_timer(srs_utime_t interval)
clock = now;
if (elapsed <= 15 * SRS_UTIME_MILLISECONDS) {
- ++_srs_pps_clock_15ms->sugar;
+ ++_srs_pps_clock_15ms->sugar_;
} else if (elapsed <= 21 * SRS_UTIME_MILLISECONDS) {
- ++_srs_pps_clock_20ms->sugar;
+ ++_srs_pps_clock_20ms->sugar_;
} else if (elapsed <= 25 * SRS_UTIME_MILLISECONDS) {
- ++_srs_pps_clock_25ms->sugar;
+ ++_srs_pps_clock_25ms->sugar_;
} else if (elapsed <= 30 * SRS_UTIME_MILLISECONDS) {
- ++_srs_pps_clock_30ms->sugar;
+ ++_srs_pps_clock_30ms->sugar_;
} else if (elapsed <= 35 * SRS_UTIME_MILLISECONDS) {
- ++_srs_pps_clock_35ms->sugar;
+ ++_srs_pps_clock_35ms->sugar_;
} else if (elapsed <= 40 * SRS_UTIME_MILLISECONDS) {
- ++_srs_pps_clock_40ms->sugar;
+ ++_srs_pps_clock_40ms->sugar_;
} else if (elapsed <= 80 * SRS_UTIME_MILLISECONDS) {
- ++_srs_pps_clock_80ms->sugar;
+ ++_srs_pps_clock_80ms->sugar_;
} else if (elapsed <= 160 * SRS_UTIME_MILLISECONDS) {
- ++_srs_pps_clock_160ms->sugar;
+ ++_srs_pps_clock_160ms->sugar_;
} else {
- ++_srs_pps_timer_s->sugar;
+ ++_srs_pps_timer_s->sugar_;
}
return err;
diff --git a/trunk/src/app/srs_app_http_stream.cpp b/trunk/src/app/srs_app_http_stream.cpp
index 235f9ef1e..80d62300d 100644
--- a/trunk/src/app/srs_app_http_stream.cpp
+++ b/trunk/src/app/srs_app_http_stream.cpp
@@ -958,11 +958,11 @@ srs_error_t SrsLiveStream::streaming_send_messages(ISrsBufferEncoder *enc, SrsMe
SrsMediaPacket *msg = msgs[i];
if (msg->is_audio()) {
- err = enc->write_audio(msg->timestamp, msg->payload(), msg->size());
+ err = enc->write_audio(msg->timestamp_, msg->payload(), msg->size());
} else if (msg->is_video()) {
- err = enc->write_video(msg->timestamp, msg->payload(), msg->size());
+ err = enc->write_video(msg->timestamp_, msg->payload(), msg->size());
} else {
- err = enc->write_metadata(msg->timestamp, msg->payload(), msg->size());
+ err = enc->write_metadata(msg->timestamp_, msg->payload(), msg->size());
}
if (err != srs_success) {
diff --git a/trunk/src/app/srs_app_listener.cpp b/trunk/src/app/srs_app_listener.cpp
index aa27a7214..0291db4f6 100644
--- a/trunk/src/app/srs_app_listener.cpp
+++ b/trunk/src/app/srs_app_listener.cpp
@@ -463,7 +463,7 @@ int SrsUdpMuxSocket::recvfrom(srs_utime_t timeout)
address_changed_ = true;
// Update the stat.
- ++_srs_pps_rpkts->sugar;
+ ++_srs_pps_rpkts->sugar_;
return nread;
}
@@ -472,7 +472,7 @@ srs_error_t SrsUdpMuxSocket::sendto(void *data, int size, srs_utime_t timeout)
{
srs_error_t err = srs_success;
- ++_srs_pps_spkts->sugar;
+ ++_srs_pps_spkts->sugar_;
int nb_write = srs_sendto(lfd, data, size, (sockaddr *)&from, fromlen, timeout);
@@ -576,7 +576,7 @@ std::string SrsUdpMuxSocket::peer_id()
peer_id_ = string(id_buf, len);
// Update the stat.
- ++_srs_pps_addrs->sugar;
+ ++_srs_pps_addrs->sugar_;
}
return peer_id_;
@@ -584,7 +584,7 @@ std::string SrsUdpMuxSocket::peer_id()
uint64_t SrsUdpMuxSocket::fast_id()
{
- ++_srs_pps_fast_addrs->sugar;
+ ++_srs_pps_fast_addrs->sugar_;
return fast_id_;
}
diff --git a/trunk/src/app/srs_app_mpegts_udp.cpp b/trunk/src/app/srs_app_mpegts_udp.cpp
index a8460fefe..243012648 100644
--- a/trunk/src/app/srs_app_mpegts_udp.cpp
+++ b/trunk/src/app/srs_app_mpegts_udp.cpp
@@ -98,15 +98,15 @@ srs_error_t SrsMpegtsQueue::push(SrsMediaPacket *msg)
// TODO: FIXME: use right way.
for (int i = 0; i < 10; i++) {
- if (msgs.find(msg->timestamp) == msgs.end()) {
+ if (msgs.find(msg->timestamp_) == msgs.end()) {
break;
}
// adjust the ts, add 1ms.
- msg->timestamp += 1;
+ msg->timestamp_ += 1;
if (i >= 100) {
- srs_warn("mpegts: free the msg for dts exists, dts=%" PRId64, msg->timestamp);
+ srs_warn("mpegts: free the msg for dts exists, dts=%" PRId64, msg->timestamp_);
srs_freep(msg);
return err;
}
@@ -120,7 +120,7 @@ srs_error_t SrsMpegtsQueue::push(SrsMediaPacket *msg)
nb_videos++;
}
- msgs[msg->timestamp] = msg;
+ msgs[msg->timestamp_] = msg;
return err;
}
@@ -327,8 +327,8 @@ srs_error_t SrsMpegtsOverUdp::on_ts_message(SrsTsMessage *msg)
if (pprint->can_print()) {
srs_trace("<- " SRS_CONSTS_LOG_STREAM_CASTER " mpegts: got %s age=%d stream=%s, dts=%" PRId64 ", pts=%" PRId64 ", size=%d, us=%d, cc=%d, sid=%#x(%s-%d)",
- (msg->channel->apply == SrsTsPidApplyVideo) ? "Video" : "Audio", pprint->age(), srs_ts_stream2string(msg->channel->stream).c_str(),
- msg->dts, msg->pts, msg->payload->length(), msg->packet->payload_unit_start_indicator, msg->continuity_counter, msg->sid,
+ (msg->channel_->apply_ == SrsTsPidApplyVideo) ? "Video" : "Audio", pprint->age(), srs_ts_stream2string(msg->channel_->stream_).c_str(),
+ msg->dts_, msg->pts_, msg->payload_->length(), msg->packet_->payload_unit_start_indicator_, msg->continuity_counter_, msg->sid_,
msg->is_audio() ? "A" : msg->is_video() ? "V"
: "N",
msg->stream_number());
@@ -336,33 +336,33 @@ srs_error_t SrsMpegtsOverUdp::on_ts_message(SrsTsMessage *msg)
// When the audio SID is private stream 1, we use common audio.
// @see https://github.com/ossrs/srs/issues/740
- if (msg->channel->apply == SrsTsPidApplyAudio && msg->sid == SrsTsPESStreamIdPrivateStream1) {
- msg->sid = SrsTsPESStreamIdAudioCommon;
+ if (msg->channel_->apply_ == SrsTsPidApplyAudio && msg->sid_ == SrsTsPESStreamIdPrivateStream1) {
+ msg->sid_ = SrsTsPESStreamIdAudioCommon;
}
// when not audio/video, or not adts/annexb format, donot support.
if (msg->stream_number() != 0) {
return srs_error_new(ERROR_STREAM_CASTER_TS_ES, "ts: unsupported stream format, sid=%#x(%s-%d)",
- msg->sid, msg->is_audio() ? "A" : msg->is_video() ? "V"
- : "N",
+ msg->sid_, msg->is_audio() ? "A" : msg->is_video() ? "V"
+ : "N",
msg->stream_number());
}
// check supported codec
- if (msg->channel->stream != SrsTsStreamVideoH264 && msg->channel->stream != SrsTsStreamAudioAAC) {
- return srs_error_new(ERROR_STREAM_CASTER_TS_CODEC, "ts: unsupported stream codec=%d", msg->channel->stream);
+ if (msg->channel_->stream_ != SrsTsStreamVideoH264 && msg->channel_->stream_ != SrsTsStreamAudioAAC) {
+ return srs_error_new(ERROR_STREAM_CASTER_TS_CODEC, "ts: unsupported stream codec=%d", msg->channel_->stream_);
}
// parse the stream.
- SrsBuffer avs(msg->payload->bytes(), msg->payload->length());
+ SrsBuffer avs(msg->payload_->bytes(), msg->payload_->length());
// publish audio or video.
- if (msg->channel->stream == SrsTsStreamVideoH264) {
+ if (msg->channel_->stream_ == SrsTsStreamVideoH264) {
if ((err = on_ts_video(msg, &avs)) != srs_success) {
return srs_error_wrap(err, "ts: consume video");
}
}
- if (msg->channel->stream == SrsTsStreamAudioAAC) {
+ if (msg->channel_->stream_ == SrsTsStreamAudioAAC) {
if ((err = on_ts_audio(msg, &avs)) != srs_success) {
return srs_error_wrap(err, "ts: consume audio");
}
@@ -382,8 +382,8 @@ srs_error_t SrsMpegtsOverUdp::on_ts_video(SrsTsMessage *msg, SrsBuffer *avs)
}
// ts tbn to flv tbn.
- uint32_t dts = (uint32_t)(msg->dts / 90);
- uint32_t pts = (uint32_t)(msg->dts / 90);
+ uint32_t dts = (uint32_t)(msg->dts_ / 90);
+ uint32_t pts = (uint32_t)(msg->dts_ / 90);
// send each frame.
while (!avs->empty()) {
@@ -540,7 +540,7 @@ srs_error_t SrsMpegtsOverUdp::on_ts_audio(SrsTsMessage *msg, SrsBuffer *avs)
}
// ts tbn to flv tbn.
- uint32_t dts = (uint32_t)(msg->dts / 90);
+ uint32_t dts = (uint32_t)(msg->dts_ / 90);
// send each frame.
while (!avs->empty()) {
@@ -629,7 +629,7 @@ srs_error_t SrsMpegtsOverUdp::rtmp_write_packet(char type, uint32_t timestamp, c
srs_trace("mpegts: send msg %s age=%d, dts=%" PRId64 ", size=%d",
msg->is_audio() ? "A" : msg->is_video() ? "V"
: "N",
- pprint->age(), msg->timestamp, msg->size());
+ pprint->age(), msg->timestamp_, msg->size());
}
// send out encoded msg.
diff --git a/trunk/src/app/srs_app_recv_thread.cpp b/trunk/src/app/srs_app_recv_thread.cpp
index 779f2658e..254a85e6e 100644
--- a/trunk/src/app/srs_app_recv_thread.cpp
+++ b/trunk/src/app/srs_app_recv_thread.cpp
@@ -360,13 +360,13 @@ srs_error_t SrsPublishRecvThread::consume(SrsRtmpCommonMessage *msg)
_nb_msgs++;
- if (msg->header.is_video()) {
+ if (msg->header_.is_video()) {
video_frames++;
}
// log to show the time of recv thread.
srs_verbose("recv thread now=%" PRId64 "us, got msg time=%" PRId64 "ms, size=%d",
- srs_time_now_realtime(), msg->header.timestamp, msg->size);
+ srs_time_now_realtime(), msg->header_.timestamp, msg->size);
// the rtmp connection will handle this message
err = _conn->handle_publish_message(source_, msg);
diff --git a/trunk/src/app/srs_app_rtc_codec.cpp b/trunk/src/app/srs_app_rtc_codec.cpp
index e2fb2a821..792699c5b 100644
--- a/trunk/src/app/srs_app_rtc_codec.cpp
+++ b/trunk/src/app/srs_app_rtc_codec.cpp
@@ -179,8 +179,8 @@ void SrsAudioTranscoder::free_frames(std::vector &frames
for (std::vector::iterator it = frames.begin(); it != frames.end(); ++it) {
SrsParsedAudioPacket *p = *it;
- for (int i = 0; i < p->nb_samples; i++) {
- char *pa = p->samples[i].bytes;
+ for (int i = 0; i < p->nb_samples_; i++) {
+ char *pa = p->samples_[i].bytes_;
srs_freepa(pa);
}
@@ -329,8 +329,8 @@ srs_error_t SrsAudioTranscoder::decode_and_resample(SrsParsedAudioPacket *pkt)
{
srs_error_t err = srs_success;
- dec_packet_->data = (uint8_t *)pkt->samples[0].bytes;
- dec_packet_->size = pkt->samples[0].size;
+ dec_packet_->data = (uint8_t *)pkt->samples_[0].bytes_;
+ dec_packet_->size = pkt->samples_[0].size_;
// Ignore empty packet, see https://github.com/ossrs/srs/pull/2757#discussion_r759797651
if (!dec_packet_->data || !dec_packet_->size) {
@@ -344,7 +344,7 @@ srs_error_t SrsAudioTranscoder::decode_and_resample(SrsParsedAudioPacket *pkt)
av_make_error_string(err_buf, AV_ERROR_MAX_STRING_SIZE, error));
}
- new_pkt_pts_ = pkt->dts + pkt->cts;
+ new_pkt_pts_ = pkt->dts_ + pkt->cts_;
while (error >= 0) {
error = avcodec_receive_frame(dec_, dec_frame_);
if (error == AVERROR(EAGAIN) || error == AVERROR_EOF) {
@@ -439,8 +439,8 @@ srs_error_t SrsAudioTranscoder::encode(std::vector &pkts
char *buf = new char[enc_packet_->size];
memcpy(buf, enc_packet_->data, enc_packet_->size);
out_frame->add_sample(buf, enc_packet_->size);
- out_frame->dts = enc_packet_->dts;
- out_frame->cts = enc_packet_->pts - enc_packet_->dts;
+ out_frame->dts_ = enc_packet_->dts;
+ out_frame->cts_ = enc_packet_->pts - enc_packet_->dts;
pkts.push_back(out_frame);
}
}
diff --git a/trunk/src/app/srs_app_rtc_conn.cpp b/trunk/src/app/srs_app_rtc_conn.cpp
index aeebff5fd..db9d0953a 100644
--- a/trunk/src/app/srs_app_rtc_conn.cpp
+++ b/trunk/src/app/srs_app_rtc_conn.cpp
@@ -112,7 +112,7 @@ srs_error_t SrsSecurityTransport::write_dtls_data(void *data, int size)
return err;
}
- ++_srs_pps_sstuns->sugar;
+ ++_srs_pps_sstuns->sugar_;
if ((err = network_->write(data, size, NULL)) != srs_success) {
return srs_error_wrap(err, "send dtls packet");
@@ -352,7 +352,7 @@ srs_error_t SrsRtcPLIWorker::cycle()
uint32_t ssrc = it->first;
SrsContextId cid = it->second;
- ++_srs_pps_pli->sugar;
+ ++_srs_pps_pli->sugar_;
if ((err = handler_->do_request_keyframe(ssrc, cid)) != srs_success) {
srs_warn("PLI error, %s", srs_error_desc(err).c_str());
@@ -822,7 +822,7 @@ srs_error_t SrsRtcPlayStream::on_rtcp_nack(SrsRtcpNack *rtcp)
{
srs_error_t err = srs_success;
- ++_srs_pps_rnack->sugar;
+ ++_srs_pps_rnack->sugar_;
uint32_t ssrc = rtcp->get_media_ssrc();
@@ -951,14 +951,14 @@ srs_error_t SrsRtcPublishRtcpTimer::on_timer(srs_utime_t interval)
// to prevent it from being freed.
SrsLocker(&lock_);
- ++_srs_pps_pub->sugar;
+ ++_srs_pps_pub->sugar_;
if (!p_->is_started) {
return err;
}
// For RR and RRTR.
- ++_srs_pps_rr->sugar;
+ ++_srs_pps_rr->sugar_;
if ((err = p_->send_rtcp_rr()) != srs_success) {
srs_warn("RR err %s", srs_error_desc(err).c_str());
@@ -998,7 +998,7 @@ srs_error_t SrsRtcPublishTwccTimer::on_timer(srs_utime_t interval)
// to prevent it from being freed.
SrsLocker(&lock_);
- ++_srs_pps_pub->sugar;
+ ++_srs_pps_pub->sugar_;
if (!p_->is_started) {
return err;
@@ -1009,11 +1009,11 @@ srs_error_t SrsRtcPublishTwccTimer::on_timer(srs_utime_t interval)
return err;
}
- ++_srs_pps_twcc->sugar;
+ ++_srs_pps_twcc->sugar_;
// If circuit-breaker is dropping packet, disable TWCC.
if (_srs_circuit_breaker->hybrid_critical_water_level()) {
- ++_srs_pps_snack4->sugar;
+ ++_srs_pps_snack4->sugar_;
return err;
}
@@ -1445,12 +1445,12 @@ srs_error_t SrsRtcPublishStream::do_on_rtp_plaintext(SrsRtpPacket *&pkt, SrsBuff
SrsRtcAudioRecvTrack *audio_track = get_audio_track(ssrc);
SrsRtcVideoRecvTrack *video_track = get_video_track(ssrc);
if (audio_track) {
- pkt->frame_type = SrsFrameTypeAudio;
+ pkt->frame_type_ = SrsFrameTypeAudio;
if ((err = audio_track->on_rtp(source_, pkt)) != srs_success) {
return srs_error_wrap(err, "on audio");
}
} else if (video_track) {
- pkt->frame_type = SrsFrameTypeVideo;
+ pkt->frame_type_ = SrsFrameTypeVideo;
if ((err = video_track->on_rtp(source_, pkt)) != srs_success) {
return srs_error_wrap(err, "on video");
}
@@ -1460,7 +1460,7 @@ srs_error_t SrsRtcPublishStream::do_on_rtp_plaintext(SrsRtpPacket *&pkt, SrsBuff
// If circuit-breaker is enabled, disable nack.
if (_srs_circuit_breaker->hybrid_critical_water_level()) {
- ++_srs_pps_snack4->sugar;
+ ++_srs_pps_snack4->sugar_;
return err;
}
@@ -1542,7 +1542,7 @@ srs_error_t SrsRtcPublishStream::send_periodic_twcc()
return err;
}
- ++_srs_pps_srtcps->sugar;
+ ++_srs_pps_srtcps->sugar_;
// limit the max count=1024 to avoid dead loop.
for (int i = 0; i < 1024 && rtcp_twcc_.need_feedback(); ++i) {
@@ -1772,11 +1772,11 @@ srs_error_t SrsRtcConnectionNackTimer::on_timer(srs_utime_t interval)
return err;
}
- ++_srs_pps_conn->sugar;
+ ++_srs_pps_conn->sugar_;
// If circuit-breaker is enabled, disable nack.
if (_srs_circuit_breaker->hybrid_critical_water_level()) {
- ++_srs_pps_snack4->sugar;
+ ++_srs_pps_snack4->sugar_;
return err;
}
@@ -2315,7 +2315,7 @@ srs_error_t SrsRtcConnection::send_rtcp(char *data, int nb_data)
{
srs_error_t err = srs_success;
- ++_srs_pps_srtcps->sugar;
+ ++_srs_pps_srtcps->sugar_;
int nb_buf = nb_data;
if ((err = networks_->available()->protect_rtcp(data, &nb_buf)) != srs_success) {
@@ -2331,7 +2331,7 @@ srs_error_t SrsRtcConnection::send_rtcp(char *data, int nb_data)
void SrsRtcConnection::check_send_nacks(SrsRtpNackForReceiver *nack, uint32_t ssrc, uint32_t &sent_nacks, uint32_t &timeout_nacks)
{
- ++_srs_pps_snack->sugar;
+ ++_srs_pps_snack->sugar_;
SrsRtcpNack rtcpNack(ssrc);
@@ -2342,8 +2342,8 @@ void SrsRtcConnection::check_send_nacks(SrsRtpNackForReceiver *nack, uint32_t ss
return;
}
- ++_srs_pps_snack2->sugar;
- ++_srs_pps_srtcps->sugar;
+ ++_srs_pps_snack2->sugar_;
+ ++_srs_pps_srtcps->sugar_;
char buf[kRtcpPacketSize];
SrsBuffer stream(buf, sizeof(buf));
@@ -2357,7 +2357,7 @@ void SrsRtcConnection::check_send_nacks(SrsRtpNackForReceiver *nack, uint32_t ss
srs_error_t SrsRtcConnection::send_rtcp_rr(uint32_t ssrc, SrsRtpRingBuffer *rtp_queue, const uint64_t &last_send_systime, const SrsNtp &last_send_ntp)
{
- ++_srs_pps_srtcps->sugar;
+ ++_srs_pps_srtcps->sugar_;
// @see https://tools.ietf.org/html/rfc3550#section-6.4.2
char buf[kRtpPacketSize];
@@ -2397,7 +2397,7 @@ srs_error_t SrsRtcConnection::send_rtcp_rr(uint32_t ssrc, SrsRtpRingBuffer *rtp_
srs_error_t SrsRtcConnection::send_rtcp_xr_rrtr(uint32_t ssrc)
{
- ++_srs_pps_srtcps->sugar;
+ ++_srs_pps_srtcps->sugar_;
/*
@see: http://www.rfc-editor.org/rfc/rfc3611.html#section-2
@@ -2444,7 +2444,7 @@ srs_error_t SrsRtcConnection::send_rtcp_xr_rrtr(uint32_t ssrc)
srs_error_t SrsRtcConnection::send_rtcp_fb_pli(uint32_t ssrc, const SrsContextId &cid_of_subscriber)
{
- ++_srs_pps_srtcps->sugar;
+ ++_srs_pps_srtcps->sugar_;
char buf[kRtpPacketSize];
SrsBuffer stream(buf, sizeof(buf));
@@ -2519,7 +2519,7 @@ srs_error_t SrsRtcConnection::do_send_packet(SrsRtpPacket *pkt)
return err;
}
- ++_srs_pps_srtps->sugar;
+ ++_srs_pps_srtps->sugar_;
if ((err = networks_->available()->write(iov->iov_base, iov->iov_len, NULL)) != srs_success) {
srs_warn("RTC: Write %d bytes err %s", iov->iov_len, srs_error_desc(err).c_str());
@@ -2562,7 +2562,7 @@ srs_error_t SrsRtcConnection::on_binding_request(SrsStunPacket *r, string &ice_p
{
srs_error_t err = srs_success;
- ++_srs_pps_sstuns->sugar;
+ ++_srs_pps_sstuns->sugar_;
bool strict_check = _srs_config->get_rtc_stun_strict_check(req_->vhost);
if (strict_check && r->get_ice_controlled()) {
diff --git a/trunk/src/app/srs_app_rtc_queue.cpp b/trunk/src/app/srs_app_rtc_queue.cpp
index 5c7b54fbe..d2f64571f 100644
--- a/trunk/src/app/srs_app_rtc_queue.cpp
+++ b/trunk/src/app/srs_app_rtc_queue.cpp
@@ -217,7 +217,7 @@ void SrsRtpNackForReceiver::insert(uint16_t first, uint16_t last)
{
// If circuit-breaker is enabled, disable nack.
if (_srs_circuit_breaker->hybrid_high_water_level()) {
- ++_srs_pps_snack4->sugar;
+ ++_srs_pps_snack4->sugar_;
return;
}
@@ -255,7 +255,7 @@ void SrsRtpNackForReceiver::get_nack_seqs(SrsRtcpNack &seqs, uint32_t &timeout_n
// If circuit-breaker is enabled, disable nack.
if (_srs_circuit_breaker->hybrid_high_water_level()) {
queue_.clear();
- ++_srs_pps_snack4->sugar;
+ ++_srs_pps_snack4->sugar_;
return;
}
diff --git a/trunk/src/app/srs_app_rtc_server.cpp b/trunk/src/app/srs_app_rtc_server.cpp
index 35ecc4b86..a87d6e90d 100644
--- a/trunk/src/app/srs_app_rtc_server.cpp
+++ b/trunk/src/app/srs_app_rtc_server.cpp
@@ -538,8 +538,8 @@ void SrsRtcSessionManager::srs_update_rtc_sessions()
srs_trace("RTC: Server conns=%u%s%s%s%s%s%s%s",
nn_rtc_conns,
- stats.rpkts_desc.c_str(), stats.spkts_desc.c_str(), stats.rtcp_desc.c_str(), stats.snk_desc.c_str(),
- stats.rnk_desc.c_str(), loss_desc.c_str(), stats.fid_desc.c_str());
+ stats.rpkts_desc_.c_str(), stats.spkts_desc_.c_str(), stats.rtcp_desc_.c_str(), stats.snk_desc_.c_str(),
+ stats.rnk_desc_.c_str(), loss_desc.c_str(), stats.fid_desc_.c_str());
}
srs_error_t SrsRtcSessionManager::exec_rtc_async_work(ISrsAsyncCallTask *t)
@@ -574,7 +574,7 @@ srs_error_t SrsRtcSessionManager::on_udp_packet(SrsUdpMuxSocket *skt)
// For STUN, the peer address may change.
if (!is_rtp_or_rtcp && srs_is_stun((uint8_t *)data, size)) {
- ++_srs_pps_rstuns->sugar;
+ ++_srs_pps_rstuns->sugar_;
string peer_id = skt->peer_id();
// TODO: FIXME: Should support ICE renomination, to switch network between candidates.
@@ -614,7 +614,7 @@ srs_error_t SrsRtcSessionManager::on_udp_packet(SrsUdpMuxSocket *skt)
// Note that we don't(except error) switch to the context of session, for performance issue.
if (is_rtp_or_rtcp && !is_rtcp) {
- ++_srs_pps_rrtps->sugar;
+ ++_srs_pps_rrtps->sugar_;
err = session->udp()->on_rtp(data, size);
if (err != srs_success) {
@@ -625,12 +625,12 @@ srs_error_t SrsRtcSessionManager::on_udp_packet(SrsUdpMuxSocket *skt)
session->switch_to_context();
if (is_rtp_or_rtcp && is_rtcp) {
- ++_srs_pps_rrtcps->sugar;
+ ++_srs_pps_rrtcps->sugar_;
return session->udp()->on_rtcp(data, size);
}
if (srs_is_dtls((uint8_t *)data, size)) {
- ++_srs_pps_rstuns->sugar;
+ ++_srs_pps_rstuns->sugar_;
return session->udp()->on_dtls(data, size);
}
diff --git a/trunk/src/app/srs_app_rtc_source.cpp b/trunk/src/app/srs_app_rtc_source.cpp
index b44e79217..ed6418703 100644
--- a/trunk/src/app/srs_app_rtc_source.cpp
+++ b/trunk/src/app/srs_app_rtc_source.cpp
@@ -77,29 +77,29 @@ srs_error_t aac_raw_append_adts_header(SrsMediaPacket *shared_audio, SrsFormat *
}
// If no audio RAW frame, or not parsed for no sequence header, drop the packet.
- if (format->audio->nb_samples == 0) {
+ if (format->audio_->nb_samples_ == 0) {
srs_warn("RTC: Drop AAC %d bytes for no sample", shared_audio->size());
return err;
}
- if (format->audio->nb_samples != 1) {
- return srs_error_new(ERROR_RTC_RTP_MUXER, "adts samples=%d", format->audio->nb_samples);
+ if (format->audio_->nb_samples_ != 1) {
+ return srs_error_new(ERROR_RTC_RTP_MUXER, "adts samples=%d", format->audio_->nb_samples_);
}
- int nb_buf = format->audio->samples[0].size + 7;
+ int nb_buf = format->audio_->samples_[0].size_ + 7;
char *buf = new char[nb_buf];
SrsBuffer stream(buf, nb_buf);
// TODO: Add comment.
stream.write_1bytes(0xFF);
stream.write_1bytes(0xF9);
- stream.write_1bytes(((format->acodec->aac_object - 1) << 6) | ((format->acodec->aac_sample_rate & 0x0F) << 2) | ((format->acodec->aac_channels & 0x04) >> 2));
- stream.write_1bytes(((format->acodec->aac_channels & 0x03) << 6) | ((nb_buf >> 11) & 0x03));
+ stream.write_1bytes(((format->acodec_->aac_object_ - 1) << 6) | ((format->acodec_->aac_sample_rate_ & 0x0F) << 2) | ((format->acodec_->aac_channels_ & 0x04) >> 2));
+ stream.write_1bytes(((format->acodec_->aac_channels_ & 0x03) << 6) | ((nb_buf >> 11) & 0x03));
stream.write_1bytes((nb_buf >> 3) & 0xFF);
stream.write_1bytes(((nb_buf & 0x07) << 5) | 0x1F);
stream.write_1bytes(0xFC);
- stream.write_bytes(format->audio->samples[0].bytes, format->audio->samples[0].size);
+ stream.write_bytes(format->audio_->samples_[0].bytes_, format->audio_->samples_[0].size_);
*pbuf = buf;
*pnn_buf = nb_buf;
@@ -778,7 +778,7 @@ srs_error_t SrsRtcSource::on_rtp(SrsRtpPacket *pkt)
// If circuit-breaker is dying, drop packet.
if (_srs_circuit_breaker->hybrid_dying_water_level()) {
- _srs_pps_aloss2->sugar += (int64_t)consumers.size();
+ _srs_pps_aloss2->sugar_ += (int64_t)consumers.size();
return err;
}
@@ -975,7 +975,7 @@ srs_error_t SrsRtcRtpBuilder::initialize(ISrsRequest *r)
}
// Setup the SPS/PPS parsing strategy.
- format->try_annexb_first = _srs_config->try_annexb_first(r->vhost);
+ format->try_annexb_first_ = _srs_config->try_annexb_first(r->vhost);
keep_bframe = _srs_config->get_rtc_keep_bframe(req->vhost);
keep_avc_nalu_sei = _srs_config->get_rtc_keep_avc_nalu_sei(req->vhost);
@@ -1025,18 +1025,18 @@ srs_error_t SrsRtcRtpBuilder::on_audio(SrsMediaPacket *msg)
}
// Try to init codec when startup or codec changed.
- if (format->acodec && (err = init_codec(format->acodec->id)) != srs_success) {
+ if (format->acodec_ && (err = init_codec(format->acodec_->id_)) != srs_success) {
return srs_error_wrap(err, "init codec");
}
// Ignore if no format->acodec, it means the codec is not parsed, or unknown codec.
// @issue https://github.com/ossrs/srs/issues/1506#issuecomment-562079474
- if (!format->acodec) {
+ if (!format->acodec_) {
return err;
}
// support audio codec: aac/mp3
- SrsAudioCodecId acodec = format->acodec->id;
+ SrsAudioCodecId acodec = format->acodec_->id_;
if (acodec != SrsAudioCodecIdAAC && acodec != SrsAudioCodecIdMP3) {
return err;
}
@@ -1050,10 +1050,10 @@ srs_error_t SrsRtcRtpBuilder::on_audio(SrsMediaPacket *msg)
}
// ignore sequence header
- srs_assert(format->audio);
+ srs_assert(format->audio_);
- if (format->acodec->id == SrsAudioCodecIdMP3) {
- return transcode(format->audio);
+ if (format->acodec_->id_ == SrsAudioCodecIdMP3) {
+ return transcode(format->audio_);
}
// When drop aac audio packet, never transcode.
@@ -1073,8 +1073,8 @@ srs_error_t SrsRtcRtpBuilder::on_audio(SrsMediaPacket *msg)
}
SrsParsedAudioPacket aac;
- aac.dts = format->audio->dts;
- aac.cts = format->audio->cts;
+ aac.dts_ = format->audio_->dts_;
+ aac.cts_ = format->audio_->cts_;
if ((err = aac.add_sample(adts_audio, nn_adts_audio)) == srs_success) {
// If OK, transcode the AAC to Opus and consume it.
err = transcode(&aac);
@@ -1155,17 +1155,17 @@ srs_error_t SrsRtcRtpBuilder::package_opus(SrsParsedAudioPacket *audio, SrsRtpPa
pkt->header.set_payload_type(audio_payload_type_);
pkt->header.set_ssrc(audio_ssrc_);
- pkt->frame_type = SrsFrameTypeAudio;
+ pkt->frame_type_ = SrsFrameTypeAudio;
pkt->header.set_marker(true);
pkt->header.set_sequence(audio_sequence++);
- pkt->header.set_timestamp(audio->dts * 48);
+ pkt->header.set_timestamp(audio->dts_ * 48);
SrsRtpRawPayload *raw = new SrsRtpRawPayload();
pkt->set_payload(raw, SrsRtpPacketPayloadTypeRaw);
- srs_assert(audio->nb_samples == 1);
- raw->payload = pkt->wrap(audio->samples[0].bytes, audio->samples[0].size);
- raw->nn_payload = audio->samples[0].size;
+ srs_assert(audio->nb_samples_ == 1);
+ raw->payload_ = pkt->wrap(audio->samples_[0].bytes_, audio->samples_[0].size_);
+ raw->nn_payload_ = audio->samples_[0].size_;
return err;
}
@@ -1197,12 +1197,12 @@ srs_error_t SrsRtcRtpBuilder::on_video(SrsMediaPacket *msg)
// Ignore if no format->vcodec, it means the codec is not parsed, or unsupport/unknown codec
// such as H.263 codec
- if (!format->vcodec) {
+ if (!format->vcodec_) {
return err;
}
// support video codec: h264/h265
- SrsVideoCodecId vcodec = format->vcodec->id;
+ SrsVideoCodecId vcodec = format->vcodec_->id_;
if (vcodec != SrsVideoCodecIdAVC && vcodec != SrsVideoCodecIdHEVC) {
return err;
}
@@ -1249,7 +1249,7 @@ srs_error_t SrsRtcRtpBuilder::on_video(SrsMediaPacket *msg)
for (int i = 0; i < nn_samples; i++) {
SrsNaluSample *sample = samples[i];
- if (sample->size <= kRtpMaxPayloadSize) {
+ if (sample->size_ <= kRtpMaxPayloadSize) {
if ((err = package_single_nalu(msg, sample, pkts)) != srs_success) {
return srs_error_wrap(err, "package single nalu");
}
@@ -1273,15 +1273,15 @@ srs_error_t SrsRtcRtpBuilder::filter(SrsMediaPacket *msg, SrsFormat *format, boo
srs_error_t err = srs_success;
// If IDR, we will insert SPS/PPS before IDR frame.
- if (format->video && format->video->has_idr) {
+ if (format->video_ && format->video_->has_idr_) {
has_idr = true;
}
// Update samples to shared frame.
- for (int i = 0; i < format->video->nb_samples; ++i) {
- SrsNaluSample *sample = &format->video->samples[i];
+ for (int i = 0; i < format->video_->nb_samples_; ++i) {
+ SrsNaluSample *sample = &format->video_->samples_[i];
- if (!keep_avc_nalu_sei && format->vcodec->id == SrsVideoCodecIdAVC) {
+ if (!keep_avc_nalu_sei && format->vcodec_->id_ == SrsVideoCodecIdAVC) {
SrsAvcNaluType avc_nalu_type;
if ((err = SrsParsedVideoPacket::parse_avc_nalu_type(sample, avc_nalu_type)) != srs_success) {
@@ -1297,11 +1297,11 @@ srs_error_t SrsRtcRtpBuilder::filter(SrsMediaPacket *msg, SrsFormat *format, boo
// TODO: Drop B-frame in better way, which not cause picture corruption.
if (!keep_bframe) {
bool is_b_frame = false;
- if (format->vcodec->id == SrsVideoCodecIdAVC) {
+ if (format->vcodec_->id_ == SrsVideoCodecIdAVC) {
if ((err = SrsParsedVideoPacket::parse_avc_bframe(sample, is_b_frame)) != srs_success) {
return srs_error_wrap(err, "parse bframe");
}
- } else if (format->vcodec->id == SrsVideoCodecIdHEVC) {
+ } else if (format->vcodec_->id_ == SrsVideoCodecIdHEVC) {
if ((err = SrsParsedVideoPacket::parse_hevc_bframe(sample, format, is_b_frame)) != srs_success) {
return srs_error_wrap(err, "parse bframe");
}
@@ -1322,7 +1322,7 @@ srs_error_t SrsRtcRtpBuilder::package_stap_a(SrsMediaPacket *msg, SrsRtpPacket *
srs_error_t err = srs_success;
SrsFormat *format = meta->vsh_format();
- if (!format || !format->vcodec) {
+ if (!format || !format->vcodec_) {
return err;
}
@@ -1334,7 +1334,7 @@ srs_error_t SrsRtcRtpBuilder::package_nalus(SrsMediaPacket *msg, const vectorvsh_format();
- if (!format || !format->vcodec) {
+ if (!format || !format->vcodec_) {
return err;
}
@@ -1352,7 +1352,7 @@ srs_error_t SrsRtcRtpBuilder::package_fu_a(SrsMediaPacket *msg, SrsNaluSample *s
srs_error_t err = srs_success;
SrsFormat *format = meta->vsh_format();
- if (!format || !format->vcodec) {
+ if (!format || !format->vcodec_) {
return err;
}
@@ -1514,11 +1514,11 @@ bool SrsRtcFrameBuilderVideoPacketCache::check_frame_complete(const uint16_t sta
if (!fua_payload)
continue;
- if (fua_payload->start) {
+ if (fua_payload->start_) {
++nn_fu_start;
}
- if (fua_payload->end) {
+ if (fua_payload->end_) {
++nn_fu_end;
}
}
@@ -1882,9 +1882,9 @@ srs_error_t SrsRtcFrameBuilder::transcode_audio(SrsRtpPacket *pkt)
SrsRtpRawPayload *payload = dynamic_cast(pkt->payload());
SrsParsedAudioPacket frame;
- frame.add_sample(payload->payload, payload->nn_payload);
- frame.dts = ts;
- frame.cts = 0;
+ frame.add_sample(payload->payload_, payload->nn_payload_);
+ frame.dts_ = ts;
+ frame.cts_ = 0;
err = audio_transcoder_->transcode(&frame, out_pkts);
if (err != srs_success) {
@@ -1894,8 +1894,8 @@ srs_error_t SrsRtcFrameBuilder::transcode_audio(SrsRtpPacket *pkt)
for (std::vector::iterator it = out_pkts.begin(); it != out_pkts.end(); ++it) {
SrsRtmpCommonMessage out_rtmp;
// TODO: FIXME: Should never directly use it, please define a variable with class name.
- out_rtmp.header.timestamp = (*it)->dts;
- packet_aac(&out_rtmp, (*it)->samples[0].bytes, (*it)->samples[0].size, ts, is_first_audio_);
+ out_rtmp.header_.timestamp_ = (*it)->dts_;
+ packet_aac(&out_rtmp, (*it)->samples_[0].bytes_, (*it)->samples_[0].size_, ts, is_first_audio_);
SrsMediaPacket msg;
out_rtmp.to_msg(&msg);
@@ -1913,7 +1913,7 @@ srs_error_t SrsRtcFrameBuilder::transcode_audio(SrsRtpPacket *pkt)
void SrsRtcFrameBuilder::packet_aac(SrsRtmpCommonMessage *audio, char *data, int len, uint32_t pts, bool is_header)
{
int rtmp_len = len + 2;
- audio->header.initialize_audio(rtmp_len, pts, 1);
+ audio->header_.initialize_audio(rtmp_len, pts, 1);
audio->create_payload(rtmp_len);
SrsBuffer stream(audio->payload(), rtmp_len);
uint8_t aac_flag = (SrsAudioCodecIdAAC << 4) | (SrsAudioSampleRate44100 << 2) | (SrsAudioSampleBits16bit << 1) | SrsAudioChannelsStereo;
@@ -1998,11 +1998,11 @@ srs_error_t SrsRtcFrameBuilder::packet_sequence_header_avc(SrsRtpPacket *pkt)
bool has_sps_pps_in_raw_payload = false;
SrsRtpRawPayload *raw_payload = dynamic_cast(pkt->payload());
if (raw_payload) {
- if (pkt->nalu_type == SrsAvcNaluTypeSPS) {
+ if (pkt->nalu_type_ == SrsAvcNaluTypeSPS) {
has_sps_pps_in_raw_payload = true;
srs_freep(obs_whip_sps_);
obs_whip_sps_ = pkt->copy();
- } else if (pkt->nalu_type == SrsAvcNaluTypePPS) {
+ } else if (pkt->nalu_type_ == SrsAvcNaluTypePPS) {
has_sps_pps_in_raw_payload = true;
srs_freep(obs_whip_pps_);
obs_whip_pps_ = pkt->copy();
@@ -2052,8 +2052,8 @@ srs_error_t SrsRtcFrameBuilder::do_packet_sequence_header_avc(SrsRtpPacket *pkt,
std::string sh;
SrsUniquePtr avc(new SrsRawH264Stream());
- string sps2 = string(sps->bytes, sps->size);
- string pps2 = string(pps->bytes, pps->size);
+ string sps2 = string(sps->bytes_, sps->size_);
+ string pps2 = string(pps->bytes_, pps->size_);
if ((err = avc->mux_sequence_header(sps2, pps2, sh)) != srs_success) {
return srs_error_wrap(err, "mux sequence header");
}
@@ -2093,15 +2093,15 @@ srs_error_t SrsRtcFrameBuilder::packet_sequence_header_hevc(SrsRtpPacket *pkt)
bool has_vps_sps_pps_in_raw_payload = false;
SrsRtpRawPayload *raw_payload = dynamic_cast(pkt->payload());
if (raw_payload) {
- if (pkt->nalu_type == SrsHevcNaluType_VPS) {
+ if (pkt->nalu_type_ == SrsHevcNaluType_VPS) {
has_vps_sps_pps_in_raw_payload = true;
srs_freep(obs_whip_vps_);
obs_whip_vps_ = pkt->copy();
- } else if (pkt->nalu_type == SrsHevcNaluType_SPS) {
+ } else if (pkt->nalu_type_ == SrsHevcNaluType_SPS) {
has_vps_sps_pps_in_raw_payload = true;
srs_freep(obs_whip_sps_);
obs_whip_sps_ = pkt->copy();
- } else if (pkt->nalu_type == SrsHevcNaluType_PPS) {
+ } else if (pkt->nalu_type_ == SrsHevcNaluType_PPS) {
has_vps_sps_pps_in_raw_payload = true;
srs_freep(obs_whip_pps_);
obs_whip_pps_ = pkt->copy();
@@ -2150,10 +2150,10 @@ srs_error_t SrsRtcFrameBuilder::do_packet_sequence_header_hevc(SrsRtpPacket *pkt
SrsUniquePtr hevc(new SrsRawHEVCStream());
std::vector h265_pps;
- h265_pps.push_back(string(pps->bytes, pps->size));
+ h265_pps.push_back(string(pps->bytes_, pps->size_));
std::string sh;
- if ((err = hevc->mux_sequence_header(string(vps->bytes, vps->size), string(sps->bytes, sps->size), h265_pps, sh)) != srs_success) {
+ if ((err = hevc->mux_sequence_header(string(vps->bytes_, vps->size_), string(sps->bytes_, sps->size_), h265_pps, sh)) != srs_success) {
return srs_error_wrap(err, "mux sequence header");
}
@@ -2189,9 +2189,9 @@ int SrsRtcFrameBuilder::calculate_packet_payload_size(SrsRtpPacket *pkt)
// H.264 FU-A payload
SrsRtpFUAPayload2 *fua_payload = dynamic_cast(pkt->payload());
- if (fua_payload && fua_payload->size > 0) {
- int size = fua_payload->size;
- if (fua_payload->start) {
+ if (fua_payload && fua_payload->size_ > 0) {
+ int size = fua_payload->size_;
+ if (fua_payload->start_) {
size += 1 + 4; // NALU header + length prefix
}
return size;
@@ -2201,10 +2201,10 @@ int SrsRtcFrameBuilder::calculate_packet_payload_size(SrsRtpPacket *pkt)
SrsRtpSTAPPayload *stap_payload = dynamic_cast(pkt->payload());
if (stap_payload) {
int size = 0;
- for (int j = 0; j < (int)stap_payload->nalus.size(); ++j) {
- SrsNaluSample *sample = stap_payload->nalus.at(j);
- if (sample->size > 0) {
- size += 4 + sample->size; // length prefix + NALU
+ for (int j = 0; j < (int)stap_payload->nalus_.size(); ++j) {
+ SrsNaluSample *sample = stap_payload->nalus_.at(j);
+ if (sample->size_ > 0) {
+ size += 4 + sample->size_; // length prefix + NALU
}
}
return size;
@@ -2212,9 +2212,9 @@ int SrsRtcFrameBuilder::calculate_packet_payload_size(SrsRtpPacket *pkt)
// H.265 FU-A payload
SrsRtpFUAPayloadHevc2 *fua_payload_hevc = dynamic_cast(pkt->payload());
- if (fua_payload_hevc && fua_payload_hevc->size > 0) {
- int size = fua_payload_hevc->size;
- if (fua_payload_hevc->start) {
+ if (fua_payload_hevc && fua_payload_hevc->size_ > 0) {
+ int size = fua_payload_hevc->size_;
+ if (fua_payload_hevc->start_) {
size += 2 + 4; // HEVC NALU header + length prefix
}
return size;
@@ -2224,10 +2224,10 @@ int SrsRtcFrameBuilder::calculate_packet_payload_size(SrsRtpPacket *pkt)
SrsRtpSTAPPayloadHevc *stap_payload_hevc = dynamic_cast(pkt->payload());
if (stap_payload_hevc) {
int size = 0;
- for (int j = 0; j < (int)stap_payload_hevc->nalus.size(); ++j) {
- SrsNaluSample *sample = stap_payload_hevc->nalus.at(j);
- if (sample->size > 0) {
- size += 4 + sample->size; // length prefix + NALU
+ for (int j = 0; j < (int)stap_payload_hevc->nalus_.size(); ++j) {
+ SrsNaluSample *sample = stap_payload_hevc->nalus_.at(j);
+ if (sample->size_ > 0) {
+ size += 4 + sample->size_; // length prefix + NALU
}
}
return size;
@@ -2235,8 +2235,8 @@ int SrsRtcFrameBuilder::calculate_packet_payload_size(SrsRtpPacket *pkt)
// Raw payload
SrsRtpRawPayload *raw_payload = dynamic_cast(pkt->payload());
- if (raw_payload && raw_payload->nn_payload > 0) {
- return 4 + raw_payload->nn_payload; // length prefix + payload
+ if (raw_payload && raw_payload->nn_payload_ > 0) {
+ return 4 + raw_payload->nn_payload_; // length prefix + payload
}
return 0;
@@ -2250,16 +2250,16 @@ void SrsRtcFrameBuilder::write_packet_payload_to_buffer(SrsRtpPacket *pkt, SrsBu
// H.264 FU-A payload
SrsRtpFUAPayload2 *fua_payload = dynamic_cast(pkt->payload());
- if (fua_payload && fua_payload->size > 0) {
- if (fua_payload->start) {
- nalu_len = fua_payload->size + 1;
+ if (fua_payload && fua_payload->size_ > 0) {
+ if (fua_payload->start_) {
+ nalu_len = fua_payload->size_ + 1;
payload.skip(4); // Skip 4 bytes to write nalu_len later
- payload.write_1bytes(fua_payload->nri | fua_payload->nalu_type);
- payload.write_bytes(fua_payload->payload, fua_payload->size);
+ payload.write_1bytes(fua_payload->nri_ | fua_payload->nalu_type_);
+ payload.write_bytes(fua_payload->payload_, fua_payload->size_);
} else {
- nalu_len += fua_payload->size;
- payload.write_bytes(fua_payload->payload, fua_payload->size);
- if (fua_payload->end) {
+ nalu_len += fua_payload->size_;
+ payload.write_bytes(fua_payload->payload_, fua_payload->size_);
+ if (fua_payload->end_) {
// Write nalu_len back
payload.skip(-(4 + nalu_len));
payload.write_4bytes(nalu_len);
@@ -2272,11 +2272,11 @@ void SrsRtcFrameBuilder::write_packet_payload_to_buffer(SrsRtpPacket *pkt, SrsBu
// H.264 STAP-A payload
SrsRtpSTAPPayload *stap_payload = dynamic_cast(pkt->payload());
if (stap_payload) {
- for (int j = 0; j < (int)stap_payload->nalus.size(); ++j) {
- SrsNaluSample *sample = stap_payload->nalus.at(j);
- if (sample->size > 0) {
- payload.write_4bytes(sample->size);
- payload.write_bytes(sample->bytes, sample->size);
+ for (int j = 0; j < (int)stap_payload->nalus_.size(); ++j) {
+ SrsNaluSample *sample = stap_payload->nalus_.at(j);
+ if (sample->size_ > 0) {
+ payload.write_4bytes(sample->size_);
+ payload.write_bytes(sample->bytes_, sample->size_);
}
}
return;
@@ -2284,17 +2284,17 @@ void SrsRtcFrameBuilder::write_packet_payload_to_buffer(SrsRtpPacket *pkt, SrsBu
// H.265 FU-A payload
SrsRtpFUAPayloadHevc2 *fua_payload_hevc = dynamic_cast(pkt->payload());
- if (fua_payload_hevc && fua_payload_hevc->size > 0) {
- if (fua_payload_hevc->start) {
- nalu_len = fua_payload_hevc->size + 2;
+ if (fua_payload_hevc && fua_payload_hevc->size_ > 0) {
+ if (fua_payload_hevc->start_) {
+ nalu_len = fua_payload_hevc->size_ + 2;
payload.skip(4); // Skip 4 bytes to write nalu_len later
- payload.write_1bytes(fua_payload_hevc->nalu_type << 1);
+ payload.write_1bytes(fua_payload_hevc->nalu_type_ << 1);
payload.write_1bytes(0x01);
- payload.write_bytes(fua_payload_hevc->payload, fua_payload_hevc->size);
+ payload.write_bytes(fua_payload_hevc->payload_, fua_payload_hevc->size_);
} else {
- nalu_len += fua_payload_hevc->size;
- payload.write_bytes(fua_payload_hevc->payload, fua_payload_hevc->size);
- if (fua_payload_hevc->end) {
+ nalu_len += fua_payload_hevc->size_;
+ payload.write_bytes(fua_payload_hevc->payload_, fua_payload_hevc->size_);
+ if (fua_payload_hevc->end_) {
// Write nalu_len back
payload.skip(-(4 + nalu_len));
payload.write_4bytes(nalu_len);
@@ -2307,11 +2307,11 @@ void SrsRtcFrameBuilder::write_packet_payload_to_buffer(SrsRtpPacket *pkt, SrsBu
// H.265 STAP payload
SrsRtpSTAPPayloadHevc *stap_payload_hevc = dynamic_cast(pkt->payload());
if (stap_payload_hevc) {
- for (int j = 0; j < (int)stap_payload_hevc->nalus.size(); ++j) {
- SrsNaluSample *sample = stap_payload_hevc->nalus.at(j);
- if (sample->size > 0) {
- payload.write_4bytes(sample->size);
- payload.write_bytes(sample->bytes, sample->size);
+ for (int j = 0; j < (int)stap_payload_hevc->nalus_.size(); ++j) {
+ SrsNaluSample *sample = stap_payload_hevc->nalus_.at(j);
+ if (sample->size_ > 0) {
+ payload.write_4bytes(sample->size_);
+ payload.write_bytes(sample->bytes_, sample->size_);
}
}
return;
@@ -2319,9 +2319,9 @@ void SrsRtcFrameBuilder::write_packet_payload_to_buffer(SrsRtpPacket *pkt, SrsBu
// Raw payload
SrsRtpRawPayload *raw_payload = dynamic_cast(pkt->payload());
- if (raw_payload && raw_payload->nn_payload > 0) {
- payload.write_4bytes(raw_payload->nn_payload);
- payload.write_bytes(raw_payload->payload, raw_payload->nn_payload);
+ if (raw_payload && raw_payload->nn_payload_ > 0) {
+ payload.write_4bytes(raw_payload->nn_payload_);
+ payload.write_bytes(raw_payload->payload_, raw_payload->nn_payload_);
return;
}
}
@@ -2395,7 +2395,7 @@ srs_error_t SrsRtcFrameBuilder::packet_video_rtmp(const uint16_t start, const ui
}
SrsRtmpCommonMessage rtmp;
- rtmp.header.initialize_video(nb_payload, pkt->get_avsync_time(), 1);
+ rtmp.header_.initialize_video(nb_payload, pkt->get_avsync_time(), 1);
rtmp.create_payload(nb_payload);
SrsBuffer payload(rtmp.payload(), rtmp.size());
if (video_codec_ == SrsVideoCodecIdHEVC) {
@@ -3250,7 +3250,7 @@ srs_error_t SrsRtcAudioRecvTrack::check_send_nacks()
{
srs_error_t err = srs_success;
- ++_srs_pps_sanack->sugar;
+ ++_srs_pps_sanack->sugar_;
uint32_t timeout_nacks = 0;
if ((err = do_check_send_nacks(timeout_nacks)) != srs_success) {
@@ -3279,7 +3279,7 @@ void SrsRtcVideoRecvTrack::on_before_decode_payload(SrsRtpPacket *pkt, SrsBuffer
SrsVideoCodecId codec = (SrsVideoCodecId)track_desc_->media_->codec(true);
if (codec == SrsVideoCodecIdAVC) {
uint8_t v = SrsAvcNaluTypeParse(buf->head()[0]);
- pkt->nalu_type = v;
+ pkt->nalu_type_ = v;
if (v == kStapA) {
*ppayload = new SrsRtpSTAPPayload();
@@ -3293,7 +3293,7 @@ void SrsRtcVideoRecvTrack::on_before_decode_payload(SrsRtpPacket *pkt, SrsBuffer
}
} else if (codec == SrsVideoCodecIdHEVC) {
uint8_t v = SrsHevcNaluTypeParse(buf->head()[0]);
- pkt->nalu_type = v;
+ pkt->nalu_type_ = v;
if (v == kStapHevc) {
*ppayload = new SrsRtpSTAPPayloadHevc();
@@ -3329,7 +3329,7 @@ srs_error_t SrsRtcVideoRecvTrack::check_send_nacks()
{
srs_error_t err = srs_success;
- ++_srs_pps_svnack->sugar;
+ ++_srs_pps_svnack->sugar_;
uint32_t timeout_nacks = 0;
if ((err = do_check_send_nacks(timeout_nacks)) != srs_success) {
@@ -3422,10 +3422,10 @@ SrsRtpPacket *SrsRtcSendTrack::fetch_rtp_packet(uint16_t seq)
// For NACK, it sequence must match exactly, or it cause SRTP fail.
// Return packet only when sequence is equal.
if (pkt->header.get_sequence() == seq) {
- ++_srs_pps_rhnack->sugar;
+ ++_srs_pps_rhnack->sugar_;
return pkt;
}
- ++_srs_pps_rmnack->sugar;
+ ++_srs_pps_rmnack->sugar_;
// Ignore if sequence not match.
uint32_t nn = 0;
@@ -3490,7 +3490,7 @@ srs_error_t SrsRtcSendTrack::on_recv_nack(const vector &lost_seqs)
{
srs_error_t err = srs_success;
- ++_srs_pps_rnack2->sugar;
+ ++_srs_pps_rnack2->sugar_;
for (int i = 0; i < (int)lost_seqs.size(); ++i) {
uint16_t seq = lost_seqs.at(i);
diff --git a/trunk/src/app/srs_app_rtmp_conn.cpp b/trunk/src/app/srs_app_rtmp_conn.cpp
index dfd5a59b2..24dd9dad5 100644
--- a/trunk/src/app/srs_app_rtmp_conn.cpp
+++ b/trunk/src/app/srs_app_rtmp_conn.cpp
@@ -829,11 +829,11 @@ srs_error_t SrsRtmpConn::do_playing(SrsSharedPtr source, SrsLiveC
// foreach msg, collect the duration.
// @remark: never use msg when sent it, for the protocol sdk will free it.
- if (starttime < 0 || starttime > msg->timestamp) {
- starttime = msg->timestamp;
+ if (starttime < 0 || starttime > msg->timestamp_) {
+ starttime = msg->timestamp_;
}
- duration += (msg->timestamp - starttime) * SRS_UTIME_MILLISECONDS;
- starttime = msg->timestamp;
+ duration += (msg->timestamp_ - starttime) * SRS_UTIME_MILLISECONDS;
+ starttime = msg->timestamp_;
}
}
@@ -1108,7 +1108,7 @@ srs_error_t SrsRtmpConn::handle_publish_message(SrsSharedPtr &sou
srs_error_t err = srs_success;
// process publish event.
- if (msg->header.is_amf0_command() || msg->header.is_amf3_command()) {
+ if (msg->header_.is_amf0_command() || msg->header_.is_amf3_command()) {
SrsRtmpCommand *pkt_raw = NULL;
if ((err = rtmp->decode_message(msg, &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "rtmp: decode message");
@@ -1157,14 +1157,14 @@ srs_error_t SrsRtmpConn::process_publish_message(SrsSharedPtr &so
}
// process audio packet
- if (msg->header.is_audio()) {
+ if (msg->header_.is_audio()) {
if ((err = source->on_audio(msg)) != srs_success) {
return srs_error_wrap(err, "rtmp: consume audio");
}
return err;
}
// process video packet
- if (msg->header.is_video()) {
+ if (msg->header_.is_video()) {
if ((err = source->on_video(msg)) != srs_success) {
return srs_error_wrap(err, "rtmp: consume video");
}
@@ -1172,7 +1172,7 @@ srs_error_t SrsRtmpConn::process_publish_message(SrsSharedPtr &so
}
// process aggregate packet
- if (msg->header.is_aggregate()) {
+ if (msg->header_.is_aggregate()) {
if ((err = source->on_aggregate(msg)) != srs_success) {
return srs_error_wrap(err, "rtmp: consume aggregate");
}
@@ -1180,7 +1180,7 @@ srs_error_t SrsRtmpConn::process_publish_message(SrsSharedPtr &so
}
// process onMetaData
- if (msg->header.is_amf0_data() || msg->header.is_amf3_data()) {
+ if (msg->header_.is_amf0_data() || msg->header_.is_amf3_data()) {
SrsRtmpCommand *pkt_raw = NULL;
if ((err = rtmp->decode_message(msg, &pkt_raw)) != srs_success) {
return srs_error_wrap(err, "rtmp: decode message");
@@ -1209,7 +1209,7 @@ srs_error_t SrsRtmpConn::process_play_control_msg(SrsLiveConsumer *consumer, Srs
}
SrsUniquePtr msg(msg_raw);
- if (!msg->header.is_amf0_command() && !msg->header.is_amf3_command()) {
+ if (!msg->header_.is_amf0_command() && !msg->header_.is_amf3_command()) {
return err;
}
diff --git a/trunk/src/app/srs_app_rtsp_source.cpp b/trunk/src/app/srs_app_rtsp_source.cpp
index 21eb188ae..0009837fc 100644
--- a/trunk/src/app/srs_app_rtsp_source.cpp
+++ b/trunk/src/app/srs_app_rtsp_source.cpp
@@ -467,7 +467,7 @@ srs_error_t SrsRtspSource::on_rtp(SrsRtpPacket *pkt)
// If circuit-breaker is dying, drop packet.
if (_srs_circuit_breaker->hybrid_dying_water_level()) {
- _srs_pps_aloss2->sugar += (int64_t)consumers.size();
+ _srs_pps_aloss2->sugar_ += (int64_t)consumers.size();
return err;
}
@@ -548,18 +548,18 @@ srs_error_t SrsRtspRtpBuilder::initialize_audio_track(SrsAudioCodecId codec)
audio_ssrc_ = SrsRtcSSRCGenerator::instance()->generate_ssrc();
audio_desc->ssrc_ = audio_ssrc_;
- int sample_rate = srs_flv_srates[format->acodec->sound_rate];
+ int sample_rate = srs_flv_srates[format->acodec_->sound_rate_];
audio_sample_rate_ = sample_rate;
// Build payload from actual audio format
if (codec == SrsAudioCodecIdOpus) {
// For Opus, use actual format parameters if available
- int channels = (format->acodec->sound_type == SrsAudioChannelsStereo) ? 2 : 1;
+ int channels = (format->acodec_->sound_type_ == SrsAudioChannelsStereo) ? 2 : 1;
audio_payload_type_ = kAudioPayloadType;
audio_desc->media_ = new SrsAudioPayload(audio_payload_type_, "opus", sample_rate, channels);
} else if (codec == SrsAudioCodecIdAAC) {
// For AAC, extract parameters from format
- int channels = format->acodec->aac_channels;
+ int channels = format->acodec_->aac_channels_;
audio_payload_type_ = kAudioPayloadType;
// Note: Use "MPEG4-GENERIC" instead of "AAC" for RTSP/SDP compliance
@@ -569,7 +569,7 @@ srs_error_t SrsRtspRtpBuilder::initialize_audio_track(SrsAudioCodecId codec)
// AAC requires AudioSpecificConfig in SDP fmtp line
// Build the config string from AAC sequence header
- const std::vector &asc = format->acodec->aac_extra_data;
+ const std::vector &asc = format->acodec_->aac_extra_data_;
if (!asc.empty()) {
int hex_len = asc.size() * 2;
SrsUniquePtr hex_buf(new char[hex_len + 1]);
@@ -666,9 +666,9 @@ srs_error_t SrsRtspRtpBuilder::initialize(ISrsRequest *r)
}
// Setup the SPS/PPS parsing strategy.
- format->try_annexb_first = _srs_config->try_annexb_first(r->vhost);
+ format->try_annexb_first_ = _srs_config->try_annexb_first(r->vhost);
- srs_trace("RTSP bridge from RTMP, try_annexb_first=%d", format->try_annexb_first);
+ srs_trace("RTSP bridge from RTMP, try_annexb_first=%d", format->try_annexb_first_);
return err;
}
@@ -712,12 +712,12 @@ srs_error_t SrsRtspRtpBuilder::on_audio(SrsMediaPacket *msg)
// Ignore if no format->acodec, it means the codec is not parsed, or unknown codec.
// @issue https://github.com/ossrs/srs/issues/1506#issuecomment-562079474
- if (!format->acodec) {
+ if (!format->acodec_) {
return err;
}
// support audio codec: aac/opus
- SrsAudioCodecId acodec = format->acodec->id;
+ SrsAudioCodecId acodec = format->acodec_->id_;
if (acodec != SrsAudioCodecIdAAC && acodec != SrsAudioCodecIdOpus) {
return err;
}
@@ -731,7 +731,7 @@ srs_error_t SrsRtspRtpBuilder::on_audio(SrsMediaPacket *msg)
}
// Skip empty audio frames
- if (format->audio->nb_samples == 0) {
+ if (format->audio_->nb_samples_ == 0) {
return err;
}
@@ -739,7 +739,7 @@ srs_error_t SrsRtspRtpBuilder::on_audio(SrsMediaPacket *msg)
SrsUniquePtr pkt(new SrsRtpPacket());
if (acodec == SrsAudioCodecIdAAC) {
- if ((err = package_aac(format->audio, pkt.get())) != srs_success) {
+ if ((err = package_aac(format->audio_, pkt.get())) != srs_success) {
return srs_error_wrap(err, "package aac");
}
} else {
@@ -757,17 +757,17 @@ srs_error_t SrsRtspRtpBuilder::package_aac(SrsParsedAudioPacket *audio, SrsRtpPa
{
srs_error_t err = srs_success;
- srs_assert(audio->nb_samples);
+ srs_assert(audio->nb_samples_);
// For RTSP, audio TBN is not fixed, but use the sample rate, so we
// need to convert FLV TBN(1000) to the sample rate TBN.
- int64_t dts = (int64_t)audio->dts;
+ int64_t dts = (int64_t)audio->dts_;
dts *= (int64_t)audio_sample_rate_;
dts /= 1000;
pkt->header.set_payload_type(audio_payload_type_);
pkt->header.set_ssrc(audio_ssrc_);
- pkt->frame_type = SrsFrameTypeAudio;
+ pkt->frame_type_ = SrsFrameTypeAudio;
pkt->header.set_marker(true);
pkt->header.set_sequence(audio_sequence++);
pkt->header.set_timestamp(dts);
@@ -779,12 +779,12 @@ srs_error_t SrsRtspRtpBuilder::package_aac(SrsParsedAudioPacket *audio, SrsRtpPa
// Use AAC-hbr mode with AU-headers
// Calculate total size for all AU samples
int total_au_size = 0;
- for (int i = 0; i < audio->nb_samples; i++) {
- total_au_size += audio->samples[i].size;
+ for (int i = 0; i < audio->nb_samples_; i++) {
+ total_au_size += audio->samples_[i].size_;
}
// AU-headers: 16 bits per AU (13 bits for size + 3 bits for index)
- int au_headers_length = audio->nb_samples * 16; // bits
+ int au_headers_length = audio->nb_samples_ * 16; // bits
int au_headers_bytes = (au_headers_length + 7) / 8; // convert to bytes
int payload_size = 2 + au_headers_bytes + total_au_size; // AU-headers-length(2) + AU-headers + AU data
@@ -796,22 +796,22 @@ srs_error_t SrsRtspRtpBuilder::package_aac(SrsParsedAudioPacket *audio, SrsRtpPa
buffer.write_2bytes(au_headers_length);
// Write AU-headers for each sample
- for (int i = 0; i < audio->nb_samples; i++) {
+ for (int i = 0; i < audio->nb_samples_; i++) {
// AU-header: AU-size(13 bits) + AU-index(3 bits) = 16 bits
// According to RFC 3640, AU-size comes first (MSB), then AU-index (LSB)
- uint16_t au_size = audio->samples[i].size & 0x1FFF; // 13 bits mask
- uint16_t au_index = i & 0x07; // 3 bits mask
+ uint16_t au_size = audio->samples_[i].size_ & 0x1FFF; // 13 bits mask
+ uint16_t au_index = i & 0x07; // 3 bits mask
buffer.write_2bytes((au_size << 3) | au_index);
}
// Copy all AAC AU data
- for (int i = 0; i < audio->nb_samples; i++) {
- buffer.write_bytes(audio->samples[i].bytes, audio->samples[i].size);
+ for (int i = 0; i < audio->nb_samples_; i++) {
+ buffer.write_bytes(audio->samples_[i].bytes_, audio->samples_[i].size_);
}
// Wrap the payload in the RTP packet
- raw->payload = pkt->wrap(payload.get(), payload_size);
- raw->nn_payload = payload_size;
+ raw->payload_ = pkt->wrap(payload.get(), payload_size);
+ raw->nn_payload_ = payload_size;
return err;
}
@@ -843,12 +843,12 @@ srs_error_t SrsRtspRtpBuilder::on_video(SrsMediaPacket *msg)
// Ignore if no format->vcodec, it means the codec is not parsed, or unsupport/unknown codec
// such as H.263 codec
- if (!format->vcodec) {
+ if (!format->vcodec_) {
return err;
}
// support video codec: h264/h265
- SrsVideoCodecId vcodec = format->vcodec->id;
+ SrsVideoCodecId vcodec = format->vcodec_->id_;
if (vcodec != SrsVideoCodecIdAVC && vcodec != SrsVideoCodecIdHEVC) {
return err;
}
@@ -890,7 +890,7 @@ srs_error_t SrsRtspRtpBuilder::on_video(SrsMediaPacket *msg)
for (int i = 0; i < nn_samples; i++) {
SrsNaluSample *sample = samples[i];
- if (sample->size <= kRtpMaxPayloadSize) {
+ if (sample->size_ <= kRtpMaxPayloadSize) {
if ((err = package_single_nalu(msg, sample, pkts)) != srs_success) {
return srs_error_wrap(err, "package single nalu");
}
@@ -913,13 +913,13 @@ srs_error_t SrsRtspRtpBuilder::filter(SrsMediaPacket *msg, SrsFormat *format, bo
srs_error_t err = srs_success;
// If IDR, we will insert SPS/PPS before IDR frame.
- if (format->video && format->video->has_idr) {
+ if (format->video_ && format->video_->has_idr_) {
has_idr = true;
}
// Update samples to shared frame.
- for (int i = 0; i < format->video->nb_samples; ++i) {
- SrsNaluSample *sample = &format->video->samples[i];
+ for (int i = 0; i < format->video_->nb_samples_; ++i) {
+ SrsNaluSample *sample = &format->video_->samples_[i];
samples.push_back(sample);
}
@@ -931,7 +931,7 @@ srs_error_t SrsRtspRtpBuilder::package_stap_a(SrsMediaPacket *msg, SrsRtpPacket
srs_error_t err = srs_success;
SrsFormat *format = meta->vsh_format();
- if (!format || !format->vcodec) {
+ if (!format || !format->vcodec_) {
return err;
}
@@ -943,7 +943,7 @@ srs_error_t SrsRtspRtpBuilder::package_nalus(SrsMediaPacket *msg, const vectorvsh_format();
- if (!format || !format->vcodec) {
+ if (!format || !format->vcodec_) {
return err;
}
@@ -961,7 +961,7 @@ srs_error_t SrsRtspRtpBuilder::package_fu_a(SrsMediaPacket *msg, SrsNaluSample *
srs_error_t err = srs_success;
SrsFormat *format = meta->vsh_format();
- if (!format || !format->vcodec) {
+ if (!format || !format->vcodec_) {
return err;
}
diff --git a/trunk/src/app/srs_app_server.cpp b/trunk/src/app/srs_app_server.cpp
index d144c1137..317b0faa7 100644
--- a/trunk/src/app/srs_app_server.cpp
+++ b/trunk/src/app/srs_app_server.cpp
@@ -1363,10 +1363,10 @@ srs_error_t SrsServer::srs_update_server_statistics()
srs_trace("SRS: cpu=%.2f%%,%dMB%s%s%s%s%s%s%s%s%s%s%s",
u->percent * 100, memory,
- stats.cid_desc.c_str(), stats.timer_desc.c_str(),
- stats.recvfrom_desc.c_str(), stats.io_desc.c_str(), stats.msg_desc.c_str(),
- stats.epoll_desc.c_str(), stats.sched_desc.c_str(), stats.clock_desc.c_str(),
- stats.thread_desc.c_str(), stats.free_desc.c_str(), stats.objs_desc.c_str());
+ stats.cid_desc_.c_str(), stats.timer_desc_.c_str(),
+ stats.recvfrom_desc_.c_str(), stats.io_desc_.c_str(), stats.msg_desc_.c_str(),
+ stats.epoll_desc_.c_str(), stats.sched_desc_.c_str(), stats.clock_desc_.c_str(),
+ stats.thread_desc_.c_str(), stats.free_desc_.c_str(), stats.objs_desc_.c_str());
return err;
}
diff --git a/trunk/src/app/srs_app_source.cpp b/trunk/src/app/srs_app_source.cpp
index 473f03831..133add7f0 100644
--- a/trunk/src/app/srs_app_source.cpp
+++ b/trunk/src/app/srs_app_source.cpp
@@ -85,9 +85,9 @@ srs_error_t SrsRtmpJitter::correct(SrsMediaPacket *msg, SrsRtmpJitterAlgorithm a
if (ag == SrsRtmpJitterAlgorithmZERO) {
// for the first time, last_pkt_correct_time is -1.
if (last_pkt_correct_time == -1) {
- last_pkt_correct_time = msg->timestamp;
+ last_pkt_correct_time = msg->timestamp_;
}
- msg->timestamp -= last_pkt_correct_time;
+ msg->timestamp_ -= last_pkt_correct_time;
return err;
}
@@ -98,7 +98,7 @@ srs_error_t SrsRtmpJitter::correct(SrsMediaPacket *msg, SrsRtmpJitterAlgorithm a
// full jitter algorithm, do jitter correct.
// set to 0 for metadata.
if (!msg->is_av()) {
- msg->timestamp = 0;
+ msg->timestamp_ = 0;
return err;
}
@@ -112,7 +112,7 @@ srs_error_t SrsRtmpJitter::correct(SrsMediaPacket *msg, SrsRtmpJitterAlgorithm a
* 3. last_pkt_correct_time: simply add the positive delta,
* and enforce the time monotonically.
*/
- int64_t time = msg->timestamp;
+ int64_t time = msg->timestamp_;
int64_t delta = time - last_pkt_time;
// if jitter detected, reset the delta.
@@ -124,7 +124,7 @@ srs_error_t SrsRtmpJitter::correct(SrsMediaPacket *msg, SrsRtmpJitterAlgorithm a
last_pkt_correct_time = srs_max(0, last_pkt_correct_time + delta);
- msg->timestamp = last_pkt_correct_time;
+ msg->timestamp_ = last_pkt_correct_time;
last_pkt_time = time;
return err;
@@ -259,12 +259,12 @@ srs_error_t SrsMessageQueue::enqueue(SrsMediaPacket *msg, bool *is_overflow)
// If jitter is off, the timestamp of first sequence header is zero, which wll cause SRS to shrink and drop the
// keyframes even if there is not overflow packets in queue, so we must ignore the zero timestamps, please
// @see https://github.com/ossrs/srs/pull/2186#issuecomment-953383063
- if (msg->is_av() && msg->timestamp != 0) {
+ if (msg->is_av() && msg->timestamp_ != 0) {
if (av_start_time == -1) {
- av_start_time = srs_utime_t(msg->timestamp * SRS_UTIME_MILLISECONDS);
+ av_start_time = srs_utime_t(msg->timestamp_ * SRS_UTIME_MILLISECONDS);
}
- av_end_time = srs_utime_t(msg->timestamp * SRS_UTIME_MILLISECONDS);
+ av_end_time = srs_utime_t(msg->timestamp_ * SRS_UTIME_MILLISECONDS);
}
if (max_queue_size <= 0) {
@@ -299,7 +299,7 @@ srs_error_t SrsMessageQueue::dump_packets(int max_count, SrsMediaPacket **pmsgs,
memcpy(pmsgs, omsgs, count * sizeof(SrsMediaPacket *));
SrsMediaPacket *last = omsgs[count - 1];
- av_start_time = srs_utime_t(last->timestamp * SRS_UTIME_MILLISECONDS);
+ av_start_time = srs_utime_t(last->timestamp_ * SRS_UTIME_MILLISECONDS);
if (count >= nb_msgs) {
// the pmsgs is big enough and clear msgs at most time.
@@ -364,11 +364,11 @@ void SrsMessageQueue::shrink()
// Push back sequence headers and update their timestamps.
if (video_sh) {
- video_sh->timestamp = srsu2ms(av_end_time);
+ video_sh->timestamp_ = srsu2ms(av_end_time);
msgs.push_back(video_sh);
}
if (audio_sh) {
- audio_sh->timestamp = srsu2ms(av_end_time);
+ audio_sh->timestamp_ = srsu2ms(av_end_time);
msgs.push_back(audio_sh);
}
@@ -710,7 +710,7 @@ srs_utime_t SrsGopCache::start_time()
SrsMediaPacket *msg = gop_cache[0];
srs_assert(msg);
- return srs_utime_t(msg->timestamp * SRS_UTIME_MILLISECONDS);
+ return srs_utime_t(msg->timestamp_ * SRS_UTIME_MILLISECONDS);
}
bool SrsGopCache::pure_audio()
@@ -771,7 +771,7 @@ void SrsMixQueue::clear()
void SrsMixQueue::push(SrsMediaPacket *msg)
{
- msgs.insert(std::make_pair(msg->timestamp, msg));
+ msgs.insert(std::make_pair(msg->timestamp_, msg));
if (msg->is_video()) {
nb_videos++;
@@ -951,28 +951,28 @@ srs_error_t SrsOriginHub::on_audio(SrsMediaPacket *shared_audio)
// Handle the metadata when got sequence header.
if (format->is_aac_sequence_header() || format->is_mp3_sequence_header()) {
- srs_assert(format->acodec);
- SrsAudioCodecConfig *c = format->acodec;
+ srs_assert(format->acodec_);
+ SrsAudioCodecConfig *c = format->acodec_;
static int flv_sample_sizes[] = {8, 16, 0};
static int flv_sound_types[] = {1, 2, 0};
// when got audio stream info.
SrsStatistic *stat = SrsStatistic::instance();
- if ((err = stat->on_audio_info(req_, format->acodec->id, c->sound_rate, c->sound_type, c->aac_object)) != srs_success) {
+ if ((err = stat->on_audio_info(req_, format->acodec_->id_, c->sound_rate_, c->sound_type_, c->aac_object_)) != srs_success) {
return srs_error_wrap(err, "stat audio");
}
- if (format->acodec->id == SrsAudioCodecIdMP3) {
+ if (format->acodec_->id_ == SrsAudioCodecIdMP3) {
srs_trace("%dB audio sh, codec(%d, %dbits, %dchannels, %dHZ)",
- msg->size(), c->id, flv_sample_sizes[c->sound_size], flv_sound_types[c->sound_type],
- srs_flv_srates[c->sound_rate]);
+ msg->size(), c->id_, flv_sample_sizes[c->sound_size_], flv_sound_types[c->sound_type_],
+ srs_flv_srates[c->sound_rate_]);
} else {
srs_trace("%dB audio sh, codec(%d, profile=%s, %dchannels, %dkbps, %dHZ), flv(%dbits, %dchannels, %dHZ)",
- msg->size(), c->id, srs_aac_object2str(c->aac_object).c_str(), c->aac_channels,
- c->audio_data_rate / 1000, srs_aac_srates[c->aac_sample_rate],
- flv_sample_sizes[c->sound_size], flv_sound_types[c->sound_type],
- srs_flv_srates[c->sound_rate]);
+ msg->size(), c->id_, srs_aac_object2str(c->aac_object_).c_str(), c->aac_channels_,
+ c->audio_data_rate_ / 1000, srs_aac_srates[c->aac_sample_rate_],
+ flv_sample_sizes[c->sound_size_], flv_sound_types[c->sound_type_],
+ srs_flv_srates[c->sound_rate_]);
}
}
@@ -1038,22 +1038,22 @@ srs_error_t SrsOriginHub::on_video(SrsMediaPacket *shared_video, bool is_sequenc
// cache the sequence header if h264
// donot cache the sequence header to gop_cache, return here.
if (format->is_avc_sequence_header()) {
- SrsVideoCodecConfig *c = format->vcodec;
+ SrsVideoCodecConfig *c = format->vcodec_;
srs_assert(c);
// when got video stream info.
SrsStatistic *stat = SrsStatistic::instance();
- if (c->id == SrsVideoCodecIdAVC) {
- err = stat->on_video_info(req_, c->id, c->avc_profile, c->avc_level, c->width, c->height);
+ if (c->id_ == SrsVideoCodecIdAVC) {
+ err = stat->on_video_info(req_, c->id_, c->avc_profile_, c->avc_level_, c->width_, c->height_);
srs_trace("%dB video sh, codec(%d, profile=%s, level=%s, %dx%d, %dkbps, %.1ffps, %.1fs)",
- msg->size(), c->id, srs_avc_profile2str(c->avc_profile).c_str(), srs_avc_level2str(c->avc_level).c_str(),
- c->width, c->height, c->video_data_rate / 1000, c->frame_rate, c->duration);
- } else if (c->id == SrsVideoCodecIdHEVC) {
- err = stat->on_video_info(req_, c->id, c->hevc_profile, c->hevc_level, c->width, c->height);
+ msg->size(), c->id_, srs_avc_profile2str(c->avc_profile_).c_str(), srs_avc_level2str(c->avc_level_).c_str(),
+ c->width_, c->height_, c->video_data_rate_ / 1000, c->frame_rate_, c->duration_);
+ } else if (c->id_ == SrsVideoCodecIdHEVC) {
+ err = stat->on_video_info(req_, c->id_, c->hevc_profile_, c->hevc_level_, c->width_, c->height_);
srs_trace("%dB video sh, codec(%d, profile=%s, level=%s, %dx%d, %dkbps, %.1ffps, %.1fs)",
- msg->size(), c->id, srs_hevc_profile2str(c->hevc_profile).c_str(), srs_hevc_level2str(c->hevc_level).c_str(),
- c->width, c->height, c->video_data_rate / 1000, c->frame_rate, c->duration);
+ msg->size(), c->id_, srs_hevc_profile2str(c->hevc_profile_).c_str(), srs_hevc_level2str(c->hevc_level_).c_str(),
+ c->width_, c->height_, c->video_data_rate_ / 1000, c->frame_rate_, c->duration_);
}
if (err != srs_success) {
return srs_error_wrap(err, "stat video");
@@ -1062,7 +1062,7 @@ srs_error_t SrsOriginHub::on_video(SrsMediaPacket *shared_video, bool is_sequenc
// Ignore video data when no sps/pps
// @bug https://github.com/ossrs/srs/issues/703#issuecomment-578393155
- if (format->vcodec && !format->vcodec->is_avc_codec_ok()) {
+ if (format->vcodec_ && !format->vcodec_->is_avc_codec_ok()) {
return err;
}
@@ -1435,7 +1435,7 @@ srs_error_t SrsMetaCache::dumps(SrsLiveConsumer *consumer, bool atc, SrsRtmpJitt
// copy sequence header
// copy audio sequence first, for hls to fast parse the "right" audio codec.
- if (aformat && aformat->acodec && aformat->acodec->id != SrsAudioCodecIdMP3) {
+ if (aformat && aformat->acodec_ && aformat->acodec_->id_ != SrsAudioCodecIdMP3) {
if (ds && audio && (err = consumer->enqueue(audio, atc, ag)) != srs_success) {
return srs_error_wrap(err, "enqueue audio sh");
}
@@ -1833,7 +1833,7 @@ srs_error_t SrsLiveSource::initialize(SrsSharedPtr wrapper, ISrsR
}
// Setup the SPS/PPS parsing strategy.
- format_->try_annexb_first = _srs_config->try_annexb_first(r->vhost);
+ format_->try_annexb_first_ = _srs_config->try_annexb_first(r->vhost);
if ((err = play_edge->initialize(wrapper, req)) != srs_success) {
return srs_error_wrap(err, "edge(play)");
@@ -1933,7 +1933,7 @@ srs_error_t SrsLiveSource::on_meta_data(SrsRtmpCommonMessage *msg, SrsOnMetaData
// Update the meta cache.
bool updated = false;
- if ((err = meta->update_data(&msg->header, metadata, updated)) != srs_success) {
+ if ((err = meta->update_data(&msg->header_, metadata, updated)) != srs_success) {
return srs_error_wrap(err, "update metadata");
}
if (!updated) {
@@ -1967,13 +1967,13 @@ srs_error_t SrsLiveSource::on_audio(SrsRtmpCommonMessage *shared_audio)
// Detect where stream is monotonically increasing.
if (!mix_correct && is_monotonically_increase) {
- if (last_packet_time > 0 && shared_audio->header.timestamp < last_packet_time) {
+ if (last_packet_time > 0 && shared_audio->header_.timestamp_ < last_packet_time) {
is_monotonically_increase = false;
srs_warn("AUDIO: Timestamp %" PRId64 "=>%" PRId64 ", may need mix_correct.",
- last_packet_time, shared_audio->header.timestamp);
+ last_packet_time, shared_audio->header_.timestamp_);
}
}
- last_packet_time = shared_audio->header.timestamp;
+ last_packet_time = shared_audio->header_.timestamp_;
// convert shared_audio to msg, user should not use shared_audio again.
// the payload is transfer to msg, and set to NULL in shared_audio.
@@ -2027,7 +2027,7 @@ srs_error_t SrsLiveSource::on_audio_imp(SrsMediaPacket *msg)
// Ignore if no format->acodec, it means the codec is not parsed, or unsupport/unknown codec
// such as G.711 codec
- if (!format_->acodec) {
+ if (!format_->acodec_) {
return err;
}
@@ -2083,10 +2083,10 @@ srs_error_t SrsLiveSource::on_audio_imp(SrsMediaPacket *msg)
// if atc, update the sequence header to abs time.
if (atc) {
if (meta->ash()) {
- meta->ash()->timestamp = msg->timestamp;
+ meta->ash()->timestamp_ = msg->timestamp_;
}
if (meta->data()) {
- meta->data()->timestamp = msg->timestamp;
+ meta->data()->timestamp_ = msg->timestamp_;
}
}
@@ -2099,13 +2099,13 @@ srs_error_t SrsLiveSource::on_video(SrsRtmpCommonMessage *shared_video)
// Detect where stream is monotonically increasing.
if (!mix_correct && is_monotonically_increase) {
- if (last_packet_time > 0 && shared_video->header.timestamp < last_packet_time) {
+ if (last_packet_time > 0 && shared_video->header_.timestamp_ < last_packet_time) {
is_monotonically_increase = false;
srs_warn("VIDEO: Timestamp %" PRId64 "=>%" PRId64 ", may need mix_correct.",
- last_packet_time, shared_video->header.timestamp);
+ last_packet_time, shared_video->header_.timestamp_);
}
}
- last_packet_time = shared_video->header.timestamp;
+ last_packet_time = shared_video->header_.timestamp_;
// drop any unknown header video.
// @see https://github.com/ossrs/srs/issues/421
@@ -2136,7 +2136,7 @@ srs_error_t SrsLiveSource::on_video_imp(SrsMediaPacket *msg)
// user can disable the sps parse to workaround when parse sps failed.
// @see https://github.com/ossrs/srs/issues/474
if (is_sequence_header) {
- format_->avc_parse_sps = _srs_config->get_parse_sps(req->vhost);
+ format_->avc_parse_sps_ = _srs_config->get_parse_sps(req->vhost);
}
if ((err = format_->on_video(msg)) != srs_success) {
@@ -2145,7 +2145,7 @@ srs_error_t SrsLiveSource::on_video_imp(SrsMediaPacket *msg)
// Ignore if no format->vcodec, it means the codec is not parsed, or unsupport/unknown codec
// such as H.263 codec
- if (!format_->vcodec) {
+ if (!format_->vcodec_) {
return err;
}
@@ -2197,10 +2197,10 @@ srs_error_t SrsLiveSource::on_video_imp(SrsMediaPacket *msg)
// if atc, update the sequence header to abs time.
if (atc) {
if (meta->vsh()) {
- meta->vsh()->timestamp = msg->timestamp;
+ meta->vsh()->timestamp_ = msg->timestamp_;
}
if (meta->data()) {
- meta->data()->timestamp = msg->timestamp;
+ meta->data()->timestamp_ = msg->timestamp_;
}
}
@@ -2247,7 +2247,7 @@ srs_error_t SrsLiveSource::on_aggregate(SrsRtmpCommonMessage *msg)
// adjust abs timestamp in aggregate msg.
// only -1 means uninitialized delta.
if (delta == -1) {
- delta = (int)msg->header.timestamp - (int)timestamp;
+ delta = (int)msg->header_.timestamp_ - (int)timestamp;
}
timestamp += delta;
@@ -2263,11 +2263,11 @@ srs_error_t SrsLiveSource::on_aggregate(SrsRtmpCommonMessage *msg)
// to common message.
SrsRtmpCommonMessage o;
- o.header.message_type = type;
- o.header.payload_length = data_size;
- o.header.timestamp_delta = timestamp;
- o.header.timestamp = timestamp;
- o.header.stream_id = stream_id;
+ o.header_.message_type_ = type;
+ o.header_.payload_length_ = data_size;
+ o.header_.timestamp_delta_ = timestamp;
+ o.header_.timestamp_ = timestamp;
+ o.header_.stream_id_ = stream_id;
if (data_size > 0) {
o.create_payload(data_size);
@@ -2280,11 +2280,11 @@ srs_error_t SrsLiveSource::on_aggregate(SrsRtmpCommonMessage *msg)
stream->read_4bytes();
// process parsed message
- if (o.header.is_audio()) {
+ if (o.header_.is_audio()) {
if ((err = on_audio(&o)) != srs_success) {
return srs_error_wrap(err, "consume audio");
}
- } else if (o.header.is_video()) {
+ } else if (o.header_.is_video()) {
if ((err = on_video(&o)) != srs_success) {
return srs_error_wrap(err, "consume video");
}
@@ -2431,13 +2431,13 @@ srs_error_t SrsLiveSource::consumer_dumps(SrsLiveConsumer *consumer, bool ds, bo
// if atc, update the sequence header to gop cache time.
if (atc && !gop_cache->empty()) {
if (meta->data()) {
- meta->data()->timestamp = srsu2ms(gop_cache->start_time());
+ meta->data()->timestamp_ = srsu2ms(gop_cache->start_time());
}
if (meta->vsh()) {
- meta->vsh()->timestamp = srsu2ms(gop_cache->start_time());
+ meta->vsh()->timestamp_ = srsu2ms(gop_cache->start_time());
}
if (meta->ash()) {
- meta->ash()->timestamp = srsu2ms(gop_cache->start_time());
+ meta->ash()->timestamp_ = srsu2ms(gop_cache->start_time());
}
}
diff --git a/trunk/src/app/srs_app_srt_source.cpp b/trunk/src/app/srs_app_srt_source.cpp
index 98dc3bf46..4098527a7 100644
--- a/trunk/src/app/srs_app_srt_source.cpp
+++ b/trunk/src/app/srs_app_srt_source.cpp
@@ -366,40 +366,40 @@ srs_error_t SrsSrtFrameBuilder::on_ts_message(SrsTsMessage *msg)
// When the audio SID is private stream 1, we use common audio.
// @see https://github.com/ossrs/srs/issues/740
- if (msg->channel->apply == SrsTsPidApplyAudio && msg->sid == SrsTsPESStreamIdPrivateStream1) {
- msg->sid = SrsTsPESStreamIdAudioCommon;
+ if (msg->channel_->apply_ == SrsTsPidApplyAudio && msg->sid_ == SrsTsPESStreamIdPrivateStream1) {
+ msg->sid_ = SrsTsPESStreamIdAudioCommon;
}
// when not audio/video, or not adts/annexb format, donot support.
if (msg->stream_number() != 0) {
return srs_error_new(ERROR_STREAM_CASTER_TS_ES, "ts: unsupported stream format, sid=%#x(%s-%d)",
- msg->sid, msg->is_audio() ? "A" : msg->is_video() ? "V"
- : "N",
+ msg->sid_, msg->is_audio() ? "A" : msg->is_video() ? "V"
+ : "N",
msg->stream_number());
}
// check supported codec
- if (msg->channel->stream != SrsTsStreamVideoH264 && msg->channel->stream != SrsTsStreamVideoHEVC && msg->channel->stream != SrsTsStreamAudioAAC) {
- return srs_error_new(ERROR_STREAM_CASTER_TS_CODEC, "ts: unsupported stream codec=%d", msg->channel->stream);
+ if (msg->channel_->stream_ != SrsTsStreamVideoH264 && msg->channel_->stream_ != SrsTsStreamVideoHEVC && msg->channel_->stream_ != SrsTsStreamAudioAAC) {
+ return srs_error_new(ERROR_STREAM_CASTER_TS_CODEC, "ts: unsupported stream codec=%d", msg->channel_->stream_);
}
// parse the stream.
- SrsBuffer avs(msg->payload->bytes(), msg->payload->length());
+ SrsBuffer avs(msg->payload_->bytes(), msg->payload_->length());
// publish audio or video.
- if (msg->channel->stream == SrsTsStreamVideoH264) {
+ if (msg->channel_->stream_ == SrsTsStreamVideoH264) {
if ((err = on_ts_video_avc(msg, &avs)) != srs_success) {
return srs_error_wrap(err, "ts: consume video");
}
}
- if (msg->channel->stream == SrsTsStreamAudioAAC) {
+ if (msg->channel_->stream_ == SrsTsStreamAudioAAC) {
if ((err = on_ts_audio(msg, &avs)) != srs_success) {
return srs_error_wrap(err, "ts: consume audio");
}
}
// TODO: FIXME: implements other codec?
- if (msg->channel->stream == SrsTsStreamVideoHEVC) {
+ if (msg->channel_->stream_ == SrsTsStreamVideoHEVC) {
if ((err = on_ts_video_hevc(msg, &avs)) != srs_success) {
return srs_error_wrap(err, "ts: consume hevc video");
}
@@ -484,7 +484,7 @@ srs_error_t SrsSrtFrameBuilder::check_sps_pps_change(SrsTsMessage *msg)
sps_pps_change_ = false;
// ts tbn to flv tbn.
- uint32_t dts = (uint32_t)(msg->dts / 90);
+ uint32_t dts = (uint32_t)(msg->dts_ / 90);
std::string sh;
SrsUniquePtr avc(new SrsRawH264Stream());
@@ -528,8 +528,8 @@ srs_error_t SrsSrtFrameBuilder::on_h264_frame(SrsTsMessage *msg, vectordts / 90);
- uint32_t pts = (uint32_t)(msg->pts / 90);
+ uint32_t dts = (uint32_t)(msg->dts_ / 90);
+ uint32_t pts = (uint32_t)(msg->pts_ / 90);
int32_t cts = pts - dts;
int frame_size = 5; // 5bytes video tag header
@@ -542,7 +542,7 @@ srs_error_t SrsSrtFrameBuilder::on_h264_frame(SrsTsMessage *msg, vectordts / 90);
+ uint32_t dts = (uint32_t)(msg->dts_ / 90);
std::string sh;
SrsUniquePtr hevc(new SrsRawHEVCStream());
@@ -712,8 +712,8 @@ srs_error_t SrsSrtFrameBuilder::on_hevc_frame(SrsTsMessage *msg, vectordts / 90);
- uint32_t pts = (uint32_t)(msg->pts / 90);
+ uint32_t dts = (uint32_t)(msg->dts_ / 90);
+ uint32_t pts = (uint32_t)(msg->pts_ / 90);
int32_t cts = pts - dts;
// for IDR frame, the frame is keyframe.
@@ -731,7 +731,7 @@ srs_error_t SrsSrtFrameBuilder::on_hevc_frame(SrsTsMessage *msg, vector aac(new SrsRawAacStream());
// ts tbn to flv tbn.
- uint32_t pts = (uint32_t)(msg->pts / 90);
+ uint32_t pts = (uint32_t)(msg->pts_ / 90);
int frame_idx = 0;
int duration_ms = 0;
@@ -863,7 +863,7 @@ srs_error_t SrsSrtFrameBuilder::check_audio_sh_change(SrsTsMessage *msg, uint32_
int rtmp_len = audio_sh_.size() + 2;
SrsRtmpCommonMessage rtmp;
- rtmp.header.initialize_audio(rtmp_len, pts, audio_streamid_);
+ rtmp.header_.initialize_audio(rtmp_len, pts, audio_streamid_);
rtmp.create_payload(rtmp_len);
SrsBuffer stream(rtmp.payload(), rtmp_len);
@@ -889,7 +889,7 @@ srs_error_t SrsSrtFrameBuilder::on_aac_frame(SrsTsMessage *msg, uint32_t pts, ch
int rtmp_len = data_size + 2 /* 2 bytes of flv audio tag header*/;
SrsRtmpCommonMessage rtmp;
- rtmp.header.initialize_audio(rtmp_len, pts, audio_streamid_);
+ rtmp.header_.initialize_audio(rtmp_len, pts, audio_streamid_);
rtmp.create_payload(rtmp_len);
SrsBuffer stream(rtmp.payload(), rtmp_len);
diff --git a/trunk/src/app/srs_app_statistic.cpp b/trunk/src/app/srs_app_statistic.cpp
index b447bb44b..f08b2b908 100644
--- a/trunk/src/app/srs_app_statistic.cpp
+++ b/trunk/src/app/srs_app_statistic.cpp
@@ -118,7 +118,7 @@ srs_error_t SrsStatisticStream::dumps(SrsJsonObject *obj)
obj->set("url", SrsJsonAny::str(url.c_str()));
obj->set("live_ms", SrsJsonAny::integer(srsu2ms(srs_time_now_cached())));
obj->set("clients", SrsJsonAny::integer(nb_clients));
- obj->set("frames", SrsJsonAny::integer(frames->sugar));
+ obj->set("frames", SrsJsonAny::integer(frames->sugar_));
obj->set("send_bytes", SrsJsonAny::integer(kbps->get_send_bytes()));
obj->set("recv_bytes", SrsJsonAny::integer(kbps->get_recv_bytes()));
@@ -395,7 +395,7 @@ srs_error_t SrsStatistic::on_video_frames(ISrsRequest *req, int nb_frames)
SrsStatisticVhost *vhost = create_vhost(req);
SrsStatisticStream *stream = create_stream(vhost, req);
- stream->frames->sugar += nb_frames;
+ stream->frames->sugar_ += nb_frames;
return err;
}
diff --git a/trunk/src/core/srs_core_version7.hpp b/trunk/src/core/srs_core_version7.hpp
index 096fe561e..6e0b5807e 100644
--- a/trunk/src/core/srs_core_version7.hpp
+++ b/trunk/src/core/srs_core_version7.hpp
@@ -9,6 +9,6 @@
#define VERSION_MAJOR 7
#define VERSION_MINOR 0
-#define VERSION_REVISION 81
+#define VERSION_REVISION 82
#endif
\ No newline at end of file
diff --git a/trunk/src/kernel/srs_kernel_aac.cpp b/trunk/src/kernel/srs_kernel_aac.cpp
index a1fc9df07..a626c694f 100644
--- a/trunk/src/kernel/srs_kernel_aac.cpp
+++ b/trunk/src/kernel/srs_kernel_aac.cpp
@@ -24,11 +24,11 @@ using namespace std;
SrsAacTransmuxer::SrsAacTransmuxer()
{
- writer = NULL;
- got_sequence_header = false;
- aac_object = SrsAacObjectTypeReserved;
- aac_sample_rate = 0;
- aac_channels = 0;
+ writer_ = NULL;
+ got_sequence_header_ = false;
+ aac_object_ = SrsAacObjectTypeReserved;
+ aac_sample_rate_ = 0;
+ aac_channels_ = 0;
}
SrsAacTransmuxer::~SrsAacTransmuxer()
@@ -41,7 +41,7 @@ srs_error_t SrsAacTransmuxer::initialize(ISrsStreamWriter *fs)
srs_assert(fs);
- writer = fs;
+ writer_ = fs;
return err;
}
@@ -91,20 +91,20 @@ srs_error_t SrsAacTransmuxer::write_audio(int64_t timestamp, char *data, int siz
}
int8_t audioObjectType = stream->read_1bytes();
- aac_sample_rate = stream->read_1bytes();
+ aac_sample_rate_ = stream->read_1bytes();
- aac_channels = (aac_sample_rate >> 3) & 0x0f;
- aac_sample_rate = ((audioObjectType << 1) & 0x0e) | ((aac_sample_rate >> 7) & 0x01);
+ aac_channels_ = (aac_sample_rate_ >> 3) & 0x0f;
+ aac_sample_rate_ = ((audioObjectType << 1) & 0x0e) | ((aac_sample_rate_ >> 7) & 0x01);
audioObjectType = (audioObjectType >> 3) & 0x1f;
- aac_object = (SrsAacObjectType)audioObjectType;
+ aac_object_ = (SrsAacObjectType)audioObjectType;
- got_sequence_header = true;
+ got_sequence_header_ = true;
return err;
}
- if (!got_sequence_header) {
+ if (!got_sequence_header_) {
return srs_error_new(ERROR_AAC_DECODE_ERROR, "aac no sequence header");
}
@@ -149,13 +149,13 @@ srs_error_t SrsAacTransmuxer::write_audio(int64_t timestamp, char *data, int siz
// channel_configuration 3 uimsbf
// original/copy 1 bslbf
// home 1 bslbf
- SrsAacProfile aac_profile = srs_aac_rtmp2ts(aac_object);
- *pp++ = ((aac_profile << 6) & 0xc0) | ((aac_sample_rate << 2) & 0x3c) | ((aac_channels >> 2) & 0x01);
+ SrsAacProfile aac_profile = srs_aac_rtmp2ts(aac_object_);
+ *pp++ = ((aac_profile << 6) & 0xc0) | ((aac_sample_rate_ << 2) & 0x3c) | ((aac_channels_ >> 2) & 0x01);
// 4bits left.
// adts_variable_header(), 1.A.2.2.2 Variable Header of ADTS
// copyright_identification_bit 1 bslbf
// copyright_identification_start 1 bslbf
- *pp++ = ((aac_channels << 6) & 0xc0) | ((aac_frame_length >> 11) & 0x03);
+ *pp++ = ((aac_channels_ << 6) & 0xc0) | ((aac_frame_length >> 11) & 0x03);
// aac_frame_length 13 bslbf: Length of the frame including headers and error_check in bytes.
// use the left 2bits as the 13 and 12 bit,
@@ -169,12 +169,12 @@ srs_error_t SrsAacTransmuxer::write_audio(int64_t timestamp, char *data, int siz
}
// write 7bytes fixed header.
- if ((err = writer->write(aac_fixed_header, 7, NULL)) != srs_success) {
+ if ((err = writer_->write(aac_fixed_header, 7, NULL)) != srs_success) {
return srs_error_wrap(err, "write aac header");
}
// write aac frame body.
- if ((err = writer->write(data + stream->pos(), aac_raw_length, NULL)) != srs_success) {
+ if ((err = writer_->write(data + stream->pos(), aac_raw_length, NULL)) != srs_success) {
return srs_error_wrap(err, "write aac frame");
}
diff --git a/trunk/src/kernel/srs_kernel_aac.hpp b/trunk/src/kernel/srs_kernel_aac.hpp
index 527dfdf9d..aeae1d344 100644
--- a/trunk/src/kernel/srs_kernel_aac.hpp
+++ b/trunk/src/kernel/srs_kernel_aac.hpp
@@ -20,13 +20,13 @@ class ISrsStreamWriter;
class SrsAacTransmuxer
{
private:
- ISrsStreamWriter *writer;
+ ISrsStreamWriter *writer_;
private:
- SrsAacObjectType aac_object;
- int8_t aac_sample_rate;
- int8_t aac_channels;
- bool got_sequence_header;
+ SrsAacObjectType aac_object_;
+ int8_t aac_sample_rate_;
+ int8_t aac_channels_;
+ bool got_sequence_header_;
public:
SrsAacTransmuxer();
diff --git a/trunk/src/kernel/srs_kernel_balance.cpp b/trunk/src/kernel/srs_kernel_balance.cpp
index 698bd5fc1..56209de4e 100644
--- a/trunk/src/kernel/srs_kernel_balance.cpp
+++ b/trunk/src/kernel/srs_kernel_balance.cpp
@@ -20,8 +20,8 @@ ISrsLbRoundRobin::~ISrsLbRoundRobin()
SrsLbRoundRobin::SrsLbRoundRobin()
{
- index = -1;
- count = 0;
+ index_ = -1;
+ count_ = 0;
}
SrsLbRoundRobin::~SrsLbRoundRobin()
@@ -30,20 +30,20 @@ SrsLbRoundRobin::~SrsLbRoundRobin()
uint32_t SrsLbRoundRobin::current()
{
- return index;
+ return index_;
}
string SrsLbRoundRobin::selected()
{
- return elem;
+ return elem_;
}
string SrsLbRoundRobin::select(const vector &servers)
{
srs_assert(!servers.empty());
- index = (int)(count++ % servers.size());
- elem = servers.at(index);
+ index_ = (int)(count_++ % servers.size());
+ elem_ = servers.at(index_);
- return elem;
+ return elem_;
}
diff --git a/trunk/src/kernel/srs_kernel_balance.hpp b/trunk/src/kernel/srs_kernel_balance.hpp
index 33687dc12..ba7078618 100644
--- a/trunk/src/kernel/srs_kernel_balance.hpp
+++ b/trunk/src/kernel/srs_kernel_balance.hpp
@@ -51,9 +51,9 @@ public:
class SrsLbRoundRobin : public ISrsLbRoundRobin
{
private:
- int index;
- uint32_t count;
- std::string elem;
+ int index_;
+ uint32_t count_;
+ std::string elem_;
public:
SrsLbRoundRobin();
diff --git a/trunk/src/kernel/srs_kernel_buffer.cpp b/trunk/src/kernel/srs_kernel_buffer.cpp
index 755e1a71c..7e9f210cc 100644
--- a/trunk/src/kernel/srs_kernel_buffer.cpp
+++ b/trunk/src/kernel/srs_kernel_buffer.cpp
@@ -38,8 +38,8 @@ ISrsCodec::~ISrsCodec()
SrsBuffer::SrsBuffer(char *b, int nn)
{
- p = bytes = b;
- nb_bytes = nn;
+ p_ = bytes_ = b;
+ nb_bytes_ = nn;
}
SrsBuffer::~SrsBuffer()
@@ -48,44 +48,44 @@ SrsBuffer::~SrsBuffer()
SrsBuffer *SrsBuffer::copy()
{
- SrsBuffer *cp = new SrsBuffer(bytes, nb_bytes);
- cp->p = p;
+ SrsBuffer *cp = new SrsBuffer(bytes_, nb_bytes_);
+ cp->p_ = p_;
return cp;
}
char *SrsBuffer::data()
{
- return bytes;
+ return bytes_;
}
char *SrsBuffer::head()
{
- return p;
+ return p_;
}
int SrsBuffer::size()
{
- return nb_bytes;
+ return nb_bytes_;
}
void SrsBuffer::set_size(int v)
{
- nb_bytes = v;
+ nb_bytes_ = v;
}
int SrsBuffer::pos()
{
- return (int)(p - bytes);
+ return (int)(p_ - bytes_);
}
int SrsBuffer::left()
{
- return nb_bytes - (int)(p - bytes);
+ return nb_bytes_ - (int)(p_ - bytes_);
}
bool SrsBuffer::empty()
{
- return !bytes || (p >= bytes + nb_bytes);
+ return !bytes_ || (p_ >= bytes_ + nb_bytes_);
}
bool SrsBuffer::require(int required_size)
@@ -94,23 +94,23 @@ bool SrsBuffer::require(int required_size)
return false;
}
- return required_size <= nb_bytes - (p - bytes);
+ return required_size <= nb_bytes_ - (p_ - bytes_);
}
void SrsBuffer::skip(int size)
{
- srs_assert(p);
- srs_assert(p + size >= bytes);
- srs_assert(p + size <= bytes + nb_bytes);
+ srs_assert(p_);
+ srs_assert(p_ + size >= bytes_);
+ srs_assert(p_ + size <= bytes_ + nb_bytes_);
- p += size;
+ p_ += size;
}
int8_t SrsBuffer::read_1bytes()
{
srs_assert(require(1));
- return (int8_t)*p++;
+ return (int8_t)*p_++;
}
int16_t SrsBuffer::read_2bytes()
@@ -119,8 +119,8 @@ int16_t SrsBuffer::read_2bytes()
int16_t value;
char *pp = (char *)&value;
- pp[1] = *p++;
- pp[0] = *p++;
+ pp[1] = *p_++;
+ pp[0] = *p_++;
return value;
}
@@ -131,8 +131,8 @@ int16_t SrsBuffer::read_le2bytes()
int16_t value;
char *pp = (char *)&value;
- pp[0] = *p++;
- pp[1] = *p++;
+ pp[0] = *p_++;
+ pp[1] = *p_++;
return value;
}
@@ -143,9 +143,9 @@ int32_t SrsBuffer::read_3bytes()
int32_t value = 0x00;
char *pp = (char *)&value;
- pp[2] = *p++;
- pp[1] = *p++;
- pp[0] = *p++;
+ pp[2] = *p_++;
+ pp[1] = *p_++;
+ pp[0] = *p_++;
return value;
}
@@ -156,9 +156,9 @@ int32_t SrsBuffer::read_le3bytes()
int32_t value = 0x00;
char *pp = (char *)&value;
- pp[0] = *p++;
- pp[1] = *p++;
- pp[2] = *p++;
+ pp[0] = *p_++;
+ pp[1] = *p_++;
+ pp[2] = *p_++;
return value;
}
@@ -169,10 +169,10 @@ int32_t SrsBuffer::read_4bytes()
int32_t value;
char *pp = (char *)&value;
- pp[3] = *p++;
- pp[2] = *p++;
- pp[1] = *p++;
- pp[0] = *p++;
+ pp[3] = *p_++;
+ pp[2] = *p_++;
+ pp[1] = *p_++;
+ pp[0] = *p_++;
return value;
}
@@ -183,10 +183,10 @@ int32_t SrsBuffer::read_le4bytes()
int32_t value;
char *pp = (char *)&value;
- pp[0] = *p++;
- pp[1] = *p++;
- pp[2] = *p++;
- pp[3] = *p++;
+ pp[0] = *p_++;
+ pp[1] = *p_++;
+ pp[2] = *p_++;
+ pp[3] = *p_++;
return value;
}
@@ -197,14 +197,14 @@ int64_t SrsBuffer::read_8bytes()
int64_t value;
char *pp = (char *)&value;
- pp[7] = *p++;
- pp[6] = *p++;
- pp[5] = *p++;
- pp[4] = *p++;
- pp[3] = *p++;
- pp[2] = *p++;
- pp[1] = *p++;
- pp[0] = *p++;
+ pp[7] = *p_++;
+ pp[6] = *p_++;
+ pp[5] = *p_++;
+ pp[4] = *p_++;
+ pp[3] = *p_++;
+ pp[2] = *p_++;
+ pp[1] = *p_++;
+ pp[0] = *p_++;
return value;
}
@@ -215,14 +215,14 @@ int64_t SrsBuffer::read_le8bytes()
int64_t value;
char *pp = (char *)&value;
- pp[0] = *p++;
- pp[1] = *p++;
- pp[2] = *p++;
- pp[3] = *p++;
- pp[4] = *p++;
- pp[5] = *p++;
- pp[6] = *p++;
- pp[7] = *p++;
+ pp[0] = *p_++;
+ pp[1] = *p_++;
+ pp[2] = *p_++;
+ pp[3] = *p_++;
+ pp[4] = *p_++;
+ pp[5] = *p_++;
+ pp[6] = *p_++;
+ pp[7] = *p_++;
return value;
}
@@ -232,9 +232,9 @@ string SrsBuffer::read_string(int len)
srs_assert(require(len));
std::string value;
- value.append(p, len);
+ value.append(p_, len);
- p += len;
+ p_ += len;
return value;
}
@@ -243,16 +243,16 @@ void SrsBuffer::read_bytes(char *data, int size)
{
srs_assert(require(size));
- memcpy(data, p, size);
+ memcpy(data, p_, size);
- p += size;
+ p_ += size;
}
void SrsBuffer::write_1bytes(int8_t value)
{
srs_assert(require(1));
- *p++ = value;
+ *p_++ = value;
}
void SrsBuffer::write_2bytes(int16_t value)
@@ -260,8 +260,8 @@ void SrsBuffer::write_2bytes(int16_t value)
srs_assert(require(2));
char *pp = (char *)&value;
- *p++ = pp[1];
- *p++ = pp[0];
+ *p_++ = pp[1];
+ *p_++ = pp[0];
}
void SrsBuffer::write_le2bytes(int16_t value)
@@ -269,8 +269,8 @@ void SrsBuffer::write_le2bytes(int16_t value)
srs_assert(require(2));
char *pp = (char *)&value;
- *p++ = pp[0];
- *p++ = pp[1];
+ *p_++ = pp[0];
+ *p_++ = pp[1];
}
void SrsBuffer::write_4bytes(int32_t value)
@@ -278,10 +278,10 @@ void SrsBuffer::write_4bytes(int32_t value)
srs_assert(require(4));
char *pp = (char *)&value;
- *p++ = pp[3];
- *p++ = pp[2];
- *p++ = pp[1];
- *p++ = pp[0];
+ *p_++ = pp[3];
+ *p_++ = pp[2];
+ *p_++ = pp[1];
+ *p_++ = pp[0];
}
void SrsBuffer::write_le4bytes(int32_t value)
@@ -289,10 +289,10 @@ void SrsBuffer::write_le4bytes(int32_t value)
srs_assert(require(4));
char *pp = (char *)&value;
- *p++ = pp[0];
- *p++ = pp[1];
- *p++ = pp[2];
- *p++ = pp[3];
+ *p_++ = pp[0];
+ *p_++ = pp[1];
+ *p_++ = pp[2];
+ *p_++ = pp[3];
}
void SrsBuffer::write_3bytes(int32_t value)
@@ -300,9 +300,9 @@ void SrsBuffer::write_3bytes(int32_t value)
srs_assert(require(3));
char *pp = (char *)&value;
- *p++ = pp[2];
- *p++ = pp[1];
- *p++ = pp[0];
+ *p_++ = pp[2];
+ *p_++ = pp[1];
+ *p_++ = pp[0];
}
void SrsBuffer::write_le3bytes(int32_t value)
@@ -310,9 +310,9 @@ void SrsBuffer::write_le3bytes(int32_t value)
srs_assert(require(3));
char *pp = (char *)&value;
- *p++ = pp[0];
- *p++ = pp[1];
- *p++ = pp[2];
+ *p_++ = pp[0];
+ *p_++ = pp[1];
+ *p_++ = pp[2];
}
void SrsBuffer::write_8bytes(int64_t value)
@@ -320,14 +320,14 @@ void SrsBuffer::write_8bytes(int64_t value)
srs_assert(require(8));
char *pp = (char *)&value;
- *p++ = pp[7];
- *p++ = pp[6];
- *p++ = pp[5];
- *p++ = pp[4];
- *p++ = pp[3];
- *p++ = pp[2];
- *p++ = pp[1];
- *p++ = pp[0];
+ *p_++ = pp[7];
+ *p_++ = pp[6];
+ *p_++ = pp[5];
+ *p_++ = pp[4];
+ *p_++ = pp[3];
+ *p_++ = pp[2];
+ *p_++ = pp[1];
+ *p_++ = pp[0];
}
void SrsBuffer::write_le8bytes(int64_t value)
@@ -335,14 +335,14 @@ void SrsBuffer::write_le8bytes(int64_t value)
srs_assert(require(8));
char *pp = (char *)&value;
- *p++ = pp[0];
- *p++ = pp[1];
- *p++ = pp[2];
- *p++ = pp[3];
- *p++ = pp[4];
- *p++ = pp[5];
- *p++ = pp[6];
- *p++ = pp[7];
+ *p_++ = pp[0];
+ *p_++ = pp[1];
+ *p_++ = pp[2];
+ *p_++ = pp[3];
+ *p_++ = pp[4];
+ *p_++ = pp[5];
+ *p_++ = pp[6];
+ *p_++ = pp[7];
}
void SrsBuffer::write_string(string value)
@@ -353,8 +353,8 @@ void SrsBuffer::write_string(string value)
srs_assert(require((int)value.length()));
- memcpy(p, value.data(), value.length());
- p += value.length();
+ memcpy(p_, value.data(), value.length());
+ p_ += value.length();
}
void SrsBuffer::write_bytes(char *data, int size)
@@ -365,15 +365,15 @@ void SrsBuffer::write_bytes(char *data, int size)
srs_assert(require(size));
- memcpy(p, data, size);
- p += size;
+ memcpy(p_, data, size);
+ p_ += size;
}
SrsBitBuffer::SrsBitBuffer(SrsBuffer *b)
{
- cb = 0;
- cb_left = 0;
- stream = b;
+ cb_ = 0;
+ cb_left_ = 0;
+ stream_ = b;
}
SrsBitBuffer::~SrsBitBuffer()
@@ -382,10 +382,10 @@ SrsBitBuffer::~SrsBitBuffer()
bool SrsBitBuffer::empty()
{
- if (cb_left) {
+ if (cb_left_) {
return false;
}
- return stream->empty();
+ return stream_->empty();
}
bool SrsBitBuffer::require_bits(int n)
@@ -399,20 +399,20 @@ bool SrsBitBuffer::require_bits(int n)
int8_t SrsBitBuffer::read_bit()
{
- if (!cb_left) {
- srs_assert(!stream->empty());
- cb = stream->read_1bytes();
- cb_left = 8;
+ if (!cb_left_) {
+ srs_assert(!stream_->empty());
+ cb_ = stream_->read_1bytes();
+ cb_left_ = 8;
}
- int8_t v = (cb >> (cb_left - 1)) & 0x01;
- cb_left--;
+ int8_t v = (cb_ >> (cb_left_ - 1)) & 0x01;
+ cb_left_--;
return v;
}
int SrsBitBuffer::left_bits()
{
- return cb_left + stream->left() * 8;
+ return cb_left_ + stream_->left() * 8;
}
void SrsBitBuffer::skip_bits(int n)
@@ -438,9 +438,9 @@ int32_t SrsBitBuffer::read_bits(int n)
int8_t SrsBitBuffer::read_8bits()
{
// FAST_8
- if (!cb_left) {
- srs_assert(!stream->empty());
- return stream->read_1bytes();
+ if (!cb_left_) {
+ srs_assert(!stream_->empty());
+ return stream_->read_1bytes();
}
return read_bits(8);
@@ -449,9 +449,9 @@ int8_t SrsBitBuffer::read_8bits()
int16_t SrsBitBuffer::read_16bits()
{
// FAST_16
- if (!cb_left) {
- srs_assert(!stream->empty());
- return stream->read_2bytes();
+ if (!cb_left_) {
+ srs_assert(!stream_->empty());
+ return stream_->read_2bytes();
}
return read_bits(16);
@@ -460,9 +460,9 @@ int16_t SrsBitBuffer::read_16bits()
int32_t SrsBitBuffer::read_32bits()
{
// FAST_32
- if (!cb_left) {
- srs_assert(!stream->empty());
- return stream->read_4bytes();
+ if (!cb_left_) {
+ srs_assert(!stream_->empty());
+ return stream_->read_4bytes();
}
return read_bits(32);
diff --git a/trunk/src/kernel/srs_kernel_buffer.hpp b/trunk/src/kernel/srs_kernel_buffer.hpp
index 27d160f9a..537cb265c 100644
--- a/trunk/src/kernel/srs_kernel_buffer.hpp
+++ b/trunk/src/kernel/srs_kernel_buffer.hpp
@@ -184,11 +184,11 @@ class SrsBuffer
{
private:
// Current read/write position within the buffer
- char *p;
+ char *p_;
// Pointer to the start of the buffer data (not owned by this class)
- char *bytes;
+ char *bytes_;
// Total size of the buffer in bytes
- int nb_bytes;
+ int nb_bytes_;
public:
// Create a buffer wrapper around existing memory.
@@ -404,11 +404,11 @@ class SrsBitBuffer
{
private:
// Current byte being processed (cached from stream)
- int8_t cb;
+ int8_t cb_;
// Number of unread bits remaining in current byte (0-8)
- uint8_t cb_left;
+ uint8_t cb_left_;
// Underlying byte buffer (not owned by this class)
- SrsBuffer *stream;
+ SrsBuffer *stream_;
public:
// Construct a bit buffer from an existing byte buffer.
diff --git a/trunk/src/kernel/srs_kernel_codec.cpp b/trunk/src/kernel/srs_kernel_codec.cpp
index dead7d652..0065650e3 100644
--- a/trunk/src/kernel/srs_kernel_codec.cpp
+++ b/trunk/src/kernel/srs_kernel_codec.cpp
@@ -726,16 +726,16 @@ SrsCodecConfig::~SrsCodecConfig()
SrsAudioCodecConfig::SrsAudioCodecConfig()
{
- id = SrsAudioCodecIdForbidden;
- sound_rate = SrsAudioSampleRateForbidden;
- sound_size = SrsAudioSampleBitsForbidden;
- sound_type = SrsAudioChannelsForbidden;
+ id_ = SrsAudioCodecIdForbidden;
+ sound_rate_ = SrsAudioSampleRateForbidden;
+ sound_size_ = SrsAudioSampleBitsForbidden;
+ sound_type_ = SrsAudioChannelsForbidden;
- audio_data_rate = 0;
+ audio_data_rate_ = 0;
- aac_object = SrsAacObjectTypeForbidden;
- aac_sample_rate = SrsAacSampleRateUnset; // sample rate ignored
- aac_channels = 0;
+ aac_object_ = SrsAacObjectTypeForbidden;
+ aac_sample_rate_ = SrsAacSampleRateUnset; // sample rate ignored
+ aac_channels_ = 0;
}
SrsAudioCodecConfig::~SrsAudioCodecConfig()
@@ -744,23 +744,23 @@ SrsAudioCodecConfig::~SrsAudioCodecConfig()
bool SrsAudioCodecConfig::is_aac_codec_ok()
{
- return !aac_extra_data.empty();
+ return !aac_extra_data_.empty();
}
SrsVideoCodecConfig::SrsVideoCodecConfig()
{
- id = SrsVideoCodecIdForbidden;
- video_data_rate = 0;
- frame_rate = duration = 0;
+ id_ = SrsVideoCodecIdForbidden;
+ video_data_rate_ = 0;
+ frame_rate_ = duration_ = 0;
- width = 0;
- height = 0;
+ width_ = 0;
+ height_ = 0;
- NAL_unit_length = 0;
- avc_profile = SrsAvcProfileReserved;
- avc_level = SrsAvcLevelReserved;
+ NAL_unit_length_ = 0;
+ avc_profile_ = SrsAvcProfileReserved;
+ avc_level_ = SrsAvcLevelReserved;
- payload_format = SrsAvcPayloadFormatGuess;
+ payload_format_ = SrsAvcPayloadFormatGuess;
}
SrsVideoCodecConfig::~SrsVideoCodecConfig()
@@ -769,7 +769,7 @@ SrsVideoCodecConfig::~SrsVideoCodecConfig()
bool SrsVideoCodecConfig::is_avc_codec_ok()
{
- return !avc_extra_data.empty();
+ return !avc_extra_data_.empty();
}
bool srs_avc_startswith_annexb(SrsBuffer *stream, int *pnb_start_code)
diff --git a/trunk/src/kernel/srs_kernel_codec.hpp b/trunk/src/kernel/srs_kernel_codec.hpp
index 68c3d32dd..b201a2612 100644
--- a/trunk/src/kernel/srs_kernel_codec.hpp
+++ b/trunk/src/kernel/srs_kernel_codec.hpp
@@ -519,15 +519,15 @@ enum SrsHevcSliceType {
};
struct SrsHevcNalData {
- uint16_t nal_unit_length;
- std::vector nal_unit_data;
+ uint16_t nal_unit_length_;
+ std::vector nal_unit_data_;
};
struct SrsHevcHvccNalu {
- uint8_t array_completeness;
- uint8_t nal_unit_type;
- uint16_t num_nalus;
- std::vector nal_data_vec;
+ uint8_t array_completeness_;
+ uint8_t nal_unit_type_;
+ uint16_t num_nalus_;
+ std::vector nal_data_vec_;
};
/**
@@ -551,60 +551,60 @@ const int SrsHevcMax_PPS_COUNT = 64;
*/
struct SrsHevcProfileTierLevel {
public:
- uint8_t general_profile_space;
- uint8_t general_tier_flag;
- uint8_t general_profile_idc;
- uint8_t general_profile_compatibility_flag[32];
- uint8_t general_progressive_source_flag;
- uint8_t general_interlaced_source_flag;
- uint8_t general_non_packed_constraint_flag;
- uint8_t general_frame_only_constraint_flag;
- uint8_t general_max_12bit_constraint_flag;
- uint8_t general_max_10bit_constraint_flag;
- uint8_t general_max_8bit_constraint_flag;
- uint8_t general_max_422chroma_constraint_flag;
- uint8_t general_max_420chroma_constraint_flag;
- uint8_t general_max_monochrome_constraint_flag;
- uint8_t general_intra_constraint_flag;
- uint8_t general_one_picture_only_constraint_flag;
- uint8_t general_lower_bit_rate_constraint_flag;
- uint32_t general_max_14bit_constraint_flag;
- uint8_t general_reserved_zero_7bits;
- uint64_t general_reserved_zero_33bits;
- uint64_t general_reserved_zero_34bits;
- uint64_t general_reserved_zero_35bits;
- uint64_t general_reserved_zero_43bits;
- uint8_t general_inbld_flag;
- uint8_t general_reserved_zero_bit;
- uint8_t general_level_idc;
- std::vector sub_layer_profile_present_flag;
- std::vector sub_layer_level_present_flag;
- uint8_t reserved_zero_2bits[8];
- std::vector sub_layer_profile_space;
- std::vector sub_layer_tier_flag;
- std::vector sub_layer_profile_idc;
- std::vector > sub_layer_profile_compatibility_flag;
- std::vector sub_layer_progressive_source_flag;
- std::vector sub_layer_interlaced_source_flag;
- std::vector sub_layer_non_packed_constraint_flag;
- std::vector sub_layer_frame_only_constraint_flag;
- std::vector sub_layer_max_12bit_constraint_flag;
- std::vector sub_layer_max_10bit_constraint_flag;
- std::vector sub_layer_max_8bit_constraint_flag;
- std::vector sub_layer_max_422chroma_constraint_flag;
- std::vector sub_layer_max_420chroma_constraint_flag;
- std::vector sub_layer_max_monochrome_constraint_flag;
- std::vector sub_layer_intra_constraint_flag;
- std::vector sub_layer_one_picture_only_constraint_flag;
- std::vector sub_layer_lower_bit_rate_constraint_flag;
- std::vector sub_layer_reserved_zero_7bits;
- std::vector sub_layer_reserved_zero_33bits;
- std::vector sub_layer_reserved_zero_34bits;
- std::vector sub_layer_reserved_zero_35bits;
- std::vector sub_layer_reserved_zero_43bits;
- std::vector sub_layer_inbld_flag;
- std::vector sub_layer_reserved_zero_bit;
- std::vector sub_layer_level_idc;
+ uint8_t general_profile_space_;
+ uint8_t general_tier_flag_;
+ uint8_t general_profile_idc_;
+ uint8_t general_profile_compatibility_flag_[32];
+ uint8_t general_progressive_source_flag_;
+ uint8_t general_interlaced_source_flag_;
+ uint8_t general_non_packed_constraint_flag_;
+ uint8_t general_frame_only_constraint_flag_;
+ uint8_t general_max_12bit_constraint_flag_;
+ uint8_t general_max_10bit_constraint_flag_;
+ uint8_t general_max_8bit_constraint_flag_;
+ uint8_t general_max_422chroma_constraint_flag_;
+ uint8_t general_max_420chroma_constraint_flag_;
+ uint8_t general_max_monochrome_constraint_flag_;
+ uint8_t general_intra_constraint_flag_;
+ uint8_t general_one_picture_only_constraint_flag_;
+ uint8_t general_lower_bit_rate_constraint_flag_;
+ uint32_t general_max_14bit_constraint_flag_;
+ uint8_t general_reserved_zero_7bits_;
+ uint64_t general_reserved_zero_33bits_;
+ uint64_t general_reserved_zero_34bits_;
+ uint64_t general_reserved_zero_35bits_;
+ uint64_t general_reserved_zero_43bits_;
+ uint8_t general_inbld_flag_;
+ uint8_t general_reserved_zero_bit_;
+ uint8_t general_level_idc_;
+ std::vector sub_layer_profile_present_flag_;
+ std::vector sub_layer_level_present_flag_;
+ uint8_t reserved_zero_2bits_[8];
+ std::vector sub_layer_profile_space_;
+ std::vector sub_layer_tier_flag_;
+ std::vector sub_layer_profile_idc_;
+ std::vector > sub_layer_profile_compatibility_flag_;
+ std::vector sub_layer_progressive_source_flag_;
+ std::vector sub_layer_interlaced_source_flag_;
+ std::vector sub_layer_non_packed_constraint_flag_;
+ std::vector sub_layer_frame_only_constraint_flag_;
+ std::vector sub_layer_max_12bit_constraint_flag_;
+ std::vector sub_layer_max_10bit_constraint_flag_;
+ std::vector sub_layer_max_8bit_constraint_flag_;
+ std::vector sub_layer_max_422chroma_constraint_flag_;
+ std::vector sub_layer_max_420chroma_constraint_flag_;
+ std::vector sub_layer_max_monochrome_constraint_flag_;
+ std::vector sub_layer_intra_constraint_flag_;
+ std::vector sub_layer_one_picture_only_constraint_flag_;
+ std::vector sub_layer_lower_bit_rate_constraint_flag_;
+ std::vector sub_layer_reserved_zero_7bits_;
+ std::vector sub_layer_reserved_zero_33bits_;
+ std::vector sub_layer_reserved_zero_34bits_;
+ std::vector sub_layer_reserved_zero_35bits_;
+ std::vector sub_layer_reserved_zero_43bits_;
+ std::vector sub_layer_inbld_flag_;
+ std::vector sub_layer_reserved_zero_bit_;
+ std::vector sub_layer_level_idc_;
public:
SrsHevcProfileTierLevel();
@@ -617,11 +617,11 @@ public:
* @doc ITU-T-H.265-2021.pdf, page 440.
*/
struct SrsHevcSubLayerHrdParameters {
- std::vector bit_rate_value_minus1;
- std::vector cpb_size_value_minus1;
- std::vector cpb_size_du_value_minus1;
- std::vector bit_rate_du_value_minus1;
- std::vector cbr_flag;
+ std::vector bit_rate_value_minus1_;
+ std::vector cpb_size_value_minus1_;
+ std::vector cpb_size_du_value_minus1_;
+ std::vector bit_rate_du_value_minus1_;
+ std::vector cbr_flag_;
};
/**
@@ -630,26 +630,26 @@ struct SrsHevcSubLayerHrdParameters {
* @doc ITU-T-H.265-2021.pdf, page 439.
*/
struct SrsHevcHrdParameters {
- uint8_t nal_hrd_parameters_present_flag;
- uint8_t vcl_hrd_parameters_present_flag;
- uint8_t sub_pic_hrd_params_present_flag;
- uint8_t tick_divisor_minus2;
- uint8_t du_cpb_removal_delay_increment_length_minus1;
- uint8_t sub_pic_cpb_params_in_pic_timing_sei_flag;
- uint8_t dpb_output_delay_du_length_minus1;
- uint8_t bit_rate_scale;
- uint8_t cpb_size_scale;
- uint8_t cpb_size_du_scale;
- uint8_t initial_cpb_removal_delay_length_minus1;
- uint8_t au_cpb_removal_delay_length_minus1;
- uint8_t dpb_output_delay_length_minus1;
- std::vector fixed_pic_rate_general_flag;
- std::vector fixed_pic_rate_within_cvs_flag;
- std::vector elemental_duration_in_tc_minus1;
- std::vector low_delay_hrd_flag;
- std::vector cpb_cnt_minus1;
- SrsHevcSubLayerHrdParameters sub_layer_hrd_parameters; // nal
- SrsHevcSubLayerHrdParameters sub_layer_hrd_parameters_v; // vlc
+ uint8_t nal_hrd_parameters_present_flag_;
+ uint8_t vcl_hrd_parameters_present_flag_;
+ uint8_t sub_pic_hrd_params_present_flag_;
+ uint8_t tick_divisor_minus2_;
+ uint8_t du_cpb_removal_delay_increment_length_minus1_;
+ uint8_t sub_pic_cpb_params_in_pic_timing_sei_flag_;
+ uint8_t dpb_output_delay_du_length_minus1_;
+ uint8_t bit_rate_scale_;
+ uint8_t cpb_size_scale_;
+ uint8_t cpb_size_du_scale_;
+ uint8_t initial_cpb_removal_delay_length_minus1_;
+ uint8_t au_cpb_removal_delay_length_minus1_;
+ uint8_t dpb_output_delay_length_minus1_;
+ std::vector fixed_pic_rate_general_flag_;
+ std::vector fixed_pic_rate_within_cvs_flag_;
+ std::vector elemental_duration_in_tc_minus1_;
+ std::vector low_delay_hrd_flag_;
+ std::vector cpb_cnt_minus1_;
+ SrsHevcSubLayerHrdParameters sub_layer_hrd_parameters_; // nal
+ SrsHevcSubLayerHrdParameters sub_layer_hrd_parameters_v_; // vlc
};
/**
@@ -658,11 +658,11 @@ struct SrsHevcHrdParameters {
* @doc ITU-T-H.265-2021.pdf, page 65.
*/
struct SrsHevcScalingListData {
- uint32_t scaling_list_pred_mode_flag[4][6];
- uint32_t scaling_list_pred_matrix_id_delta[4][6];
- int32_t scaling_list_dc_coef_minus8[4][6];
- uint32_t ScalingList[4][6][64];
- int32_t coefNum;
+ uint32_t scaling_list_pred_mode_flag_[4][6];
+ uint32_t scaling_list_pred_matrix_id_delta_[4][6];
+ int32_t scaling_list_dc_coef_minus8_[4][6];
+ uint32_t ScalingList_[4][6][64];
+ int32_t coefNum_;
};
/**
@@ -671,15 +671,15 @@ struct SrsHevcScalingListData {
* @doc ITU-T-H.265-2021.pdf, page 57.
*/
struct SrsHevcSpsRangeExtension {
- uint8_t transform_skip_rotation_enabled_flag;
- uint8_t transform_skip_context_enabled_flag;
- uint8_t implicit_rdpcm_enabled_flag;
- uint8_t explicit_rdpcm_enabled_flag;
- uint8_t extended_precision_processing_flag;
- uint8_t intra_smoothing_disabled_flag;
- uint8_t high_precision_offsets_enabled_flag;
- uint8_t persistent_rice_adaptation_enabled_flag;
- uint8_t cabac_bypass_alignment_enabled_flag;
+ uint8_t transform_skip_rotation_enabled_flag_;
+ uint8_t transform_skip_context_enabled_flag_;
+ uint8_t implicit_rdpcm_enabled_flag_;
+ uint8_t explicit_rdpcm_enabled_flag_;
+ uint8_t extended_precision_processing_flag_;
+ uint8_t intra_smoothing_disabled_flag_;
+ uint8_t high_precision_offsets_enabled_flag_;
+ uint8_t persistent_rice_adaptation_enabled_flag_;
+ uint8_t cabac_bypass_alignment_enabled_flag_;
};
/**
@@ -688,15 +688,15 @@ struct SrsHevcSpsRangeExtension {
* @doc ITU-T-H.265-2021.pdf, page 57.
*/
struct SrsHevcPpsRangeExtension {
- uint32_t log2_max_transform_skip_block_size_minus2;
- uint8_t cross_component_prediction_enabled_flag;
- uint8_t chroma_qp_offset_list_enabled_flag;
- uint32_t diff_cu_chroma_qp_offset_depth;
- uint32_t chroma_qp_offset_list_len_minus1;
- std::vector cb_qp_offset_list;
- std::vector cr_qp_offset_list;
- uint32_t log2_sao_offset_scale_luma;
- uint32_t log2_sao_offset_scale_chroma;
+ uint32_t log2_max_transform_skip_block_size_minus2_;
+ uint8_t cross_component_prediction_enabled_flag_;
+ uint8_t chroma_qp_offset_list_enabled_flag_;
+ uint32_t diff_cu_chroma_qp_offset_depth_;
+ uint32_t chroma_qp_offset_list_len_minus1_;
+ std::vector cb_qp_offset_list_;
+ std::vector cr_qp_offset_list_;
+ uint32_t log2_sao_offset_scale_luma_;
+ uint32_t log2_sao_offset_scale_chroma_;
};
/**
@@ -705,19 +705,19 @@ struct SrsHevcPpsRangeExtension {
* @doc ITU-T-H.265-2021.pdf, page 70.
*/
struct SrsHevcStRefPicSet {
- uint8_t inter_ref_pic_set_prediction_flag;
- int delta_idx_minus1;
- uint8_t delta_rps_sign;
- int abs_delta_rps_minus1;
- std::vector used_by_curr_pic_flag;
- std::vector use_delta_flag;
- int num_negative_pics;
- int num_positive_pics;
+ uint8_t inter_ref_pic_set_prediction_flag_;
+ int delta_idx_minus1_;
+ uint8_t delta_rps_sign_;
+ int abs_delta_rps_minus1_;
+ std::vector used_by_curr_pic_flag_;
+ std::vector use_delta_flag_;
+ int num_negative_pics_;
+ int num_positive_pics_;
- std::vector delta_poc_s0_minus1;
- std::vector used_by_curr_pic_s0_flag;
- std::vector delta_poc_s1_minus1;
- std::vector used_by_curr_pic_s1_flag;
+ std::vector delta_poc_s0_minus1_;
+ std::vector used_by_curr_pic_s0_flag_;
+ std::vector delta_poc_s1_minus1_;
+ std::vector used_by_curr_pic_s1_flag_;
};
/**
@@ -726,46 +726,46 @@ struct SrsHevcStRefPicSet {
* @doc ITU-T-H.265-2021.pdf, page 437.
*/
struct SrsHevcVuiParameters {
- uint8_t aspect_ratio_info_present_flag;
- uint8_t aspect_ratio_idc;
- int sar_width;
- int sar_height;
- uint8_t overscan_info_present_flag;
- uint8_t overscan_appropriate_flag;
- uint8_t video_signal_type_present_flag;
- uint8_t video_format;
- uint8_t video_full_range_flag;
- uint8_t colour_description_present_flag;
- uint8_t colour_primaries;
- uint8_t transfer_characteristics;
- uint8_t matrix_coeffs;
- uint8_t chroma_loc_info_present_flag;
- int chroma_sample_loc_type_top_field;
- int chroma_sample_loc_type_bottom_field;
- uint8_t neutral_chroma_indication_flag;
- uint8_t field_seq_flag;
- uint8_t frame_field_info_present_flag;
- uint8_t default_display_window_flag;
- int def_disp_win_left_offset;
- int def_disp_win_right_offset;
- int def_disp_win_top_offset;
- int def_disp_win_bottom_offset;
- uint8_t vui_timing_info_present_flag;
- uint32_t vui_num_units_in_tick;
- uint32_t vui_time_scale;
- uint8_t vui_poc_proportional_to_timing_flag;
- int vui_num_ticks_poc_diff_one_minus1;
- uint8_t vui_hrd_parameters_present_flag;
- SrsHevcHrdParameters hrd_parameters;
- uint8_t bitstream_restriction_flag;
- uint8_t tiles_fixed_structure_flag;
- uint8_t motion_vectors_over_pic_boundaries_flag;
- uint8_t restricted_ref_pic_lists_flag;
- int min_spatial_segmentation_idc;
- int max_bytes_per_pic_denom;
- int max_bits_per_min_cu_denom;
- int log2_max_mv_length_horizontal;
- int log2_max_mv_length_vertical;
+ uint8_t aspect_ratio_info_present_flag_;
+ uint8_t aspect_ratio_idc_;
+ int sar_width_;
+ int sar_height_;
+ uint8_t overscan_info_present_flag_;
+ uint8_t overscan_appropriate_flag_;
+ uint8_t video_signal_type_present_flag_;
+ uint8_t video_format_;
+ uint8_t video_full_range_flag_;
+ uint8_t colour_description_present_flag_;
+ uint8_t colour_primaries_;
+ uint8_t transfer_characteristics_;
+ uint8_t matrix_coeffs_;
+ uint8_t chroma_loc_info_present_flag_;
+ int chroma_sample_loc_type_top_field_;
+ int chroma_sample_loc_type_bottom_field_;
+ uint8_t neutral_chroma_indication_flag_;
+ uint8_t field_seq_flag_;
+ uint8_t frame_field_info_present_flag_;
+ uint8_t default_display_window_flag_;
+ int def_disp_win_left_offset_;
+ int def_disp_win_right_offset_;
+ int def_disp_win_top_offset_;
+ int def_disp_win_bottom_offset_;
+ uint8_t vui_timing_info_present_flag_;
+ uint32_t vui_num_units_in_tick_;
+ uint32_t vui_time_scale_;
+ uint8_t vui_poc_proportional_to_timing_flag_;
+ int vui_num_ticks_poc_diff_one_minus1_;
+ uint8_t vui_hrd_parameters_present_flag_;
+ SrsHevcHrdParameters hrd_parameters_;
+ uint8_t bitstream_restriction_flag_;
+ uint8_t tiles_fixed_structure_flag_;
+ uint8_t motion_vectors_over_pic_boundaries_flag_;
+ uint8_t restricted_ref_pic_lists_flag_;
+ int min_spatial_segmentation_idc_;
+ int max_bytes_per_pic_denom_;
+ int max_bits_per_min_cu_denom_;
+ int log2_max_mv_length_horizontal_;
+ int log2_max_mv_length_vertical_;
};
/**
@@ -774,33 +774,33 @@ struct SrsHevcVuiParameters {
* @doc ITU-T-H.265-2021.pdf, page 54.
*/
struct SrsHevcRbspVps {
- uint8_t vps_video_parameter_set_id; // u(4)
- uint8_t vps_base_layer_internal_flag; // u(1)
- uint8_t vps_base_layer_available_flag; // u(1)
- uint8_t vps_max_layers_minus1; // u(6)
- uint8_t vps_max_sub_layers_minus1; // u(3)
- uint8_t vps_temporal_id_nesting_flag; // u(1)
- int vps_reserved_0xffff_16bits; // u(16)
- SrsHevcProfileTierLevel ptl;
- uint8_t vps_sub_layer_ordering_info_present_flag;
+ uint8_t vps_video_parameter_set_id_; // u(4)
+ uint8_t vps_base_layer_internal_flag_; // u(1)
+ uint8_t vps_base_layer_available_flag_; // u(1)
+ uint8_t vps_max_layers_minus1_; // u(6)
+ uint8_t vps_max_sub_layers_minus1_; // u(3)
+ uint8_t vps_temporal_id_nesting_flag_; // u(1)
+ int vps_reserved_0xffff_16bits_; // u(16)
+ SrsHevcProfileTierLevel ptl_;
+ uint8_t vps_sub_layer_ordering_info_present_flag_;
// Sublayers
- uint32_t vps_max_dec_pic_buffering_minus1[8]; // max u(3)
- uint32_t vps_max_num_reorder_pics[8];
- uint32_t vps_max_latency_increase_plus1[8];
- uint8_t vps_max_layer_id;
- uint32_t vps_num_layer_sets_minus1;
- std::vector > layer_id_included_flag;
- uint8_t vps_timing_info_present_flag;
- uint32_t vps_num_units_in_tick;
- uint32_t vps_time_scale;
- uint8_t vps_poc_proportional_to_timing_flag;
- uint32_t vps_num_ticks_poc_diff_one_minus1;
- uint32_t vps_num_hrd_parameters;
- std::vector hrd_layer_set_idx;
- std::vector cprms_present_flag;
- SrsHevcHrdParameters hrd_parameters;
- uint8_t vps_extension_flag;
- uint8_t vps_extension_data_flag;
+ uint32_t vps_max_dec_pic_buffering_minus1_[8]; // max u(3)
+ uint32_t vps_max_num_reorder_pics_[8];
+ uint32_t vps_max_latency_increase_plus1_[8];
+ uint8_t vps_max_layer_id_;
+ uint32_t vps_num_layer_sets_minus1_;
+ std::vector > layer_id_included_flag_;
+ uint8_t vps_timing_info_present_flag_;
+ uint32_t vps_num_units_in_tick_;
+ uint32_t vps_time_scale_;
+ uint8_t vps_poc_proportional_to_timing_flag_;
+ uint32_t vps_num_ticks_poc_diff_one_minus1_;
+ uint32_t vps_num_hrd_parameters_;
+ std::vector hrd_layer_set_idx_;
+ std::vector cprms_present_flag_;
+ SrsHevcHrdParameters hrd_parameters_;
+ uint8_t vps_extension_flag_;
+ uint8_t vps_extension_data_flag_;
};
/**
@@ -809,64 +809,64 @@ struct SrsHevcRbspVps {
* @doc ITU-T-H.265-2021.pdf, page 55.
*/
struct SrsHevcRbspSps {
- uint8_t sps_video_parameter_set_id;
- uint8_t sps_max_sub_layers_minus1;
- uint8_t sps_temporal_id_nesting_flag;
- SrsHevcProfileTierLevel ptl;
- uint32_t sps_seq_parameter_set_id;
- uint32_t chroma_format_idc;
- uint8_t separate_colour_plane_flag;
- uint32_t pic_width_in_luma_samples;
- uint32_t pic_height_in_luma_samples;
- uint32_t conformance_window_flag;
- uint32_t conf_win_left_offset;
- uint32_t conf_win_right_offset;
- uint32_t conf_win_top_offset;
- uint32_t conf_win_bottom_offset;
- uint32_t bit_depth_luma_minus8;
- uint32_t bit_depth_chroma_minus8;
- uint32_t log2_max_pic_order_cnt_lsb_minus4;
- uint8_t sps_sub_layer_ordering_info_present_flag;
- uint32_t sps_max_dec_pic_buffering_minus1[8]; // max u(3)
- uint32_t sps_max_num_reorder_pics[8];
- uint32_t sps_max_latency_increase_plus1[8];
- uint32_t log2_min_luma_coding_block_size_minus3;
- uint32_t log2_diff_max_min_luma_coding_block_size;
- uint32_t log2_min_luma_transform_block_size_minus2;
- uint32_t log2_diff_max_min_luma_transform_block_size;
- uint32_t max_transform_hierarchy_depth_inter;
- uint32_t max_transform_hierarchy_depth_intra;
- uint8_t scaling_list_enabled_flag;
- uint8_t sps_infer_scaling_list_flag;
- uint32_t sps_scaling_list_ref_layer_id;
- uint32_t sps_scaling_list_data_present_flag;
- SrsHevcScalingListData scaling_list_data;
- uint8_t amp_enabled_flag;
- uint8_t sample_adaptive_offset_enabled_flag;
- uint8_t pcm_enabled_flag;
- uint8_t pcm_sample_bit_depth_luma_minus1;
- uint8_t pcm_sample_bit_depth_chroma_minus1;
- uint32_t log2_min_pcm_luma_coding_block_size_minus3;
- uint32_t log2_diff_max_min_pcm_luma_coding_block_size;
- uint8_t pcm_loop_filter_disabled_flag;
- uint32_t num_short_term_ref_pic_sets;
- std::vector st_ref_pic_set;
- uint8_t long_term_ref_pics_present_flag;
- uint32_t num_long_term_ref_pics_sps;
- uint32_t lt_ref_pic_poc_lsb_sps_bytes;
- std::vector lt_ref_pic_poc_lsb_sps;
- std::vector used_by_curr_pic_lt_sps_flag;
- uint8_t sps_temporal_mvp_enabled_flag;
- uint8_t strong_intra_smoothing_enabled_flag;
- uint8_t vui_parameters_present_flag;
- SrsHevcVuiParameters vui;
- uint8_t sps_extension_present_flag;
- uint8_t sps_range_extension_flag;
- uint8_t sps_multilayer_extension_flag;
- uint8_t sps_3d_extension_flag;
- uint8_t sps_extension_5bits;
- SrsHevcSpsRangeExtension sps_range_extension;
- uint8_t inter_view_mv_vert_constraint_flag; // sps_multilayer_extension_t sps_multilayer_extension;
+ uint8_t sps_video_parameter_set_id_;
+ uint8_t sps_max_sub_layers_minus1_;
+ uint8_t sps_temporal_id_nesting_flag_;
+ SrsHevcProfileTierLevel ptl_;
+ uint32_t sps_seq_parameter_set_id_;
+ uint32_t chroma_format_idc_;
+ uint8_t separate_colour_plane_flag_;
+ uint32_t pic_width_in_luma_samples_;
+ uint32_t pic_height_in_luma_samples_;
+ uint32_t conformance_window_flag_;
+ uint32_t conf_win_left_offset_;
+ uint32_t conf_win_right_offset_;
+ uint32_t conf_win_top_offset_;
+ uint32_t conf_win_bottom_offset_;
+ uint32_t bit_depth_luma_minus8_;
+ uint32_t bit_depth_chroma_minus8_;
+ uint32_t log2_max_pic_order_cnt_lsb_minus4_;
+ uint8_t sps_sub_layer_ordering_info_present_flag_;
+ uint32_t sps_max_dec_pic_buffering_minus1_[8]; // max u(3)
+ uint32_t sps_max_num_reorder_pics_[8];
+ uint32_t sps_max_latency_increase_plus1_[8];
+ uint32_t log2_min_luma_coding_block_size_minus3_;
+ uint32_t log2_diff_max_min_luma_coding_block_size_;
+ uint32_t log2_min_luma_transform_block_size_minus2_;
+ uint32_t log2_diff_max_min_luma_transform_block_size_;
+ uint32_t max_transform_hierarchy_depth_inter_;
+ uint32_t max_transform_hierarchy_depth_intra_;
+ uint8_t scaling_list_enabled_flag_;
+ uint8_t sps_infer_scaling_list_flag_;
+ uint32_t sps_scaling_list_ref_layer_id_;
+ uint32_t sps_scaling_list_data_present_flag_;
+ SrsHevcScalingListData scaling_list_data_;
+ uint8_t amp_enabled_flag_;
+ uint8_t sample_adaptive_offset_enabled_flag_;
+ uint8_t pcm_enabled_flag_;
+ uint8_t pcm_sample_bit_depth_luma_minus1_;
+ uint8_t pcm_sample_bit_depth_chroma_minus1_;
+ uint32_t log2_min_pcm_luma_coding_block_size_minus3_;
+ uint32_t log2_diff_max_min_pcm_luma_coding_block_size_;
+ uint8_t pcm_loop_filter_disabled_flag_;
+ uint32_t num_short_term_ref_pic_sets_;
+ std::vector st_ref_pic_set_;
+ uint8_t long_term_ref_pics_present_flag_;
+ uint32_t num_long_term_ref_pics_sps_;
+ uint32_t lt_ref_pic_poc_lsb_sps_bytes_;
+ std::vector lt_ref_pic_poc_lsb_sps_;
+ std::vector used_by_curr_pic_lt_sps_flag_;
+ uint8_t sps_temporal_mvp_enabled_flag_;
+ uint8_t strong_intra_smoothing_enabled_flag_;
+ uint8_t vui_parameters_present_flag_;
+ SrsHevcVuiParameters vui_;
+ uint8_t sps_extension_present_flag_;
+ uint8_t sps_range_extension_flag_;
+ uint8_t sps_multilayer_extension_flag_;
+ uint8_t sps_3d_extension_flag_;
+ uint8_t sps_extension_5bits_;
+ SrsHevcSpsRangeExtension sps_range_extension_;
+ uint8_t inter_view_mv_vert_constraint_flag_; // sps_multilayer_extension_t sps_multilayer_extension;
// sps_3d_extension_t sps_3d_extension;
// int sps_extension_data_flag; // no need
// rbsp_trailing_bits()...
@@ -878,81 +878,81 @@ struct SrsHevcRbspSps {
* @doc ITU-T-H.265-2021.pdf, page 57.
*/
struct SrsHevcRbspPps {
- uint8_t pps_pic_parameter_set_id;
- uint8_t pps_seq_parameter_set_id;
- uint8_t dependent_slice_segments_enabled_flag;
- uint8_t output_flag_present_flag;
- uint8_t num_extra_slice_header_bits;
- uint8_t sign_data_hiding_enabled_flag;
- uint8_t cabac_init_present_flag;
- uint32_t num_ref_idx_l0_default_active_minus1;
- uint32_t num_ref_idx_l1_default_active_minus1;
- int32_t init_qp_minus26;
- uint8_t constrained_intra_pred_flag;
- uint8_t transform_skip_enabled_flag;
- uint8_t cu_qp_delta_enabled_flag;
- uint32_t diff_cu_qp_delta_depth;
- int32_t pps_cb_qp_offset;
- int32_t pps_cr_qp_offset;
- uint8_t pps_slice_chroma_qp_offsets_present_flag;
- uint8_t weighted_pred_flag;
- uint32_t weighted_bipred_flag;
- uint8_t transquant_bypass_enabled_flag;
- uint8_t tiles_enabled_flag;
- uint8_t entropy_coding_sync_enabled_flag;
- uint32_t num_tile_columns_minus1;
- uint32_t num_tile_rows_minus1;
- uint32_t uniform_spacing_flag;
- std::vector column_width_minus1;
- std::vector row_height_minus1;
- uint8_t loop_filter_across_tiles_enabled_flag;
- uint8_t pps_loop_filter_across_slices_enabled_flag;
- uint8_t deblocking_filter_control_present_flag;
- uint8_t deblocking_filter_override_enabled_flag;
- uint8_t pps_deblocking_filter_disabled_flag;
- int32_t pps_beta_offset_div2;
- int32_t pps_tc_offset_div2;
- uint8_t pps_scaling_list_data_present_flag;
- SrsHevcScalingListData scaling_list_data;
- uint8_t lists_modification_present_flag;
- uint32_t log2_parallel_merge_level_minus2;
- uint8_t slice_segment_header_extension_present_flag;
- uint8_t pps_extension_present_flag;
- uint8_t pps_range_extension_flag;
- uint8_t pps_multilayer_extension_flag;
- uint8_t pps_3d_extension_flag;
- uint8_t pps_scc_extension_flag;
- uint8_t pps_extension_4bits;
- SrsHevcPpsRangeExtension pps_range_extension;
+ uint8_t pps_pic_parameter_set_id_;
+ uint8_t pps_seq_parameter_set_id_;
+ uint8_t dependent_slice_segments_enabled_flag_;
+ uint8_t output_flag_present_flag_;
+ uint8_t num_extra_slice_header_bits_;
+ uint8_t sign_data_hiding_enabled_flag_;
+ uint8_t cabac_init_present_flag_;
+ uint32_t num_ref_idx_l0_default_active_minus1_;
+ uint32_t num_ref_idx_l1_default_active_minus1_;
+ int32_t init_qp_minus26_;
+ uint8_t constrained_intra_pred_flag_;
+ uint8_t transform_skip_enabled_flag_;
+ uint8_t cu_qp_delta_enabled_flag_;
+ uint32_t diff_cu_qp_delta_depth_;
+ int32_t pps_cb_qp_offset_;
+ int32_t pps_cr_qp_offset_;
+ uint8_t pps_slice_chroma_qp_offsets_present_flag_;
+ uint8_t weighted_pred_flag_;
+ uint32_t weighted_bipred_flag_;
+ uint8_t transquant_bypass_enabled_flag_;
+ uint8_t tiles_enabled_flag_;
+ uint8_t entropy_coding_sync_enabled_flag_;
+ uint32_t num_tile_columns_minus1_;
+ uint32_t num_tile_rows_minus1_;
+ uint32_t uniform_spacing_flag_;
+ std::vector column_width_minus1_;
+ std::vector row_height_minus1_;
+ uint8_t loop_filter_across_tiles_enabled_flag_;
+ uint8_t pps_loop_filter_across_slices_enabled_flag_;
+ uint8_t deblocking_filter_control_present_flag_;
+ uint8_t deblocking_filter_override_enabled_flag_;
+ uint8_t pps_deblocking_filter_disabled_flag_;
+ int32_t pps_beta_offset_div2_;
+ int32_t pps_tc_offset_div2_;
+ uint8_t pps_scaling_list_data_present_flag_;
+ SrsHevcScalingListData scaling_list_data_;
+ uint8_t lists_modification_present_flag_;
+ uint32_t log2_parallel_merge_level_minus2_;
+ uint8_t slice_segment_header_extension_present_flag_;
+ uint8_t pps_extension_present_flag_;
+ uint8_t pps_range_extension_flag_;
+ uint8_t pps_multilayer_extension_flag_;
+ uint8_t pps_3d_extension_flag_;
+ uint8_t pps_scc_extension_flag_;
+ uint8_t pps_extension_4bits_;
+ SrsHevcPpsRangeExtension pps_range_extension_;
// pps_multilayer_extension_t pps_multilayer_extension;
// pps_3d_extension_t pps_3d_extension;
- uint8_t pps_extension_data_flag;
+ uint8_t pps_extension_data_flag_;
// rbsp_trailing_bits( ) ...
};
struct SrsHevcDecoderConfigurationRecord {
- uint8_t configuration_version;
- uint8_t general_profile_space;
- uint8_t general_tier_flag;
- uint8_t general_profile_idc;
- uint32_t general_profile_compatibility_flags;
- uint64_t general_constraint_indicator_flags;
- uint8_t general_level_idc;
- uint16_t min_spatial_segmentation_idc;
- uint8_t parallelism_type;
- uint8_t chroma_format;
- uint8_t bit_depth_luma_minus8;
- uint8_t bit_depth_chroma_minus8;
- uint16_t avg_frame_rate;
- uint8_t constant_frame_rate;
- uint8_t num_temporal_layers;
- uint8_t temporal_id_nested;
- uint8_t length_size_minus_one;
- std::vector nalu_vec;
+ uint8_t configuration_version_;
+ uint8_t general_profile_space_;
+ uint8_t general_tier_flag_;
+ uint8_t general_profile_idc_;
+ uint32_t general_profile_compatibility_flags_;
+ uint64_t general_constraint_indicator_flags_;
+ uint8_t general_level_idc_;
+ uint16_t min_spatial_segmentation_idc_;
+ uint8_t parallelism_type_;
+ uint8_t chroma_format_;
+ uint8_t bit_depth_luma_minus8_;
+ uint8_t bit_depth_chroma_minus8_;
+ uint16_t avg_frame_rate_;
+ uint8_t constant_frame_rate_;
+ uint8_t num_temporal_layers_;
+ uint8_t temporal_id_nested_;
+ uint8_t length_size_minus_one_;
+ std::vector nalu_vec_;
- SrsHevcRbspVps vps_table[SrsHevcMax_VPS_COUNT];
- SrsHevcRbspSps sps_table[SrsHevcMax_SPS_COUNT];
- SrsHevcRbspPps pps_table[SrsHevcMax_PPS_COUNT];
+ SrsHevcRbspVps vps_table_[SrsHevcMax_VPS_COUNT];
+ SrsHevcRbspSps sps_table_[SrsHevcMax_SPS_COUNT];
+ SrsHevcRbspPps pps_table_[SrsHevcMax_PPS_COUNT];
};
/**
@@ -1132,15 +1132,15 @@ class SrsAudioCodecConfig : public SrsCodecConfig
// In FLV specification.
public:
// The audio codec id; for FLV, it's SoundFormat.
- SrsAudioCodecId id;
+ SrsAudioCodecId id_;
// The audio sample rate; for FLV, it's SoundRate.
- SrsAudioSampleRate sound_rate;
+ SrsAudioSampleRate sound_rate_;
// The audio sample size, such as 16 bits; for FLV, it's SoundSize.
- SrsAudioSampleBits sound_size;
+ SrsAudioSampleBits sound_size_;
// The audio number of channels; for FLV, it's SoundType.
// TODO: FIXME: Rename to sound_channels.
- SrsAudioChannels sound_type;
- int audio_data_rate; // in bps
+ SrsAudioChannels sound_type_;
+ int audio_data_rate_; // in bps
// In AAC specification.
public:
/**
@@ -1149,15 +1149,15 @@ public:
* 1.5.1.1 Audio object type definition, page 23,
* in ISO_IEC_14496-3-AAC-2001.pdf.
*/
- SrsAacObjectType aac_object;
+ SrsAacObjectType aac_object_;
/**
* samplingFrequencyIndex
*/
- uint8_t aac_sample_rate;
+ uint8_t aac_sample_rate_;
/**
* channelConfiguration
*/
- uint8_t aac_channels;
+ uint8_t aac_channels_;
// Sequence header payload.
public:
/**
@@ -1165,7 +1165,7 @@ public:
* without the flv codec header,
* @see: ffmpeg, AVCodecContext::extradata
*/
- std::vector aac_extra_data;
+ std::vector aac_extra_data_;
public:
SrsAudioCodecConfig();
@@ -1181,12 +1181,12 @@ public:
class SrsVideoCodecConfig : public SrsCodecConfig
{
public:
- SrsVideoCodecId id;
- int video_data_rate; // in bps
- double frame_rate;
- double duration;
- int width;
- int height;
+ SrsVideoCodecId id_;
+ int video_data_rate_; // in bps
+ double frame_rate_;
+ double duration_;
+ int width_;
+ int height_;
public:
/**
@@ -1194,29 +1194,29 @@ public:
* without the flv codec header,
* @see: ffmpeg, AVCodecContext::extradata
*/
- std::vector avc_extra_data;
+ std::vector avc_extra_data_;
public:
/**
* video specified
*/
// profile_idc, ISO_IEC_14496-10-AVC-2003.pdf, page 45.
- SrsAvcProfile avc_profile;
+ SrsAvcProfile avc_profile_;
// level_idc, ISO_IEC_14496-10-AVC-2003.pdf, page 45.
- SrsAvcLevel avc_level;
+ SrsAvcLevel avc_level_;
// The profile_idc, ITU-T-H.265-2021.pdf, page 62.
- SrsHevcProfile hevc_profile;
+ SrsHevcProfile hevc_profile_;
// The level_idc, ITU-T-H.265-2021.pdf, page 63.
- SrsHevcLevel hevc_level;
+ SrsHevcLevel hevc_level_;
// lengthSizeMinusOne, ISO_IEC_14496-15-AVC-format-2012.pdf, page 16
- int8_t NAL_unit_length;
+ int8_t NAL_unit_length_;
// Note that we may resize the vector, so the under-layer bytes may change.
- std::vector sequenceParameterSetNALUnit;
- std::vector pictureParameterSetNALUnit;
+ std::vector sequenceParameterSetNALUnit_;
+ std::vector pictureParameterSetNALUnit_;
public:
// the avc payload format.
- SrsAvcPayloadFormat payload_format;
+ SrsAvcPayloadFormat payload_format_;
public:
SrsHevcDecoderConfigurationRecord hevc_dec_conf_record_;
diff --git a/trunk/src/kernel/srs_kernel_error.cpp b/trunk/src/kernel/srs_kernel_error.cpp
index 12e1b11a4..002c829f3 100644
--- a/trunk/src/kernel/srs_kernel_error.cpp
+++ b/trunk/src/kernel/srs_kernel_error.cpp
@@ -214,21 +214,21 @@ bool srs_is_server_gracefully_close(srs_error_t err)
SrsCplxError::SrsCplxError()
{
- code = ERROR_SUCCESS;
- wrapped = NULL;
- rerrno = line = 0;
+ code_ = ERROR_SUCCESS;
+ wrapped_ = NULL;
+ rerrno_ = line_ = 0;
}
SrsCplxError::~SrsCplxError()
{
- srs_freep(wrapped);
+ srs_freep(wrapped_);
}
std::string SrsCplxError::description()
{
- if (desc.empty()) {
+ if (desc_.empty()) {
stringstream ss;
- ss << "code=" << code;
+ ss << "code=" << code_;
string code_str = srs_error_code_str(this);
if (!code_str.empty())
@@ -240,36 +240,36 @@ std::string SrsCplxError::description()
SrsCplxError *next = this;
while (next) {
- ss << " : " << next->msg;
- next = next->wrapped;
+ ss << " : " << next->msg_;
+ next = next->wrapped_;
}
ss << endl;
next = this;
while (next) {
- ss << "thread [" << getpid() << "][" << next->cid.c_str() << "]: "
- << next->func << "() [" << next->file << ":" << next->line << "]"
- << "[errno=" << next->rerrno << "]";
+ ss << "thread [" << getpid() << "][" << next->cid_.c_str() << "]: "
+ << next->func_ << "() [" << next->file_ << ":" << next->line_ << "]"
+ << "[errno=" << next->rerrno_ << "]";
- next = next->wrapped;
+ next = next->wrapped_;
if (next) {
ss << endl;
}
}
- desc = ss.str();
+ desc_ = ss.str();
}
- return desc;
+ return desc_;
}
std::string SrsCplxError::summary()
{
- if (_summary.empty()) {
+ if (summary_.empty()) {
stringstream ss;
- ss << "code=" << code;
+ ss << "code=" << code_;
string code_str = srs_error_code_str(this);
if (!code_str.empty())
@@ -277,14 +277,14 @@ std::string SrsCplxError::summary()
SrsCplxError *next = this;
while (next) {
- ss << " : " << next->msg;
- next = next->wrapped;
+ ss << " : " << next->msg_;
+ next = next->wrapped_;
}
- _summary = ss.str();
+ summary_ = ss.str();
}
- return _summary;
+ return summary_;
}
SrsCplxError *SrsCplxError::create(const char *func, const char *file, int line, int code, const char *fmt, ...)
@@ -299,17 +299,17 @@ SrsCplxError *SrsCplxError::create(const char *func, const char *file, int line,
SrsCplxError *err = new SrsCplxError();
- err->func = func;
- err->file = file;
- err->line = line;
- err->code = code;
- err->rerrno = rerrno;
+ err->func_ = func;
+ err->file_ = file;
+ err->line_ = line;
+ err->code_ = code;
+ err->rerrno_ = rerrno;
if (r0 > 0 && r0 < maxLogBuf) {
- err->msg = string(buffer, r0);
+ err->msg_ = string(buffer, r0);
}
- err->wrapped = NULL;
+ err->wrapped_ = NULL;
if (_srs_context) {
- err->cid = _srs_context->get_id();
+ err->cid_ = _srs_context->get_id();
}
return err;
@@ -327,19 +327,19 @@ SrsCplxError *SrsCplxError::wrap(const char *func, const char *file, int line, S
SrsCplxError *err = new SrsCplxError();
- err->func = func;
- err->file = file;
- err->line = line;
+ err->func_ = func;
+ err->file_ = file;
+ err->line_ = line;
if (v) {
- err->code = v->code;
+ err->code_ = v->code_;
}
- err->rerrno = rerrno;
+ err->rerrno_ = rerrno;
if (r0 > 0 && r0 < maxLogBuf) {
- err->msg = string(buffer, r0);
+ err->msg_ = string(buffer, r0);
}
- err->wrapped = v;
+ err->wrapped_ = v;
if (_srs_context) {
- err->cid = _srs_context->get_id();
+ err->cid_ = _srs_context->get_id();
}
return err;
@@ -358,15 +358,15 @@ SrsCplxError *SrsCplxError::copy(SrsCplxError *from)
SrsCplxError *err = new SrsCplxError();
- err->code = from->code;
- err->wrapped = srs_error_copy(from->wrapped);
- err->msg = from->msg;
- err->func = from->func;
- err->file = from->file;
- err->line = from->line;
- err->cid = from->cid;
- err->rerrno = from->rerrno;
- err->desc = from->desc;
+ err->code_ = from->code_;
+ err->wrapped_ = srs_error_copy(from->wrapped_);
+ err->msg_ = from->msg_;
+ err->func_ = from->func_;
+ err->file_ = from->file_;
+ err->line_ = from->line_;
+ err->cid_ = from->cid_;
+ err->rerrno_ = from->rerrno_;
+ err->desc_ = from->desc_;
return err;
}
@@ -383,7 +383,7 @@ string SrsCplxError::summary(SrsCplxError *err)
int SrsCplxError::error_code(SrsCplxError *err)
{
- return err ? err->code : ERROR_SUCCESS;
+ return err ? err->code_ : ERROR_SUCCESS;
}
#define SRS_STRERRNO_GEN(n, v, m, s) {(SrsErrorCode)v, m, s},
diff --git a/trunk/src/kernel/srs_kernel_error.hpp b/trunk/src/kernel/srs_kernel_error.hpp
index 341bba819..f6e08b550 100644
--- a/trunk/src/kernel/srs_kernel_error.hpp
+++ b/trunk/src/kernel/srs_kernel_error.hpp
@@ -434,19 +434,19 @@ extern bool srs_is_server_gracefully_close(srs_error_t err);
class SrsCplxError
{
private:
- int code;
- SrsCplxError *wrapped;
- std::string msg;
+ int code_;
+ SrsCplxError *wrapped_;
+ std::string msg_;
- std::string func;
- std::string file;
- int line;
+ std::string func_;
+ std::string file_;
+ int line_;
- SrsContextId cid;
- int rerrno;
+ SrsContextId cid_;
+ int rerrno_;
- std::string desc;
- std::string _summary;
+ std::string desc_;
+ std::string summary_;
private:
SrsCplxError();
diff --git a/trunk/src/kernel/srs_kernel_file.cpp b/trunk/src/kernel/srs_kernel_file.cpp
index fe91c9176..1284eb960 100644
--- a/trunk/src/kernel/srs_kernel_file.cpp
+++ b/trunk/src/kernel/srs_kernel_file.cpp
@@ -201,7 +201,7 @@ SrsFileReader *ISrsFileReaderFactory::create_file_reader()
SrsFileReader::SrsFileReader()
{
- fd = -1;
+ fd_ = -1;
}
SrsFileReader::~SrsFileReader()
@@ -213,15 +213,15 @@ srs_error_t SrsFileReader::open(string p)
{
srs_error_t err = srs_success;
- if (fd > 0) {
- return srs_error_new(ERROR_SYSTEM_FILE_ALREADY_OPENED, "file %s already opened", path.c_str());
+ if (fd_ > 0) {
+ return srs_error_new(ERROR_SYSTEM_FILE_ALREADY_OPENED, "file %s already opened", path_.c_str());
}
- if ((fd = _srs_open_fn(p.c_str(), O_RDONLY)) < 0) {
+ if ((fd_ = _srs_open_fn(p.c_str(), O_RDONLY)) < 0) {
return srs_error_new(ERROR_SYSTEM_FILE_OPENE, "open file %s failed", p.c_str());
}
- path = p;
+ path_ = p;
return err;
}
@@ -230,45 +230,45 @@ void SrsFileReader::close()
{
int ret = ERROR_SUCCESS;
- if (fd < 0) {
+ if (fd_ < 0) {
return;
}
- if (_srs_close_fn(fd) < 0) {
- srs_warn("close file %s failed. ret=%d", path.c_str(), ret);
+ if (_srs_close_fn(fd_) < 0) {
+ srs_warn("close file %s failed. ret=%d", path_.c_str(), ret);
}
- fd = -1;
+ fd_ = -1;
return;
}
bool SrsFileReader::is_open()
{
- return fd > 0;
+ return fd_ > 0;
}
int64_t SrsFileReader::tellg()
{
- return (int64_t)_srs_lseek_fn(fd, 0, SEEK_CUR);
+ return (int64_t)_srs_lseek_fn(fd_, 0, SEEK_CUR);
}
void SrsFileReader::skip(int64_t size)
{
- off_t r0 = _srs_lseek_fn(fd, (off_t)size, SEEK_CUR);
+ off_t r0 = _srs_lseek_fn(fd_, (off_t)size, SEEK_CUR);
srs_assert(r0 != -1);
}
int64_t SrsFileReader::seek2(int64_t offset)
{
- return (int64_t)_srs_lseek_fn(fd, (off_t)offset, SEEK_SET);
+ return (int64_t)_srs_lseek_fn(fd_, (off_t)offset, SEEK_SET);
}
int64_t SrsFileReader::filesize()
{
int64_t cur = tellg();
- int64_t size = (int64_t)_srs_lseek_fn(fd, 0, SEEK_END);
+ int64_t size = (int64_t)_srs_lseek_fn(fd_, 0, SEEK_END);
- off_t r0 = _srs_lseek_fn(fd, (off_t)cur, SEEK_SET);
+ off_t r0 = _srs_lseek_fn(fd_, (off_t)cur, SEEK_SET);
srs_assert(r0 != -1);
return size;
@@ -280,8 +280,8 @@ srs_error_t SrsFileReader::read(void *buf, size_t count, ssize_t *pnread)
ssize_t nread;
// TODO: FIXME: use st_read.
- if ((nread = _srs_read_fn(fd, buf, count)) < 0) {
- return srs_error_new(ERROR_SYSTEM_FILE_READ, "read from file %s failed", path.c_str());
+ if ((nread = _srs_read_fn(fd_, buf, count)) < 0) {
+ return srs_error_new(ERROR_SYSTEM_FILE_READ, "read from file %s failed", path_.c_str());
}
if (nread == 0) {
@@ -297,7 +297,7 @@ srs_error_t SrsFileReader::read(void *buf, size_t count, ssize_t *pnread)
srs_error_t SrsFileReader::lseek(off_t offset, int whence, off_t *seeked)
{
- off_t sk = _srs_lseek_fn(fd, offset, whence);
+ off_t sk = _srs_lseek_fn(fd_, offset, whence);
if (sk < 0) {
return srs_error_new(ERROR_SYSTEM_FILE_SEEK, "seek %d failed", (int)sk);
}
diff --git a/trunk/src/kernel/srs_kernel_file.hpp b/trunk/src/kernel/srs_kernel_file.hpp
index 83b26a6cc..c5bcef9c7 100644
--- a/trunk/src/kernel/srs_kernel_file.hpp
+++ b/trunk/src/kernel/srs_kernel_file.hpp
@@ -83,8 +83,8 @@ public:
class SrsFileReader : public ISrsReadSeeker
{
private:
- std::string path;
- int fd;
+ std::string path_;
+ int fd_;
public:
SrsFileReader();
diff --git a/trunk/src/kernel/srs_kernel_flv.cpp b/trunk/src/kernel/srs_kernel_flv.cpp
index 0b672922e..3472056e0 100644
--- a/trunk/src/kernel/srs_kernel_flv.cpp
+++ b/trunk/src/kernel/srs_kernel_flv.cpp
@@ -45,19 +45,19 @@ int srs_rtmp_prefer_cid(SrsFrameType message_type)
int srs_rtmp_write_chunk_header(SrsMediaPacket *msg, char *cache, int nb_cache, bool c0)
{
int payload_length = msg->payload_.get() ? msg->payload_->size() : 0;
- int chunk_id = srs_rtmp_prefer_cid(msg->message_type);
+ int chunk_id = srs_rtmp_prefer_cid(msg->message_type_);
if (c0) {
return srs_chunk_header_c0(chunk_id,
- (uint32_t)msg->timestamp,
+ (uint32_t)msg->timestamp_,
payload_length,
- msg->message_type,
- msg->stream_id,
+ msg->message_type_,
+ msg->stream_id_,
cache,
nb_cache);
} else {
return srs_chunk_header_c3(chunk_id,
- (uint32_t)msg->timestamp,
+ (uint32_t)msg->timestamp_,
cache,
nb_cache);
}
@@ -188,12 +188,12 @@ int srs_chunk_header_c3(int prefer_cid, uint32_t timestamp, char *cache, int nb_
SrsMessageHeader::SrsMessageHeader()
{
- message_type = 0;
- payload_length = 0;
- timestamp_delta = 0;
- stream_id = 0;
+ message_type_ = 0;
+ payload_length_ = 0;
+ timestamp_delta_ = 0;
+ stream_id_ = 0;
- timestamp = 0;
+ timestamp_ = 0;
}
SrsMessageHeader::~SrsMessageHeader()
@@ -202,89 +202,89 @@ SrsMessageHeader::~SrsMessageHeader()
bool SrsMessageHeader::is_audio()
{
- return message_type == RTMP_MSG_AudioMessage;
+ return message_type_ == RTMP_MSG_AudioMessage;
}
bool SrsMessageHeader::is_video()
{
- return message_type == RTMP_MSG_VideoMessage;
+ return message_type_ == RTMP_MSG_VideoMessage;
}
bool SrsMessageHeader::is_amf0_command()
{
- return message_type == RTMP_MSG_AMF0CommandMessage;
+ return message_type_ == RTMP_MSG_AMF0CommandMessage;
}
bool SrsMessageHeader::is_amf0_data()
{
- return message_type == RTMP_MSG_AMF0DataMessage;
+ return message_type_ == RTMP_MSG_AMF0DataMessage;
}
bool SrsMessageHeader::is_amf3_command()
{
- return message_type == RTMP_MSG_AMF3CommandMessage;
+ return message_type_ == RTMP_MSG_AMF3CommandMessage;
}
bool SrsMessageHeader::is_amf3_data()
{
- return message_type == RTMP_MSG_AMF3DataMessage;
+ return message_type_ == RTMP_MSG_AMF3DataMessage;
}
bool SrsMessageHeader::is_window_ackledgement_size()
{
- return message_type == RTMP_MSG_WindowAcknowledgementSize;
+ return message_type_ == RTMP_MSG_WindowAcknowledgementSize;
}
bool SrsMessageHeader::is_ackledgement()
{
- return message_type == RTMP_MSG_Acknowledgement;
+ return message_type_ == RTMP_MSG_Acknowledgement;
}
bool SrsMessageHeader::is_set_chunk_size()
{
- return message_type == RTMP_MSG_SetChunkSize;
+ return message_type_ == RTMP_MSG_SetChunkSize;
}
bool SrsMessageHeader::is_user_control_message()
{
- return message_type == RTMP_MSG_UserControlMessage;
+ return message_type_ == RTMP_MSG_UserControlMessage;
}
bool SrsMessageHeader::is_set_peer_bandwidth()
{
- return message_type == RTMP_MSG_SetPeerBandwidth;
+ return message_type_ == RTMP_MSG_SetPeerBandwidth;
}
bool SrsMessageHeader::is_aggregate()
{
- return message_type == RTMP_MSG_AggregateMessage;
+ return message_type_ == RTMP_MSG_AggregateMessage;
}
void SrsMessageHeader::initialize_amf0_script(int size, int stream)
{
- message_type = RTMP_MSG_AMF0DataMessage;
- payload_length = (int32_t)size;
- timestamp_delta = (int32_t)0;
- timestamp = (int64_t)0;
- stream_id = (int32_t)stream;
+ message_type_ = RTMP_MSG_AMF0DataMessage;
+ payload_length_ = (int32_t)size;
+ timestamp_delta_ = (int32_t)0;
+ timestamp_ = (int64_t)0;
+ stream_id_ = (int32_t)stream;
}
void SrsMessageHeader::initialize_audio(int size, uint32_t time, int stream)
{
- message_type = RTMP_MSG_AudioMessage;
- payload_length = (int32_t)size;
- timestamp_delta = (int32_t)time;
- timestamp = (int64_t)time;
- stream_id = (int32_t)stream;
+ message_type_ = RTMP_MSG_AudioMessage;
+ payload_length_ = (int32_t)size;
+ timestamp_delta_ = (int32_t)time;
+ timestamp_ = (int64_t)time;
+ stream_id_ = (int32_t)stream;
}
void SrsMessageHeader::initialize_video(int size, uint32_t time, int stream)
{
- message_type = RTMP_MSG_VideoMessage;
- payload_length = (int32_t)size;
- timestamp_delta = (int32_t)time;
- timestamp = (int64_t)time;
- stream_id = (int32_t)stream;
+ message_type_ = RTMP_MSG_VideoMessage;
+ payload_length_ = (int32_t)size;
+ timestamp_delta_ = (int32_t)time;
+ timestamp_ = (int64_t)time;
+ stream_id_ = (int32_t)stream;
}
SrsRtmpCommonMessage::SrsRtmpCommonMessage()
@@ -317,7 +317,7 @@ srs_error_t SrsRtmpCommonMessage::create(SrsMessageHeader *pheader, char *body,
payload_->attach(body, size);
if (pheader) {
- this->header = *pheader;
+ this->header_ = *pheader;
}
return err;
@@ -326,37 +326,37 @@ srs_error_t SrsRtmpCommonMessage::create(SrsMessageHeader *pheader, char *body,
void SrsRtmpCommonMessage::to_msg(SrsMediaPacket *msg)
{
msg->payload_ = payload_;
- msg->timestamp = header.timestamp;
- msg->stream_id = header.stream_id;
- msg->message_type = (SrsFrameType)header.message_type;
+ msg->timestamp_ = header_.timestamp_;
+ msg->stream_id_ = header_.stream_id_;
+ msg->message_type_ = (SrsFrameType)header_.message_type_;
}
SrsFlvTransmuxer::SrsFlvTransmuxer()
{
- writer = NULL;
+ writer_ = NULL;
drop_if_not_match_ = true;
has_audio_ = true;
has_video_ = true;
- nb_tag_headers = 0;
- tag_headers = NULL;
- nb_iovss_cache = 0;
- iovss_cache = NULL;
- nb_ppts = 0;
- ppts = NULL;
+ nb_tag_headers_ = 0;
+ tag_headers_ = NULL;
+ nb_iovss_cache_ = 0;
+ iovss_cache_ = NULL;
+ nb_ppts_ = 0;
+ ppts_ = NULL;
}
SrsFlvTransmuxer::~SrsFlvTransmuxer()
{
- srs_freepa(tag_headers);
- srs_freepa(iovss_cache);
- srs_freepa(ppts);
+ srs_freepa(tag_headers_);
+ srs_freepa(iovss_cache_);
+ srs_freepa(ppts_);
}
srs_error_t SrsFlvTransmuxer::initialize(ISrsWriter *fw)
{
srs_assert(fw);
- writer = fw;
+ writer_ = fw;
return srs_success;
}
@@ -406,13 +406,13 @@ srs_error_t SrsFlvTransmuxer::write_header(char flv_header[9])
srs_error_t err = srs_success;
// write data.
- if ((err = writer->write(flv_header, 9, NULL)) != srs_success) {
+ if ((err = writer_->write(flv_header, 9, NULL)) != srs_success) {
return srs_error_wrap(err, "write flv header failed");
}
// previous tag size.
char pts[] = {(char)0x00, (char)0x00, (char)0x00, (char)0x00};
- if ((err = writer->write(pts, 4, NULL)) != srs_success) {
+ if ((err = writer_->write(pts, 4, NULL)) != srs_success) {
return srs_error_wrap(err, "write pts");
}
@@ -424,10 +424,10 @@ srs_error_t SrsFlvTransmuxer::write_metadata(char type, char *data, int size)
srs_error_t err = srs_success;
if (size > 0) {
- cache_metadata(type, data, size, tag_header);
+ cache_metadata(type, data, size, tag_header_);
}
- if ((err = write_tag(tag_header, sizeof(tag_header), data, size)) != srs_success) {
+ if ((err = write_tag(tag_header_, sizeof(tag_header_), data, size)) != srs_success) {
return srs_error_wrap(err, "write tag");
}
@@ -442,10 +442,10 @@ srs_error_t SrsFlvTransmuxer::write_audio(int64_t timestamp, char *data, int siz
return err;
if (size > 0) {
- cache_audio(timestamp, data, size, tag_header);
+ cache_audio(timestamp, data, size, tag_header_);
}
- if ((err = write_tag(tag_header, sizeof(tag_header), data, size)) != srs_success) {
+ if ((err = write_tag(tag_header_, sizeof(tag_header_), data, size)) != srs_success) {
return srs_error_wrap(err, "write tag");
}
@@ -460,10 +460,10 @@ srs_error_t SrsFlvTransmuxer::write_video(int64_t timestamp, char *data, int siz
return err;
if (size > 0) {
- cache_video(timestamp, data, size, tag_header);
+ cache_video(timestamp, data, size, tag_header_);
}
- if ((err = write_tag(tag_header, sizeof(tag_header), data, size)) != srs_success) {
+ if ((err = write_tag(tag_header_, sizeof(tag_header_), data, size)) != srs_success) {
return srs_error_wrap(err, "write flv video tag failed");
}
@@ -481,33 +481,33 @@ srs_error_t SrsFlvTransmuxer::write_tags(SrsMediaPacket **msgs, int count)
srs_error_t err = srs_success;
// Do realloc the iovss if required.
- iovec *iovss = iovss_cache;
+ iovec *iovss = iovss_cache_;
do {
int nn_might_iovss = 3 * count;
- if (nb_iovss_cache < nn_might_iovss) {
- srs_freepa(iovss_cache);
+ if (nb_iovss_cache_ < nn_might_iovss) {
+ srs_freepa(iovss_cache_);
- nb_iovss_cache = nn_might_iovss;
- iovss = iovss_cache = new iovec[nn_might_iovss];
+ nb_iovss_cache_ = nn_might_iovss;
+ iovss = iovss_cache_ = new iovec[nn_might_iovss];
}
} while (false);
// Do realloc the tag headers if required.
- char *cache = tag_headers;
- if (nb_tag_headers < count) {
- srs_freepa(tag_headers);
+ char *cache = tag_headers_;
+ if (nb_tag_headers_ < count) {
+ srs_freepa(tag_headers_);
- nb_tag_headers = count;
- cache = tag_headers = new char[SRS_FLV_TAG_HEADER_SIZE * count];
+ nb_tag_headers_ = count;
+ cache = tag_headers_ = new char[SRS_FLV_TAG_HEADER_SIZE * count];
}
// Do realloc the pts if required.
- char *pts = ppts;
- if (nb_ppts < count) {
- srs_freepa(ppts);
+ char *pts = ppts_;
+ if (nb_ppts_ < count) {
+ srs_freepa(ppts_);
- nb_ppts = count;
- pts = ppts = new char[SRS_FLV_PREVIOUS_TAG_SIZE * count];
+ nb_ppts_ = count;
+ pts = ppts_ = new char[SRS_FLV_PREVIOUS_TAG_SIZE * count];
}
// Now all caches are ok, start to write all messages.
@@ -520,11 +520,11 @@ srs_error_t SrsFlvTransmuxer::write_tags(SrsMediaPacket **msgs, int count)
if (msg->is_audio()) {
if (drop_if_not_match_ && !has_audio_)
continue; // Ignore audio packets if no audio stream.
- cache_audio(msg->timestamp, msg->payload(), msg->size(), cache);
+ cache_audio(msg->timestamp_, msg->payload(), msg->size(), cache);
} else if (msg->is_video()) {
if (drop_if_not_match_ && !has_video_)
continue; // Ignore video packets if no video stream.
- cache_video(msg->timestamp, msg->payload(), msg->size(), cache);
+ cache_video(msg->timestamp_, msg->payload(), msg->size(), cache);
} else {
cache_metadata(SrsFrameTypeScript, msg->payload(), msg->size(), cache);
}
@@ -548,7 +548,7 @@ srs_error_t SrsFlvTransmuxer::write_tags(SrsMediaPacket **msgs, int count)
}
// Send out all data carried by iovec.
- if ((err = writer->writev(iovss, nn_real_iovss, NULL)) != srs_success) {
+ if ((err = writer_->writev(iovss, nn_real_iovss, NULL)) != srs_success) {
return srs_error_wrap(err, "write flv tags failed");
}
@@ -652,7 +652,7 @@ srs_error_t SrsFlvTransmuxer::write_tag(char *header, int header_size, char *tag
iovs[2].iov_base = pre_size;
iovs[2].iov_len = SRS_FLV_PREVIOUS_TAG_SIZE;
- if ((err = writer->writev(iovs, 3, NULL)) != srs_success) {
+ if ((err = writer_->writev(iovs, 3, NULL)) != srs_success) {
return srs_error_wrap(err, "write flv tag failed");
}
@@ -661,7 +661,7 @@ srs_error_t SrsFlvTransmuxer::write_tag(char *header, int header_size, char *tag
SrsFlvDecoder::SrsFlvDecoder()
{
- reader = NULL;
+ reader_ = NULL;
}
SrsFlvDecoder::~SrsFlvDecoder()
@@ -671,7 +671,7 @@ SrsFlvDecoder::~SrsFlvDecoder()
srs_error_t SrsFlvDecoder::initialize(ISrsReader *fr)
{
srs_assert(fr);
- reader = fr;
+ reader_ = fr;
return srs_success;
}
@@ -682,7 +682,7 @@ srs_error_t SrsFlvDecoder::read_header(char header[9])
srs_assert(header);
// TODO: FIXME: Should use readfully.
- if ((err = reader->read(header, 9, NULL)) != srs_success) {
+ if ((err = reader_->read(header, 9, NULL)) != srs_success) {
return srs_error_wrap(err, "read header");
}
@@ -706,7 +706,7 @@ srs_error_t SrsFlvDecoder::read_tag_header(char *ptype, int32_t *pdata_size, uin
// read tag header
// TODO: FIXME: Should use readfully.
- if ((err = reader->read(th, 11, NULL)) != srs_success) {
+ if ((err = reader_->read(th, 11, NULL)) != srs_success) {
return srs_error_wrap(err, "read flv tag header failed");
}
@@ -741,7 +741,7 @@ srs_error_t SrsFlvDecoder::read_tag_data(char *data, int32_t size)
srs_assert(data);
// TODO: FIXME: Should use readfully.
- if ((err = reader->read(data, size, NULL)) != srs_success) {
+ if ((err = reader_->read(data, size, NULL)) != srs_success) {
return srs_error_wrap(err, "read flv tag header failed");
}
@@ -756,7 +756,7 @@ srs_error_t SrsFlvDecoder::read_previous_tag_size(char previous_tag_size[4])
// ignore 4bytes tag size.
// TODO: FIXME: Should use readfully.
- if ((err = reader->read(previous_tag_size, 4, NULL)) != srs_success) {
+ if ((err = reader_->read(previous_tag_size, 4, NULL)) != srs_success) {
return srs_error_wrap(err, "read flv previous tag size failed");
}
@@ -765,7 +765,7 @@ srs_error_t SrsFlvDecoder::read_previous_tag_size(char previous_tag_size[4])
SrsFlvVodStreamDecoder::SrsFlvVodStreamDecoder()
{
- reader = NULL;
+ reader_ = NULL;
}
SrsFlvVodStreamDecoder::~SrsFlvVodStreamDecoder()
@@ -777,12 +777,12 @@ srs_error_t SrsFlvVodStreamDecoder::initialize(ISrsReader *fr)
srs_error_t err = srs_success;
srs_assert(fr);
- reader = dynamic_cast(fr);
- if (!reader) {
+ reader_ = dynamic_cast(fr);
+ if (!reader_) {
return srs_error_new(ERROR_EXPECT_FILE_IO, "stream is not file io");
}
- if (!reader->is_open()) {
+ if (!reader_->is_open()) {
return srs_error_new(ERROR_KERNEL_FLV_STREAM_CLOSED, "stream is not open for decoder");
}
@@ -801,7 +801,7 @@ srs_error_t SrsFlvVodStreamDecoder::read_header_ext(char header[13])
// 9bytes header and 4bytes first previous-tag-size
int size = 13;
- if ((err = reader->read(header, size, NULL)) != srs_success) {
+ if ((err = reader_->read(header, size, NULL)) != srs_success) {
return srs_error_wrap(err, "read header");
}
@@ -835,7 +835,7 @@ srs_error_t SrsFlvVodStreamDecoder::read_sequence_header_summary(int64_t *pstart
int64_t av_sequence_offset_start = -1;
int64_t av_sequence_offset_end = -1;
for (;;) {
- if ((err = reader->read(tag_header, SRS_FLV_TAG_HEADER_SIZE, NULL)) != srs_success) {
+ if ((err = reader_->read(tag_header, SRS_FLV_TAG_HEADER_SIZE, NULL)) != srs_success) {
return srs_error_wrap(err, "read tag header");
}
@@ -849,7 +849,7 @@ srs_error_t SrsFlvVodStreamDecoder::read_sequence_header_summary(int64_t *pstart
bool is_not_av = !is_video && !is_audio;
if (is_not_av) {
// skip body and tag size.
- reader->skip(data_size + SRS_FLV_PREVIOUS_TAG_SIZE);
+ reader_->skip(data_size + SRS_FLV_PREVIOUS_TAG_SIZE);
continue;
}
@@ -868,10 +868,10 @@ srs_error_t SrsFlvVodStreamDecoder::read_sequence_header_summary(int64_t *pstart
got_video = true;
if (av_sequence_offset_start < 0) {
- av_sequence_offset_start = reader->tellg() - SRS_FLV_TAG_HEADER_SIZE;
+ av_sequence_offset_start = reader_->tellg() - SRS_FLV_TAG_HEADER_SIZE;
}
- av_sequence_offset_end = reader->tellg() + data_size + SRS_FLV_PREVIOUS_TAG_SIZE;
- reader->skip(data_size + SRS_FLV_PREVIOUS_TAG_SIZE);
+ av_sequence_offset_end = reader_->tellg() + data_size + SRS_FLV_PREVIOUS_TAG_SIZE;
+ reader_->skip(data_size + SRS_FLV_PREVIOUS_TAG_SIZE);
}
// audio
@@ -880,10 +880,10 @@ srs_error_t SrsFlvVodStreamDecoder::read_sequence_header_summary(int64_t *pstart
got_audio = true;
if (av_sequence_offset_start < 0) {
- av_sequence_offset_start = reader->tellg() - SRS_FLV_TAG_HEADER_SIZE;
+ av_sequence_offset_start = reader_->tellg() - SRS_FLV_TAG_HEADER_SIZE;
}
- av_sequence_offset_end = reader->tellg() + data_size + SRS_FLV_PREVIOUS_TAG_SIZE;
- reader->skip(data_size + SRS_FLV_PREVIOUS_TAG_SIZE);
+ av_sequence_offset_end = reader_->tellg() + data_size + SRS_FLV_PREVIOUS_TAG_SIZE;
+ reader_->skip(data_size + SRS_FLV_PREVIOUS_TAG_SIZE);
}
if (got_audio && got_video) {
@@ -893,7 +893,7 @@ srs_error_t SrsFlvVodStreamDecoder::read_sequence_header_summary(int64_t *pstart
// seek to the sequence header start offset.
if (av_sequence_offset_start > 0) {
- reader->seek2(av_sequence_offset_start);
+ reader_->seek2(av_sequence_offset_start);
*pstart = av_sequence_offset_start;
*psize = (int)(av_sequence_offset_end - av_sequence_offset_start);
}
@@ -905,12 +905,12 @@ srs_error_t SrsFlvVodStreamDecoder::seek2(int64_t offset)
{
srs_error_t err = srs_success;
- if (offset >= reader->filesize()) {
- return srs_error_new(ERROR_SYSTEM_FILE_EOF, "flv fast decoder seek overflow file, size=%d, offset=%d", (int)reader->filesize(), (int)offset);
+ if (offset >= reader_->filesize()) {
+ return srs_error_new(ERROR_SYSTEM_FILE_EOF, "flv fast decoder seek overflow file, size=%d, offset=%d", (int)reader_->filesize(), (int)offset);
}
- if (reader->seek2(offset) < 0) {
- return srs_error_new(ERROR_SYSTEM_FILE_SEEK, "flv fast decoder seek error, size=%d, offset=%d", (int)reader->filesize(), (int)offset);
+ if (reader_->seek2(offset) < 0) {
+ return srs_error_new(ERROR_SYSTEM_FILE_SEEK, "flv fast decoder seek error, size=%d, offset=%d", (int)reader_->filesize(), (int)offset);
}
return err;
diff --git a/trunk/src/kernel/srs_kernel_flv.hpp b/trunk/src/kernel/srs_kernel_flv.hpp
index b3d045a60..03537a8be 100644
--- a/trunk/src/kernel/srs_kernel_flv.hpp
+++ b/trunk/src/kernel/srs_kernel_flv.hpp
@@ -137,26 +137,26 @@ public:
// 3bytes.
// Three-byte field that contains a timestamp delta of the message.
// @remark, only used for decoding message from chunk stream.
- int32_t timestamp_delta;
+ int32_t timestamp_delta_;
// 3bytes.
// Three-byte field that represents the size of the payload in bytes.
// It is set in big-endian format.
- int32_t payload_length;
+ int32_t payload_length_;
// 1byte.
// One byte field to represent the message type. A range of type IDs
// (1-7) are reserved for protocol control messages.
// For example, RTMP_MSG_AudioMessage or RTMP_MSG_VideoMessage.
- int8_t message_type;
+ int8_t message_type_;
// 4bytes.
// Four-byte field that identifies the stream of the message. These
// bytes are set in little-endian format.
- int32_t stream_id;
+ int32_t stream_id_;
// Four-byte field that contains a timestamp of the message.
// The 4 bytes are packed in the big-endian order.
// @remark, used as calc timestamp when decode and encode time.
// @remark, we use 64bits for large time for jitter detect and hls.
- int64_t timestamp;
+ int64_t timestamp_;
public:
SrsMessageHeader();
@@ -193,7 +193,7 @@ class SrsRtmpCommonMessage
{
public:
// 4.1. Message Header
- SrsMessageHeader header;
+ SrsMessageHeader header_;
public:
// 4.2. Message Payload
@@ -230,10 +230,10 @@ private:
bool has_audio_;
bool has_video_;
bool drop_if_not_match_;
- ISrsWriter *writer;
+ ISrsWriter *writer_;
private:
- char tag_header[SRS_FLV_TAG_HEADER_SIZE];
+ char tag_header_[SRS_FLV_TAG_HEADER_SIZE];
public:
SrsFlvTransmuxer();
@@ -277,14 +277,14 @@ public:
private:
// The cache tag header.
- int nb_tag_headers;
- char *tag_headers;
+ int nb_tag_headers_;
+ char *tag_headers_;
// The cache pps(previous tag size)
- int nb_ppts;
- char *ppts;
+ int nb_ppts_;
+ char *ppts_;
// The cache iovss.
- int nb_iovss_cache;
- iovec *iovss_cache;
+ int nb_iovss_cache_;
+ iovec *iovss_cache_;
public:
// Write the tags in a time.
@@ -302,7 +302,7 @@ private:
class SrsFlvDecoder
{
private:
- ISrsReader *reader;
+ ISrsReader *reader_;
public:
SrsFlvDecoder();
@@ -335,7 +335,7 @@ public:
class SrsFlvVodStreamDecoder
{
private:
- SrsFileReader *reader;
+ SrsFileReader *reader_;
public:
SrsFlvVodStreamDecoder();
diff --git a/trunk/src/kernel/srs_kernel_kbps.cpp b/trunk/src/kernel/srs_kernel_kbps.cpp
index cc2f60fc1..26b414e56 100644
--- a/trunk/src/kernel/srs_kernel_kbps.cpp
+++ b/trunk/src/kernel/srs_kernel_kbps.cpp
@@ -15,8 +15,8 @@ using namespace std;
SrsRateSample::SrsRateSample()
{
- total = time = -1;
- rate = 0;
+ total_ = time_ = -1;
+ rate_ = 0;
}
SrsRateSample::~SrsRateSample()
@@ -25,23 +25,23 @@ SrsRateSample::~SrsRateSample()
SrsRateSample *SrsRateSample::update(int64_t nn, srs_utime_t t, int k)
{
- total = nn;
- time = t;
- rate = k;
+ total_ = nn;
+ time_ = t;
+ rate_ = k;
return this;
}
void srs_pps_init(SrsRateSample &sample, int64_t nn, srs_utime_t now)
{
- if (sample.time < 0 || nn < sample.total) {
+ if (sample.time_ < 0 || nn < sample.total_) {
sample.update(nn, now, 0);
}
}
void srs_pps_update(SrsRateSample &sample, int64_t nn, srs_utime_t now)
{
- int pps = (int)((nn - sample.total) * 1000 / srsu2ms(now - sample.time));
- if (pps == 0 && nn > sample.total) {
+ int pps = (int)((nn - sample.total_) * 1000 / srsu2ms(now - sample.time_));
+ if (pps == 0 && nn > sample.total_) {
pps = 1; // For pps in (0, 1), we set to 1.
}
sample.update(nn, now, pps);
@@ -50,7 +50,7 @@ void srs_pps_update(SrsRateSample &sample, int64_t nn, srs_utime_t now)
SrsPps::SrsPps()
{
clk_ = _srs_clock;
- sugar = 0;
+ sugar_ = 0;
}
SrsPps::~SrsPps()
@@ -59,7 +59,7 @@ SrsPps::~SrsPps()
void SrsPps::update()
{
- update(sugar);
+ update(sugar_);
}
void SrsPps::update(int64_t nn)
@@ -74,31 +74,31 @@ void SrsPps::update(int64_t nn)
srs_pps_init(sample_5m_, nn, now);
srs_pps_init(sample_60m_, nn, now);
- if (now - sample_10s_.time >= 10 * SRS_UTIME_SECONDS) {
+ if (now - sample_10s_.time_ >= 10 * SRS_UTIME_SECONDS) {
srs_pps_update(sample_10s_, nn, now);
}
- if (now - sample_30s_.time >= 30 * SRS_UTIME_SECONDS) {
+ if (now - sample_30s_.time_ >= 30 * SRS_UTIME_SECONDS) {
srs_pps_update(sample_30s_, nn, now);
}
- if (now - sample_1m_.time >= 60 * SRS_UTIME_SECONDS) {
+ if (now - sample_1m_.time_ >= 60 * SRS_UTIME_SECONDS) {
srs_pps_update(sample_1m_, nn, now);
}
- if (now - sample_5m_.time >= 300 * SRS_UTIME_SECONDS) {
+ if (now - sample_5m_.time_ >= 300 * SRS_UTIME_SECONDS) {
srs_pps_update(sample_5m_, nn, now);
}
- if (now - sample_60m_.time >= 3600 * SRS_UTIME_SECONDS) {
+ if (now - sample_60m_.time_ >= 3600 * SRS_UTIME_SECONDS) {
srs_pps_update(sample_60m_, nn, now);
}
}
int SrsPps::r10s()
{
- return sample_10s_.rate;
+ return sample_10s_.rate_;
}
int SrsPps::r30s()
{
- return sample_30s_.rate;
+ return sample_30s_.rate_;
}
SrsWallClock::SrsWallClock()
@@ -344,14 +344,14 @@ void srs_global_kbps_update(SrsKbpsStats *stats)
{
static char buf[128];
- string &cid_desc = stats->cid_desc;
+ string &cid_desc = stats->cid_desc_;
_srs_pps_cids_get->update();
_srs_pps_cids_set->update();
if (_srs_pps_cids_get->r10s() || _srs_pps_cids_set->r10s()) {
snprintf(buf, sizeof(buf), ", cid=%d,%d", _srs_pps_cids_get->r10s(), _srs_pps_cids_set->r10s());
cid_desc = buf;
}
- string &timer_desc = stats->timer_desc;
+ string &timer_desc = stats->timer_desc_;
_srs_pps_timer->update();
_srs_pps_pub->update();
_srs_pps_conn->update();
@@ -360,14 +360,14 @@ void srs_global_kbps_update(SrsKbpsStats *stats)
timer_desc = buf;
}
- string &free_desc = stats->free_desc;
+ string &free_desc = stats->free_desc_;
_srs_pps_dispose->update();
if (_srs_pps_dispose->r10s()) {
snprintf(buf, sizeof(buf), ", free=%d", _srs_pps_dispose->r10s());
free_desc = buf;
}
- string &recvfrom_desc = stats->recvfrom_desc;
+ string &recvfrom_desc = stats->recvfrom_desc_;
(void)recvfrom_desc;
#if defined(SRS_DEBUG) && defined(SRS_DEBUG_STATS)
_srs_pps_recvfrom->update(_st_stat_recvfrom);
@@ -380,7 +380,7 @@ void srs_global_kbps_update(SrsKbpsStats *stats)
}
#endif
- string &io_desc = stats->io_desc;
+ string &io_desc = stats->io_desc_;
(void)io_desc;
#if defined(SRS_DEBUG) && defined(SRS_DEBUG_STATS)
_srs_pps_read->update(_st_stat_read);
@@ -395,7 +395,7 @@ void srs_global_kbps_update(SrsKbpsStats *stats)
}
#endif
- string &msg_desc = stats->msg_desc;
+ string &msg_desc = stats->msg_desc_;
(void)msg_desc;
#if defined(SRS_DEBUG) && defined(SRS_DEBUG_STATS)
_srs_pps_recvmsg->update(_st_stat_recvmsg);
@@ -408,7 +408,7 @@ void srs_global_kbps_update(SrsKbpsStats *stats)
}
#endif
- string &epoll_desc = stats->epoll_desc;
+ string &epoll_desc = stats->epoll_desc_;
(void)epoll_desc;
#if defined(SRS_DEBUG) && defined(SRS_DEBUG_STATS)
_srs_pps_epoll->update(_st_stat_epoll);
@@ -421,7 +421,7 @@ void srs_global_kbps_update(SrsKbpsStats *stats)
}
#endif
- string &sched_desc = stats->sched_desc;
+ string &sched_desc = stats->sched_desc_;
(void)sched_desc;
#if defined(SRS_DEBUG) && defined(SRS_DEBUG_STATS)
_srs_pps_sched_160ms->update(_st_stat_sched_160ms);
@@ -439,7 +439,7 @@ void srs_global_kbps_update(SrsKbpsStats *stats)
}
#endif
- string &clock_desc = stats->clock_desc;
+ string &clock_desc = stats->clock_desc_;
_srs_pps_clock_15ms->update();
_srs_pps_clock_20ms->update();
_srs_pps_clock_25ms->update();
@@ -454,7 +454,7 @@ void srs_global_kbps_update(SrsKbpsStats *stats)
clock_desc = buf;
}
- string &thread_desc = stats->thread_desc;
+ string &thread_desc = stats->thread_desc_;
(void)thread_desc;
#if defined(SRS_DEBUG) && defined(SRS_DEBUG_STATS)
_srs_pps_thread_run->update(_st_stat_thread_run);
@@ -467,7 +467,7 @@ void srs_global_kbps_update(SrsKbpsStats *stats)
}
#endif
- string &objs_desc = stats->objs_desc;
+ string &objs_desc = stats->objs_desc_;
_srs_pps_objs_rtps->update();
_srs_pps_objs_rraw->update();
_srs_pps_objs_rfua->update();
@@ -486,7 +486,7 @@ void srs_global_rtc_update(SrsKbsRtcStats *stats)
{
static char buf[128];
- string &rpkts_desc = stats->rpkts_desc;
+ string &rpkts_desc = stats->rpkts_desc_;
_srs_pps_rpkts->update();
_srs_pps_rrtps->update();
_srs_pps_rstuns->update();
@@ -496,7 +496,7 @@ void srs_global_rtc_update(SrsKbsRtcStats *stats)
rpkts_desc = buf;
}
- string &spkts_desc = stats->spkts_desc;
+ string &spkts_desc = stats->spkts_desc_;
_srs_pps_spkts->update();
_srs_pps_srtps->update();
_srs_pps_sstuns->update();
@@ -506,7 +506,7 @@ void srs_global_rtc_update(SrsKbsRtcStats *stats)
spkts_desc = buf;
}
- string &rtcp_desc = stats->rtcp_desc;
+ string &rtcp_desc = stats->rtcp_desc_;
_srs_pps_pli->update();
_srs_pps_twcc->update();
_srs_pps_rr->update();
@@ -515,7 +515,7 @@ void srs_global_rtc_update(SrsKbsRtcStats *stats)
rtcp_desc = buf;
}
- string &snk_desc = stats->snk_desc;
+ string &snk_desc = stats->snk_desc_;
_srs_pps_snack->update();
_srs_pps_snack2->update();
_srs_pps_sanack->update();
@@ -525,7 +525,7 @@ void srs_global_rtc_update(SrsKbsRtcStats *stats)
snk_desc = buf;
}
- string &rnk_desc = stats->rnk_desc;
+ string &rnk_desc = stats->rnk_desc_;
_srs_pps_rnack->update();
_srs_pps_rnack2->update();
_srs_pps_rhnack->update();
@@ -535,7 +535,7 @@ void srs_global_rtc_update(SrsKbsRtcStats *stats)
rnk_desc = buf;
}
- string &fid_desc = stats->fid_desc;
+ string &fid_desc = stats->fid_desc_;
_srs_pps_ids->update();
_srs_pps_fids->update();
_srs_pps_fids_level0->update();
diff --git a/trunk/src/kernel/srs_kernel_kbps.hpp b/trunk/src/kernel/srs_kernel_kbps.hpp
index e77d00d15..32f86105d 100644
--- a/trunk/src/kernel/srs_kernel_kbps.hpp
+++ b/trunk/src/kernel/srs_kernel_kbps.hpp
@@ -19,10 +19,10 @@ class SrsWallClock;
class SrsRateSample
{
public:
- int64_t total;
- srs_utime_t time;
+ int64_t total_;
+ srs_utime_t time_;
// kbps or kps
- int rate;
+ int rate_;
public:
SrsRateSample();
@@ -48,7 +48,7 @@ private:
public:
// Sugar for target to stat.
- int64_t sugar;
+ int64_t sugar_;
public:
SrsPps();
@@ -200,17 +200,17 @@ srs_error_t srs_global_kbps_initialize();
class SrsKbpsStats
{
public:
- std::string cid_desc;
- std::string timer_desc;
- std::string free_desc;
- std::string recvfrom_desc;
- std::string io_desc;
- std::string msg_desc;
- std::string epoll_desc;
- std::string sched_desc;
- std::string clock_desc;
- std::string thread_desc;
- std::string objs_desc;
+ std::string cid_desc_;
+ std::string timer_desc_;
+ std::string free_desc_;
+ std::string recvfrom_desc_;
+ std::string io_desc_;
+ std::string msg_desc_;
+ std::string epoll_desc_;
+ std::string sched_desc_;
+ std::string clock_desc_;
+ std::string thread_desc_;
+ std::string objs_desc_;
};
// Update the global kbps statistics variables
@@ -219,12 +219,12 @@ void srs_global_kbps_update(SrsKbpsStats *stats);
class SrsKbsRtcStats
{
public:
- std::string rpkts_desc;
- std::string spkts_desc;
- std::string rtcp_desc;
- std::string snk_desc;
- std::string rnk_desc;
- std::string fid_desc;
+ std::string rpkts_desc_;
+ std::string spkts_desc_;
+ std::string rtcp_desc_;
+ std::string snk_desc_;
+ std::string rnk_desc_;
+ std::string fid_desc_;
};
// Update the global rtc statistics variables
diff --git a/trunk/src/kernel/srs_kernel_mp3.cpp b/trunk/src/kernel/srs_kernel_mp3.cpp
index 56f5a04e5..4c607c38a 100644
--- a/trunk/src/kernel/srs_kernel_mp3.cpp
+++ b/trunk/src/kernel/srs_kernel_mp3.cpp
@@ -23,7 +23,7 @@ using namespace std;
SrsMp3Transmuxer::SrsMp3Transmuxer()
{
- writer = NULL;
+ writer_ = NULL;
}
SrsMp3Transmuxer::~SrsMp3Transmuxer()
@@ -40,7 +40,7 @@ srs_error_t SrsMp3Transmuxer::initialize(SrsFileWriter *fw)
return srs_error_new(ERROR_KERNEL_MP3_STREAM_CLOSED, "stream is not open");
}
- writer = fw;
+ writer_ = fw;
return err;
}
@@ -60,7 +60,7 @@ srs_error_t SrsMp3Transmuxer::write_header()
(char)0x00, (char)0x00 // Flags
};
- if ((err = writer->write(id3, sizeof(id3), NULL)) != srs_success) {
+ if ((err = writer_->write(id3, sizeof(id3), NULL)) != srs_success) {
return srs_error_wrap(err, "write id3");
}
@@ -98,7 +98,7 @@ srs_error_t SrsMp3Transmuxer::write_audio(int64_t timestamp, char *data, int siz
return srs_error_new(ERROR_MP3_DECODE_ERROR, "mp3 decode aac_packet_type failed");
}
- if ((err = writer->write(data + stream->pos(), size - stream->pos(), NULL)) != srs_success) {
+ if ((err = writer_->write(data + stream->pos(), size - stream->pos(), NULL)) != srs_success) {
return srs_error_wrap(err, "write audio");
}
diff --git a/trunk/src/kernel/srs_kernel_mp3.hpp b/trunk/src/kernel/srs_kernel_mp3.hpp
index 66010ff8b..d6d2e4882 100644
--- a/trunk/src/kernel/srs_kernel_mp3.hpp
+++ b/trunk/src/kernel/srs_kernel_mp3.hpp
@@ -20,7 +20,7 @@ class SrsFileWriter;
class SrsMp3Transmuxer
{
private:
- SrsFileWriter *writer;
+ SrsFileWriter *writer_;
public:
SrsMp3Transmuxer();
diff --git a/trunk/src/kernel/srs_kernel_mp4.cpp b/trunk/src/kernel/srs_kernel_mp4.cpp
index 62e32e0a4..8f8605980 100644
--- a/trunk/src/kernel/srs_kernel_mp4.cpp
+++ b/trunk/src/kernel/srs_kernel_mp4.cpp
@@ -53,7 +53,7 @@ srs_error_t srs_mp4_write_box(ISrsWriter *writer, ISrsCodec *box)
stringstream &srs_mp4_padding(stringstream &ss, SrsMp4DumpContext dc, int tab)
{
- for (int i = 0; i < (int)dc.level; i++) {
+ for (int i = 0; i < (int)dc.level_; i++) {
for (int j = 0; j < tab; j++) {
ss << " ";
}
@@ -135,8 +135,8 @@ srs_error_t srs_mp4_string_read(SrsBuffer *buf, string &v, int left)
SrsMp4DumpContext::SrsMp4DumpContext()
{
- level = 0;
- summary = false;
+ level_ = 0;
+ summary_ = false;
}
SrsMp4DumpContext::~SrsMp4DumpContext()
@@ -146,31 +146,31 @@ SrsMp4DumpContext::~SrsMp4DumpContext()
SrsMp4DumpContext SrsMp4DumpContext::indent()
{
SrsMp4DumpContext ctx = *this;
- ctx.level++;
+ ctx.level_++;
return ctx;
}
SrsMp4Box::SrsMp4Box()
{
- smallsize = 0;
- largesize = 0;
- start_pos = 0;
- type = SrsMp4BoxTypeForbidden;
+ smallsize_ = 0;
+ largesize_ = 0;
+ start_pos_ = 0;
+ type_ = SrsMp4BoxTypeForbidden;
}
SrsMp4Box::~SrsMp4Box()
{
vector::iterator it;
- for (it = boxes.begin(); it != boxes.end(); ++it) {
+ for (it = boxes_.begin(); it != boxes_.end(); ++it) {
SrsMp4Box *box = *it;
srs_freep(box);
}
- boxes.clear();
+ boxes_.clear();
}
uint64_t SrsMp4Box::sz()
{
- return smallsize == SRS_MP4_USE_LARGE_SIZE ? largesize : smallsize;
+ return smallsize_ == SRS_MP4_USE_LARGE_SIZE ? largesize_ : smallsize_;
}
int SrsMp4Box::sz_header()
@@ -183,10 +183,10 @@ uint64_t SrsMp4Box::update_size()
uint64_t size = nb_bytes();
if (size > 0xffffffff) {
- largesize = size;
- smallsize = SRS_MP4_USE_LARGE_SIZE;
+ largesize_ = size;
+ smallsize_ = SRS_MP4_USE_LARGE_SIZE;
} else {
- smallsize = (uint32_t)size;
+ smallsize_ = (uint32_t)size;
}
return size;
@@ -194,32 +194,32 @@ uint64_t SrsMp4Box::update_size()
int SrsMp4Box::left_space(SrsBuffer *buf)
{
- int left = (int)sz() - (buf->pos() - start_pos);
+ int left = (int)sz() - (buf->pos() - start_pos_);
return srs_max(0, left);
}
bool SrsMp4Box::is_ftyp()
{
- return type == SrsMp4BoxTypeFTYP;
+ return type_ == SrsMp4BoxTypeFTYP;
}
bool SrsMp4Box::is_moov()
{
- return type == SrsMp4BoxTypeMOOV;
+ return type_ == SrsMp4BoxTypeMOOV;
}
bool SrsMp4Box::is_mdat()
{
- return type == SrsMp4BoxTypeMDAT;
+ return type_ == SrsMp4BoxTypeMDAT;
}
SrsMp4Box *SrsMp4Box::get(SrsMp4BoxType bt)
{
vector::iterator it;
- for (it = boxes.begin(); it != boxes.end(); ++it) {
+ for (it = boxes_.begin(); it != boxes_.end(); ++it) {
SrsMp4Box *box = *it;
- if (box->type == bt) {
+ if (box->type_ == bt) {
return box;
}
}
@@ -232,11 +232,11 @@ int SrsMp4Box::remove(SrsMp4BoxType bt)
int nb_removed = 0;
vector::iterator it;
- for (it = boxes.begin(); it != boxes.end();) {
+ for (it = boxes_.begin(); it != boxes_.end();) {
SrsMp4Box *box = *it;
- if (box->type == bt) {
- it = boxes.erase(it);
+ if (box->type_ == bt) {
+ it = boxes_.erase(it);
srs_freep(box);
} else {
++it;
@@ -248,24 +248,24 @@ int SrsMp4Box::remove(SrsMp4BoxType bt)
void SrsMp4Box::append(SrsMp4Box *box)
{
- boxes.push_back(box);
+ boxes_.push_back(box);
}
stringstream &SrsMp4Box::dumps(stringstream &ss, SrsMp4DumpContext dc)
{
srs_mp4_padding(ss, dc);
- srs_print_mp4_type(ss, (uint32_t)type);
+ srs_print_mp4_type(ss, (uint32_t)type_);
ss << ", " << sz();
- if (smallsize == SRS_MP4_USE_LARGE_SIZE) {
+ if (smallsize_ == SRS_MP4_USE_LARGE_SIZE) {
ss << "(large)";
}
ss << "B";
dumps_detail(ss, dc);
- if (!boxes.empty()) {
- ss << ", " << boxes.size() << " boxes";
+ if (!boxes_.empty()) {
+ ss << ", " << boxes_.size() << " boxes";
}
// If there contained boxes in header,
@@ -275,7 +275,7 @@ stringstream &SrsMp4Box::dumps(stringstream &ss, SrsMp4DumpContext dc)
}
vector::iterator it;
- for (it = boxes.begin(); it != boxes.end(); ++it) {
+ for (it = boxes_.begin(); it != boxes_.end(); ++it) {
SrsMp4Box *box = *it;
box->dumps(ss, dc.indent());
}
@@ -455,9 +455,9 @@ srs_error_t SrsMp4Box::discovery(SrsBuffer *buf, SrsMp4Box **ppbox)
}
if (box) {
- box->smallsize = smallsize;
- box->largesize = largesize;
- box->type = type;
+ box->smallsize_ = smallsize;
+ box->largesize_ = largesize;
+ box->type_ = type;
*ppbox = box;
}
@@ -469,7 +469,7 @@ uint64_t SrsMp4Box::nb_bytes()
uint64_t sz = nb_header();
vector::iterator it;
- for (it = boxes.begin(); it != boxes.end(); ++it) {
+ for (it = boxes_.begin(); it != boxes_.end(); ++it) {
SrsMp4Box *box = *it;
sz += box->nb_bytes();
}
@@ -483,7 +483,7 @@ srs_error_t SrsMp4Box::encode(SrsBuffer *buf)
update_size();
- start_pos = buf->pos();
+ start_pos_ = buf->pos();
if ((err = encode_header(buf)) != srs_success) {
return srs_error_wrap(err, "encode box header");
@@ -500,7 +500,7 @@ srs_error_t SrsMp4Box::decode(SrsBuffer *buf)
{
srs_error_t err = srs_success;
- start_pos = buf->pos();
+ start_pos_ = buf->pos();
if ((err = decode_header(buf)) != srs_success) {
return srs_error_wrap(err, "decode box header");
@@ -518,7 +518,7 @@ srs_error_t SrsMp4Box::encode_boxes(SrsBuffer *buf)
srs_error_t err = srs_success;
vector::iterator it;
- for (it = boxes.begin(); it != boxes.end(); ++it) {
+ for (it = boxes_.begin(); it != boxes_.end(); ++it) {
SrsMp4Box *box = *it;
if ((err = box->encode(buf)) != srs_success) {
return srs_error_wrap(err, "encode contained box");
@@ -545,7 +545,7 @@ srs_error_t SrsMp4Box::decode_boxes(SrsBuffer *buf)
return srs_error_wrap(err, "decode contained box");
}
- boxes.push_back(box);
+ boxes_.push_back(box);
left -= box->sz();
}
@@ -555,11 +555,11 @@ srs_error_t SrsMp4Box::decode_boxes(SrsBuffer *buf)
int SrsMp4Box::nb_header()
{
int size = 8;
- if (smallsize == SRS_MP4_USE_LARGE_SIZE) {
+ if (smallsize_ == SRS_MP4_USE_LARGE_SIZE) {
size += 8;
}
- if (type == SrsMp4BoxTypeUUID) {
+ if (type_ == SrsMp4BoxTypeUUID) {
size += 16;
}
@@ -575,14 +575,14 @@ srs_error_t SrsMp4Box::encode_header(SrsBuffer *buf)
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "requires %d only %d bytes", size, buf->left());
}
- buf->write_4bytes(smallsize);
- buf->write_4bytes(type);
- if (smallsize == SRS_MP4_USE_LARGE_SIZE) {
- buf->write_8bytes(largesize);
+ buf->write_4bytes(smallsize_);
+ buf->write_4bytes(type_);
+ if (smallsize_ == SRS_MP4_USE_LARGE_SIZE) {
+ buf->write_8bytes(largesize_);
}
- if (type == SrsMp4BoxTypeUUID) {
- buf->write_bytes(&usertype[0], 16);
+ if (type_ == SrsMp4BoxTypeUUID) {
+ buf->write_bytes(&usertype_[0], 16);
}
int lrsz = nb_header() - SrsMp4Box::nb_header();
@@ -600,19 +600,19 @@ srs_error_t SrsMp4Box::decode_header(SrsBuffer *buf)
if (!buf->require(8)) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "requires 8 only %d bytes", buf->left());
}
- smallsize = (uint32_t)buf->read_4bytes();
- type = (SrsMp4BoxType)buf->read_4bytes();
+ smallsize_ = (uint32_t)buf->read_4bytes();
+ type_ = (SrsMp4BoxType)buf->read_4bytes();
- if (smallsize == SRS_MP4_EOF_SIZE) {
+ if (smallsize_ == SRS_MP4_EOF_SIZE) {
srs_trace("MP4 box EOF.");
return err;
}
- if (smallsize == SRS_MP4_USE_LARGE_SIZE) {
+ if (smallsize_ == SRS_MP4_USE_LARGE_SIZE) {
if (!buf->require(8)) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "box requires 8 only %d bytes", buf->left());
}
- largesize = (uint64_t)buf->read_8bytes();
+ largesize_ = (uint64_t)buf->read_8bytes();
}
// Only support 31bits size.
@@ -620,12 +620,12 @@ srs_error_t SrsMp4Box::decode_header(SrsBuffer *buf)
return srs_error_new(ERROR_MP4_BOX_OVERFLOW, "box size overflow 31bits, size=%" PRId64, sz());
}
- if (type == SrsMp4BoxTypeUUID) {
+ if (type_ == SrsMp4BoxTypeUUID) {
if (!buf->require(16)) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "box requires 16 only %d bytes", buf->left());
}
- usertype.resize(16);
- buf->read_bytes(&usertype[0], 16);
+ usertype_.resize(16);
+ buf->read_bytes(&usertype_[0], 16);
}
// The left required size, determined by the default version(0).
@@ -649,8 +649,8 @@ stringstream &SrsMp4Box::dumps_detail(stringstream &ss, SrsMp4DumpContext dc)
SrsMp4FullBox::SrsMp4FullBox()
{
- version = 0;
- flags = 0;
+ version_ = 0;
+ flags_ = 0;
}
SrsMp4FullBox::~SrsMp4FullBox()
@@ -674,8 +674,8 @@ srs_error_t SrsMp4FullBox::encode_header(SrsBuffer *buf)
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "full box requires 4 only %d bytes", buf->left());
}
- buf->write_1bytes(version);
- buf->write_3bytes(flags);
+ buf->write_1bytes(version_);
+ buf->write_3bytes(flags_);
return err;
}
@@ -692,10 +692,10 @@ srs_error_t SrsMp4FullBox::decode_header(SrsBuffer *buf)
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "full box requires 4 only %d bytes", buf->left());
}
- flags = (uint32_t)buf->read_4bytes();
+ flags_ = (uint32_t)buf->read_4bytes();
- version = (uint8_t)((flags >> 24) & 0xff);
- flags &= 0x00ffffff;
+ version_ = (uint8_t)((flags_ >> 24) & 0xff);
+ flags_ &= 0x00ffffff;
// The left required size, determined by the version.
int lrsz = nb_header() - SrsMp4FullBox::nb_header();
@@ -712,9 +712,9 @@ stringstream &SrsMp4FullBox::dumps_detail(stringstream &ss, SrsMp4DumpContext dc
ss << ", FB(4B";
- if (version != 0 || flags != 0) {
- ss << ",V" << uint32_t(version)
- << ",0x" << std::setw(2) << std::setfill('0') << std::hex << flags << std::dec;
+ if (version_ != 0 || flags_ != 0) {
+ ss << ",V" << uint32_t(version_)
+ << ",0x" << std::setw(2) << std::setfill('0') << std::hex << flags_ << std::dec;
}
ss << ")";
@@ -724,9 +724,9 @@ stringstream &SrsMp4FullBox::dumps_detail(stringstream &ss, SrsMp4DumpContext dc
SrsMp4FileTypeBox::SrsMp4FileTypeBox()
{
- type = SrsMp4BoxTypeFTYP;
- major_brand = SrsMp4BoxBrandForbidden;
- minor_version = 0;
+ type_ = SrsMp4BoxTypeFTYP;
+ major_brand_ = SrsMp4BoxBrandForbidden;
+ minor_version_ = 0;
}
SrsMp4FileTypeBox::~SrsMp4FileTypeBox()
@@ -735,31 +735,31 @@ SrsMp4FileTypeBox::~SrsMp4FileTypeBox()
void SrsMp4FileTypeBox::set_compatible_brands(SrsMp4BoxBrand b0, SrsMp4BoxBrand b1)
{
- compatible_brands.resize(2);
- compatible_brands[0] = b0;
- compatible_brands[1] = b1;
+ compatible_brands_.resize(2);
+ compatible_brands_[0] = b0;
+ compatible_brands_[1] = b1;
}
void SrsMp4FileTypeBox::set_compatible_brands(SrsMp4BoxBrand b0, SrsMp4BoxBrand b1, SrsMp4BoxBrand b2)
{
- compatible_brands.resize(3);
- compatible_brands[0] = b0;
- compatible_brands[1] = b1;
- compatible_brands[2] = b2;
+ compatible_brands_.resize(3);
+ compatible_brands_[0] = b0;
+ compatible_brands_[1] = b1;
+ compatible_brands_[2] = b2;
}
void SrsMp4FileTypeBox::set_compatible_brands(SrsMp4BoxBrand b0, SrsMp4BoxBrand b1, SrsMp4BoxBrand b2, SrsMp4BoxBrand b3)
{
- compatible_brands.resize(4);
- compatible_brands[0] = b0;
- compatible_brands[1] = b1;
- compatible_brands[2] = b2;
- compatible_brands[3] = b3;
+ compatible_brands_.resize(4);
+ compatible_brands_[0] = b0;
+ compatible_brands_[1] = b1;
+ compatible_brands_[2] = b2;
+ compatible_brands_[3] = b3;
}
int SrsMp4FileTypeBox::nb_header()
{
- return (int)(SrsMp4Box::nb_header() + 8 + compatible_brands.size() * 4);
+ return (int)(SrsMp4Box::nb_header() + 8 + compatible_brands_.size() * 4);
}
srs_error_t SrsMp4FileTypeBox::encode_header(SrsBuffer *buf)
@@ -770,11 +770,11 @@ srs_error_t SrsMp4FileTypeBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes(major_brand);
- buf->write_4bytes(minor_version);
+ buf->write_4bytes(major_brand_);
+ buf->write_4bytes(minor_version_);
- for (size_t i = 0; i < (size_t)compatible_brands.size(); i++) {
- buf->write_4bytes(compatible_brands[i]);
+ for (size_t i = 0; i < (size_t)compatible_brands_.size(); i++) {
+ buf->write_4bytes(compatible_brands_[i]);
}
return err;
@@ -788,18 +788,18 @@ srs_error_t SrsMp4FileTypeBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- major_brand = (SrsMp4BoxBrand)buf->read_4bytes();
- minor_version = buf->read_4bytes();
+ major_brand_ = (SrsMp4BoxBrand)buf->read_4bytes();
+ minor_version_ = buf->read_4bytes();
// Compatible brands to the end of the box.
int left = left_space(buf);
if (left > 0) {
- compatible_brands.resize(left / 4);
+ compatible_brands_.resize(left / 4);
}
for (int i = 0; left > 0; i++, left -= 4) {
- compatible_brands[i] = (SrsMp4BoxBrand)buf->read_4bytes();
+ compatible_brands_[i] = (SrsMp4BoxBrand)buf->read_4bytes();
}
return err;
@@ -810,13 +810,13 @@ stringstream &SrsMp4FileTypeBox::dumps_detail(stringstream &ss, SrsMp4DumpContex
SrsMp4Box::dumps_detail(ss, dc);
ss << ", brands:";
- srs_print_mp4_type(ss, (uint32_t)major_brand);
+ srs_print_mp4_type(ss, (uint32_t)major_brand_);
- ss << "," << minor_version;
+ ss << "," << minor_version_;
- if (!compatible_brands.empty()) {
+ if (!compatible_brands_.empty()) {
ss << "(";
- srs_dumps_array(compatible_brands, ss, dc, srs_mp4_pfn_type, srs_mp4_delimiter_inline);
+ srs_dumps_array(compatible_brands_, ss, dc, srs_mp4_pfn_type, srs_mp4_delimiter_inline);
ss << ")";
}
return ss;
@@ -824,7 +824,7 @@ stringstream &SrsMp4FileTypeBox::dumps_detail(stringstream &ss, SrsMp4DumpContex
SrsMp4SegmentTypeBox::SrsMp4SegmentTypeBox()
{
- type = SrsMp4BoxTypeSTYP;
+ type_ = SrsMp4BoxTypeSTYP;
}
SrsMp4SegmentTypeBox::~SrsMp4SegmentTypeBox()
@@ -833,7 +833,7 @@ SrsMp4SegmentTypeBox::~SrsMp4SegmentTypeBox()
SrsMp4MovieFragmentBox::SrsMp4MovieFragmentBox()
{
- type = SrsMp4BoxTypeMOOF;
+ type_ = SrsMp4BoxTypeMOOF;
}
SrsMp4MovieFragmentBox::~SrsMp4MovieFragmentBox()
@@ -849,19 +849,19 @@ SrsMp4MovieFragmentHeaderBox *SrsMp4MovieFragmentBox::mfhd()
void SrsMp4MovieFragmentBox::set_mfhd(SrsMp4MovieFragmentHeaderBox *v)
{
remove(SrsMp4BoxTypeMFHD);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
void SrsMp4MovieFragmentBox::add_traf(SrsMp4TrackFragmentBox *v)
{
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4MovieFragmentHeaderBox::SrsMp4MovieFragmentHeaderBox()
{
- type = SrsMp4BoxTypeMFHD;
+ type_ = SrsMp4BoxTypeMFHD;
- sequence_number = 0;
+ sequence_number_ = 0;
}
SrsMp4MovieFragmentHeaderBox::~SrsMp4MovieFragmentHeaderBox()
@@ -881,7 +881,7 @@ srs_error_t SrsMp4MovieFragmentHeaderBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes(sequence_number);
+ buf->write_4bytes(sequence_number_);
return err;
}
@@ -894,7 +894,7 @@ srs_error_t SrsMp4MovieFragmentHeaderBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- sequence_number = buf->read_4bytes();
+ sequence_number_ = buf->read_4bytes();
return err;
}
@@ -903,13 +903,13 @@ stringstream &SrsMp4MovieFragmentHeaderBox::dumps_detail(stringstream &ss, SrsMp
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", sequence=" << sequence_number;
+ ss << ", sequence=" << sequence_number_;
return ss;
}
SrsMp4TrackFragmentBox::SrsMp4TrackFragmentBox()
{
- type = SrsMp4BoxTypeTRAF;
+ type_ = SrsMp4BoxTypeTRAF;
}
SrsMp4TrackFragmentBox::~SrsMp4TrackFragmentBox()
@@ -925,7 +925,7 @@ SrsMp4TrackFragmentHeaderBox *SrsMp4TrackFragmentBox::tfhd()
void SrsMp4TrackFragmentBox::set_tfhd(SrsMp4TrackFragmentHeaderBox *v)
{
remove(SrsMp4BoxTypeTFHD);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4TrackFragmentDecodeTimeBox *SrsMp4TrackFragmentBox::tfdt()
@@ -937,7 +937,7 @@ SrsMp4TrackFragmentDecodeTimeBox *SrsMp4TrackFragmentBox::tfdt()
void SrsMp4TrackFragmentBox::set_tfdt(SrsMp4TrackFragmentDecodeTimeBox *v)
{
remove(SrsMp4BoxTypeTFDT);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4TrackFragmentRunBox *SrsMp4TrackFragmentBox::trun()
@@ -949,18 +949,18 @@ SrsMp4TrackFragmentRunBox *SrsMp4TrackFragmentBox::trun()
void SrsMp4TrackFragmentBox::set_trun(SrsMp4TrackFragmentRunBox *v)
{
remove(SrsMp4BoxTypeTRUN);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4TrackFragmentHeaderBox::SrsMp4TrackFragmentHeaderBox()
{
- type = SrsMp4BoxTypeTFHD;
+ type_ = SrsMp4BoxTypeTFHD;
- flags = 0;
- base_data_offset = 0;
- track_id = sample_description_index = 0;
- default_sample_duration = default_sample_size = 0;
- default_sample_flags = 0;
+ flags_ = 0;
+ base_data_offset_ = 0;
+ track_id_ = sample_description_index_ = 0;
+ default_sample_duration_ = default_sample_size_ = 0;
+ default_sample_flags_ = 0;
}
SrsMp4TrackFragmentHeaderBox::~SrsMp4TrackFragmentHeaderBox()
@@ -971,19 +971,19 @@ int SrsMp4TrackFragmentHeaderBox::nb_header()
{
int size = SrsMp4FullBox::nb_header() + 4;
- if ((flags & SrsMp4TfhdFlagsBaseDataOffset) == SrsMp4TfhdFlagsBaseDataOffset) {
+ if ((flags_ & SrsMp4TfhdFlagsBaseDataOffset) == SrsMp4TfhdFlagsBaseDataOffset) {
size += 8;
}
- if ((flags & SrsMp4TfhdFlagsSampleDescriptionIndex) == SrsMp4TfhdFlagsSampleDescriptionIndex) {
+ if ((flags_ & SrsMp4TfhdFlagsSampleDescriptionIndex) == SrsMp4TfhdFlagsSampleDescriptionIndex) {
size += 4;
}
- if ((flags & SrsMp4TfhdFlagsDefaultSampleDuration) == SrsMp4TfhdFlagsDefaultSampleDuration) {
+ if ((flags_ & SrsMp4TfhdFlagsDefaultSampleDuration) == SrsMp4TfhdFlagsDefaultSampleDuration) {
size += 4;
}
- if ((flags & SrsMp4TfhdFlagsDefautlSampleSize) == SrsMp4TfhdFlagsDefautlSampleSize) {
+ if ((flags_ & SrsMp4TfhdFlagsDefautlSampleSize) == SrsMp4TfhdFlagsDefautlSampleSize) {
size += 4;
}
- if ((flags & SrsMp4TfhdFlagsDefaultSampleFlags) == SrsMp4TfhdFlagsDefaultSampleFlags) {
+ if ((flags_ & SrsMp4TfhdFlagsDefaultSampleFlags) == SrsMp4TfhdFlagsDefaultSampleFlags) {
size += 4;
}
@@ -998,22 +998,22 @@ srs_error_t SrsMp4TrackFragmentHeaderBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes(track_id);
+ buf->write_4bytes(track_id_);
- if ((flags & SrsMp4TfhdFlagsBaseDataOffset) == SrsMp4TfhdFlagsBaseDataOffset) {
- buf->write_8bytes(base_data_offset);
+ if ((flags_ & SrsMp4TfhdFlagsBaseDataOffset) == SrsMp4TfhdFlagsBaseDataOffset) {
+ buf->write_8bytes(base_data_offset_);
}
- if ((flags & SrsMp4TfhdFlagsSampleDescriptionIndex) == SrsMp4TfhdFlagsSampleDescriptionIndex) {
- buf->write_4bytes(sample_description_index);
+ if ((flags_ & SrsMp4TfhdFlagsSampleDescriptionIndex) == SrsMp4TfhdFlagsSampleDescriptionIndex) {
+ buf->write_4bytes(sample_description_index_);
}
- if ((flags & SrsMp4TfhdFlagsDefaultSampleDuration) == SrsMp4TfhdFlagsDefaultSampleDuration) {
- buf->write_4bytes(default_sample_duration);
+ if ((flags_ & SrsMp4TfhdFlagsDefaultSampleDuration) == SrsMp4TfhdFlagsDefaultSampleDuration) {
+ buf->write_4bytes(default_sample_duration_);
}
- if ((flags & SrsMp4TfhdFlagsDefautlSampleSize) == SrsMp4TfhdFlagsDefautlSampleSize) {
- buf->write_4bytes(default_sample_size);
+ if ((flags_ & SrsMp4TfhdFlagsDefautlSampleSize) == SrsMp4TfhdFlagsDefautlSampleSize) {
+ buf->write_4bytes(default_sample_size_);
}
- if ((flags & SrsMp4TfhdFlagsDefaultSampleFlags) == SrsMp4TfhdFlagsDefaultSampleFlags) {
- buf->write_4bytes(default_sample_flags);
+ if ((flags_ & SrsMp4TfhdFlagsDefaultSampleFlags) == SrsMp4TfhdFlagsDefaultSampleFlags) {
+ buf->write_4bytes(default_sample_flags_);
}
return err;
@@ -1027,22 +1027,22 @@ srs_error_t SrsMp4TrackFragmentHeaderBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- track_id = buf->read_4bytes();
+ track_id_ = buf->read_4bytes();
- if ((flags & SrsMp4TfhdFlagsBaseDataOffset) == SrsMp4TfhdFlagsBaseDataOffset) {
- base_data_offset = buf->read_8bytes();
+ if ((flags_ & SrsMp4TfhdFlagsBaseDataOffset) == SrsMp4TfhdFlagsBaseDataOffset) {
+ base_data_offset_ = buf->read_8bytes();
}
- if ((flags & SrsMp4TfhdFlagsSampleDescriptionIndex) == SrsMp4TfhdFlagsSampleDescriptionIndex) {
- sample_description_index = buf->read_4bytes();
+ if ((flags_ & SrsMp4TfhdFlagsSampleDescriptionIndex) == SrsMp4TfhdFlagsSampleDescriptionIndex) {
+ sample_description_index_ = buf->read_4bytes();
}
- if ((flags & SrsMp4TfhdFlagsDefaultSampleDuration) == SrsMp4TfhdFlagsDefaultSampleDuration) {
- default_sample_duration = buf->read_4bytes();
+ if ((flags_ & SrsMp4TfhdFlagsDefaultSampleDuration) == SrsMp4TfhdFlagsDefaultSampleDuration) {
+ default_sample_duration_ = buf->read_4bytes();
}
- if ((flags & SrsMp4TfhdFlagsDefautlSampleSize) == SrsMp4TfhdFlagsDefautlSampleSize) {
- default_sample_size = buf->read_4bytes();
+ if ((flags_ & SrsMp4TfhdFlagsDefautlSampleSize) == SrsMp4TfhdFlagsDefautlSampleSize) {
+ default_sample_size_ = buf->read_4bytes();
}
- if ((flags & SrsMp4TfhdFlagsDefaultSampleFlags) == SrsMp4TfhdFlagsDefaultSampleFlags) {
- default_sample_flags = buf->read_4bytes();
+ if ((flags_ & SrsMp4TfhdFlagsDefaultSampleFlags) == SrsMp4TfhdFlagsDefaultSampleFlags) {
+ default_sample_flags_ = buf->read_4bytes();
}
return err;
@@ -1052,28 +1052,28 @@ stringstream &SrsMp4TrackFragmentHeaderBox::dumps_detail(stringstream &ss, SrsMp
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", track=" << track_id;
+ ss << ", track=" << track_id_;
- if ((flags & SrsMp4TfhdFlagsBaseDataOffset) == SrsMp4TfhdFlagsBaseDataOffset) {
- ss << ", bdo=" << base_data_offset;
+ if ((flags_ & SrsMp4TfhdFlagsBaseDataOffset) == SrsMp4TfhdFlagsBaseDataOffset) {
+ ss << ", bdo=" << base_data_offset_;
}
- if ((flags & SrsMp4TfhdFlagsSampleDescriptionIndex) == SrsMp4TfhdFlagsSampleDescriptionIndex) {
- ss << ", sdi=" << sample_description_index;
+ if ((flags_ & SrsMp4TfhdFlagsSampleDescriptionIndex) == SrsMp4TfhdFlagsSampleDescriptionIndex) {
+ ss << ", sdi=" << sample_description_index_;
}
- if ((flags & SrsMp4TfhdFlagsDefaultSampleDuration) == SrsMp4TfhdFlagsDefaultSampleDuration) {
- ss << ", dsu=" << default_sample_duration;
+ if ((flags_ & SrsMp4TfhdFlagsDefaultSampleDuration) == SrsMp4TfhdFlagsDefaultSampleDuration) {
+ ss << ", dsu=" << default_sample_duration_;
}
- if ((flags & SrsMp4TfhdFlagsDefautlSampleSize) == SrsMp4TfhdFlagsDefautlSampleSize) {
- ss << ", dss=" << default_sample_size;
+ if ((flags_ & SrsMp4TfhdFlagsDefautlSampleSize) == SrsMp4TfhdFlagsDefautlSampleSize) {
+ ss << ", dss=" << default_sample_size_;
}
- if ((flags & SrsMp4TfhdFlagsDefaultSampleFlags) == SrsMp4TfhdFlagsDefaultSampleFlags) {
- ss << ", dsf=" << default_sample_flags;
+ if ((flags_ & SrsMp4TfhdFlagsDefaultSampleFlags) == SrsMp4TfhdFlagsDefaultSampleFlags) {
+ ss << ", dsf=" << default_sample_flags_;
}
- if ((flags & SrsMp4TfhdFlagsDurationIsEmpty) == SrsMp4TfhdFlagsDurationIsEmpty) {
+ if ((flags_ & SrsMp4TfhdFlagsDurationIsEmpty) == SrsMp4TfhdFlagsDurationIsEmpty) {
ss << ", empty-duration";
}
- if ((flags & SrsMp4TfhdFlagsDefaultBaseIsMoof) == SrsMp4TfhdFlagsDefaultBaseIsMoof) {
+ if ((flags_ & SrsMp4TfhdFlagsDefaultBaseIsMoof) == SrsMp4TfhdFlagsDefaultBaseIsMoof) {
ss << ", moof-base";
}
@@ -1082,8 +1082,8 @@ stringstream &SrsMp4TrackFragmentHeaderBox::dumps_detail(stringstream &ss, SrsMp
SrsMp4TrackFragmentDecodeTimeBox::SrsMp4TrackFragmentDecodeTimeBox()
{
- type = SrsMp4BoxTypeTFDT;
- base_media_decode_time = 0;
+ type_ = SrsMp4BoxTypeTFDT;
+ base_media_decode_time_ = 0;
}
SrsMp4TrackFragmentDecodeTimeBox::~SrsMp4TrackFragmentDecodeTimeBox()
@@ -1092,7 +1092,7 @@ SrsMp4TrackFragmentDecodeTimeBox::~SrsMp4TrackFragmentDecodeTimeBox()
int SrsMp4TrackFragmentDecodeTimeBox::nb_header()
{
- return SrsMp4FullBox::nb_header() + (version ? 8 : 4);
+ return SrsMp4FullBox::nb_header() + (version_ ? 8 : 4);
}
srs_error_t SrsMp4TrackFragmentDecodeTimeBox::encode_header(SrsBuffer *buf)
@@ -1103,10 +1103,10 @@ srs_error_t SrsMp4TrackFragmentDecodeTimeBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- if (version) {
- buf->write_8bytes(base_media_decode_time);
+ if (version_) {
+ buf->write_8bytes(base_media_decode_time_);
} else {
- buf->write_4bytes((uint32_t)base_media_decode_time);
+ buf->write_4bytes((uint32_t)base_media_decode_time_);
}
return err;
@@ -1120,10 +1120,10 @@ srs_error_t SrsMp4TrackFragmentDecodeTimeBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- if (version) {
- base_media_decode_time = buf->read_8bytes();
+ if (version_) {
+ base_media_decode_time_ = buf->read_8bytes();
} else {
- base_media_decode_time = buf->read_4bytes();
+ base_media_decode_time_ = buf->read_4bytes();
}
return err;
@@ -1133,16 +1133,16 @@ stringstream &SrsMp4TrackFragmentDecodeTimeBox::dumps_detail(stringstream &ss, S
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", bmdt=" << base_media_decode_time;
+ ss << ", bmdt=" << base_media_decode_time_;
return ss;
}
SrsMp4TrunEntry::SrsMp4TrunEntry(SrsMp4FullBox *o)
{
- owner = o;
- sample_duration = sample_size = sample_flags = 0;
- sample_composition_time_offset = 0;
+ owner_ = o;
+ sample_duration_ = sample_size_ = sample_flags_ = 0;
+ sample_composition_time_offset_ = 0;
}
SrsMp4TrunEntry::~SrsMp4TrunEntry()
@@ -1153,16 +1153,16 @@ uint64_t SrsMp4TrunEntry::nb_bytes()
{
int size = 0;
- if ((owner->flags & SrsMp4TrunFlagsSampleDuration) == SrsMp4TrunFlagsSampleDuration) {
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleDuration) == SrsMp4TrunFlagsSampleDuration) {
size += 4;
}
- if ((owner->flags & SrsMp4TrunFlagsSampleSize) == SrsMp4TrunFlagsSampleSize) {
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleSize) == SrsMp4TrunFlagsSampleSize) {
size += 4;
}
- if ((owner->flags & SrsMp4TrunFlagsSampleFlag) == SrsMp4TrunFlagsSampleFlag) {
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleFlag) == SrsMp4TrunFlagsSampleFlag) {
size += 4;
}
- if ((owner->flags & SrsMp4TrunFlagsSampleCtsOffset) == SrsMp4TrunFlagsSampleCtsOffset) {
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleCtsOffset) == SrsMp4TrunFlagsSampleCtsOffset) {
size += 4;
}
@@ -1173,21 +1173,21 @@ srs_error_t SrsMp4TrunEntry::encode(SrsBuffer *buf)
{
srs_error_t err = srs_success;
- if ((owner->flags & SrsMp4TrunFlagsSampleDuration) == SrsMp4TrunFlagsSampleDuration) {
- buf->write_4bytes(sample_duration);
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleDuration) == SrsMp4TrunFlagsSampleDuration) {
+ buf->write_4bytes(sample_duration_);
}
- if ((owner->flags & SrsMp4TrunFlagsSampleSize) == SrsMp4TrunFlagsSampleSize) {
- buf->write_4bytes(sample_size);
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleSize) == SrsMp4TrunFlagsSampleSize) {
+ buf->write_4bytes(sample_size_);
}
- if ((owner->flags & SrsMp4TrunFlagsSampleFlag) == SrsMp4TrunFlagsSampleFlag) {
- buf->write_4bytes(sample_flags);
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleFlag) == SrsMp4TrunFlagsSampleFlag) {
+ buf->write_4bytes(sample_flags_);
}
- if ((owner->flags & SrsMp4TrunFlagsSampleCtsOffset) == SrsMp4TrunFlagsSampleCtsOffset) {
- if (!owner->version) {
- uint32_t v = (uint32_t)sample_composition_time_offset;
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleCtsOffset) == SrsMp4TrunFlagsSampleCtsOffset) {
+ if (!owner_->version_) {
+ uint32_t v = (uint32_t)sample_composition_time_offset_;
buf->write_4bytes(v);
} else {
- int32_t v = (int32_t)sample_composition_time_offset;
+ int32_t v = (int32_t)sample_composition_time_offset_;
buf->write_4bytes(v);
}
}
@@ -1199,22 +1199,22 @@ srs_error_t SrsMp4TrunEntry::decode(SrsBuffer *buf)
{
srs_error_t err = srs_success;
- if ((owner->flags & SrsMp4TrunFlagsSampleDuration) == SrsMp4TrunFlagsSampleDuration) {
- sample_duration = buf->read_4bytes();
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleDuration) == SrsMp4TrunFlagsSampleDuration) {
+ sample_duration_ = buf->read_4bytes();
}
- if ((owner->flags & SrsMp4TrunFlagsSampleSize) == SrsMp4TrunFlagsSampleSize) {
- sample_size = buf->read_4bytes();
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleSize) == SrsMp4TrunFlagsSampleSize) {
+ sample_size_ = buf->read_4bytes();
}
- if ((owner->flags & SrsMp4TrunFlagsSampleFlag) == SrsMp4TrunFlagsSampleFlag) {
- sample_flags = buf->read_4bytes();
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleFlag) == SrsMp4TrunFlagsSampleFlag) {
+ sample_flags_ = buf->read_4bytes();
}
- if ((owner->flags & SrsMp4TrunFlagsSampleCtsOffset) == SrsMp4TrunFlagsSampleCtsOffset) {
- if (!owner->version) {
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleCtsOffset) == SrsMp4TrunFlagsSampleCtsOffset) {
+ if (!owner_->version_) {
uint32_t v = buf->read_4bytes();
- sample_composition_time_offset = v;
+ sample_composition_time_offset_ = v;
} else {
int32_t v = buf->read_4bytes();
- sample_composition_time_offset = v;
+ sample_composition_time_offset_ = v;
}
}
@@ -1223,32 +1223,32 @@ srs_error_t SrsMp4TrunEntry::decode(SrsBuffer *buf)
stringstream &SrsMp4TrunEntry::dumps(stringstream &ss, SrsMp4DumpContext dc)
{
- if ((owner->flags & SrsMp4TrunFlagsSampleDuration) == SrsMp4TrunFlagsSampleDuration) {
- ss << "duration=" << sample_duration;
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleDuration) == SrsMp4TrunFlagsSampleDuration) {
+ ss << "duration=" << sample_duration_;
}
- if ((owner->flags & SrsMp4TrunFlagsSampleSize) == SrsMp4TrunFlagsSampleSize) {
- ss << ", size=" << sample_size;
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleSize) == SrsMp4TrunFlagsSampleSize) {
+ ss << ", size=" << sample_size_;
}
- if ((owner->flags & SrsMp4TrunFlagsSampleFlag) == SrsMp4TrunFlagsSampleFlag) {
- ss << ", flags=" << sample_flags;
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleFlag) == SrsMp4TrunFlagsSampleFlag) {
+ ss << ", flags=" << sample_flags_;
}
- if ((owner->flags & SrsMp4TrunFlagsSampleCtsOffset) == SrsMp4TrunFlagsSampleCtsOffset) {
- ss << ", cts=" << sample_composition_time_offset;
+ if ((owner_->flags_ & SrsMp4TrunFlagsSampleCtsOffset) == SrsMp4TrunFlagsSampleCtsOffset) {
+ ss << ", cts=" << sample_composition_time_offset_;
}
return ss;
}
SrsMp4TrackFragmentRunBox::SrsMp4TrackFragmentRunBox()
{
- type = SrsMp4BoxTypeTRUN;
- first_sample_flags = 0;
- data_offset = 0;
+ type_ = SrsMp4BoxTypeTRUN;
+ first_sample_flags_ = 0;
+ data_offset_ = 0;
}
SrsMp4TrackFragmentRunBox::~SrsMp4TrackFragmentRunBox()
{
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); ++it) {
+ for (it = entries_.begin(); it != entries_.end(); ++it) {
SrsMp4TrunEntry *entry = *it;
srs_freep(entry);
}
@@ -1258,15 +1258,15 @@ int SrsMp4TrackFragmentRunBox::nb_header()
{
int size = SrsMp4FullBox::nb_header() + 4;
- if ((flags & SrsMp4TrunFlagsDataOffset) == SrsMp4TrunFlagsDataOffset) {
+ if ((flags_ & SrsMp4TrunFlagsDataOffset) == SrsMp4TrunFlagsDataOffset) {
size += 4;
}
- if ((flags & SrsMp4TrunFlagsFirstSample) == SrsMp4TrunFlagsFirstSample) {
+ if ((flags_ & SrsMp4TrunFlagsFirstSample) == SrsMp4TrunFlagsFirstSample) {
size += 4;
}
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); ++it) {
+ for (it = entries_.begin(); it != entries_.end(); ++it) {
SrsMp4TrunEntry *entry = *it;
size += entry->nb_bytes();
}
@@ -1282,18 +1282,18 @@ srs_error_t SrsMp4TrackFragmentRunBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- uint32_t sample_count = (uint32_t)entries.size();
+ uint32_t sample_count = (uint32_t)entries_.size();
buf->write_4bytes(sample_count);
- if ((flags & SrsMp4TrunFlagsDataOffset) == SrsMp4TrunFlagsDataOffset) {
- buf->write_4bytes(data_offset);
+ if ((flags_ & SrsMp4TrunFlagsDataOffset) == SrsMp4TrunFlagsDataOffset) {
+ buf->write_4bytes(data_offset_);
}
- if ((flags & SrsMp4TrunFlagsFirstSample) == SrsMp4TrunFlagsFirstSample) {
- buf->write_4bytes(first_sample_flags);
+ if ((flags_ & SrsMp4TrunFlagsFirstSample) == SrsMp4TrunFlagsFirstSample) {
+ buf->write_4bytes(first_sample_flags_);
}
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); ++it) {
+ for (it = entries_.begin(); it != entries_.end(); ++it) {
SrsMp4TrunEntry *entry = *it;
if ((err = entry->encode(buf)) != srs_success) {
return srs_error_wrap(err, "encode entry");
@@ -1313,16 +1313,16 @@ srs_error_t SrsMp4TrackFragmentRunBox::decode_header(SrsBuffer *buf)
uint32_t sample_count = buf->read_4bytes();
- if ((flags & SrsMp4TrunFlagsDataOffset) == SrsMp4TrunFlagsDataOffset) {
- data_offset = buf->read_4bytes();
+ if ((flags_ & SrsMp4TrunFlagsDataOffset) == SrsMp4TrunFlagsDataOffset) {
+ data_offset_ = buf->read_4bytes();
}
- if ((flags & SrsMp4TrunFlagsFirstSample) == SrsMp4TrunFlagsFirstSample) {
- first_sample_flags = buf->read_4bytes();
+ if ((flags_ & SrsMp4TrunFlagsFirstSample) == SrsMp4TrunFlagsFirstSample) {
+ first_sample_flags_ = buf->read_4bytes();
}
for (int i = 0; i < (int)sample_count; i++) {
SrsMp4TrunEntry *entry = new SrsMp4TrunEntry(this);
- entries.push_back(entry);
+ entries_.push_back(entry);
if (!buf->require(entry->nb_bytes())) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "trun entry requires %d bytes", entry->nb_bytes());
@@ -1340,20 +1340,20 @@ stringstream &SrsMp4TrackFragmentRunBox::dumps_detail(stringstream &ss, SrsMp4Du
{
SrsMp4FullBox::dumps_detail(ss, dc);
- uint32_t sample_count = (uint32_t)entries.size();
+ uint32_t sample_count = (uint32_t)entries_.size();
ss << ", samples=" << sample_count;
- if ((flags & SrsMp4TrunFlagsDataOffset) == SrsMp4TrunFlagsDataOffset) {
- ss << ", data-offset=" << data_offset;
+ if ((flags_ & SrsMp4TrunFlagsDataOffset) == SrsMp4TrunFlagsDataOffset) {
+ ss << ", data-offset=" << data_offset_;
}
- if ((flags & SrsMp4TrunFlagsFirstSample) == SrsMp4TrunFlagsFirstSample) {
- ss << ", first-sample=" << first_sample_flags;
+ if ((flags_ & SrsMp4TrunFlagsFirstSample) == SrsMp4TrunFlagsFirstSample) {
+ ss << ", first-sample=" << first_sample_flags_;
}
if (sample_count > 0) {
ss << endl;
srs_mp4_padding(ss, dc.indent());
- srs_dumps_array(entries, ss, dc.indent(), srs_mp4_pfn_box2, srs_mp4_delimiter_newline);
+ srs_dumps_array(entries_, ss, dc.indent(), srs_mp4_pfn_box2, srs_mp4_delimiter_newline);
}
return ss;
@@ -1361,8 +1361,8 @@ stringstream &SrsMp4TrackFragmentRunBox::dumps_detail(stringstream &ss, SrsMp4Du
SrsMp4MediaDataBox::SrsMp4MediaDataBox()
{
- type = SrsMp4BoxTypeMDAT;
- nb_data = 0;
+ type_ = SrsMp4BoxTypeMDAT;
+ nb_data_ = 0;
}
SrsMp4MediaDataBox::~SrsMp4MediaDataBox()
@@ -1371,7 +1371,7 @@ SrsMp4MediaDataBox::~SrsMp4MediaDataBox()
uint64_t SrsMp4MediaDataBox::nb_bytes()
{
- return SrsMp4Box::nb_header() + nb_data;
+ return SrsMp4Box::nb_header() + nb_data_;
}
srs_error_t SrsMp4MediaDataBox::encode(SrsBuffer *buf)
@@ -1393,7 +1393,7 @@ srs_error_t SrsMp4MediaDataBox::decode(SrsBuffer *buf)
return srs_error_wrap(err, "decode box");
}
- nb_data = sz() - (uint64_t)nb_header();
+ nb_data_ = sz() - (uint64_t)nb_header();
return err;
}
@@ -1412,14 +1412,14 @@ stringstream &SrsMp4MediaDataBox::dumps_detail(stringstream &ss, SrsMp4DumpConte
{
SrsMp4Box::dumps_detail(ss, dc);
- ss << ", total " << nb_data << " bytes";
+ ss << ", total " << nb_data_ << " bytes";
return ss;
}
SrsMp4FreeSpaceBox::SrsMp4FreeSpaceBox(SrsMp4BoxType v)
{
- type = v; // 'free' or 'skip'
+ type_ = v; // 'free' or 'skip'
}
SrsMp4FreeSpaceBox::~SrsMp4FreeSpaceBox()
@@ -1428,7 +1428,7 @@ SrsMp4FreeSpaceBox::~SrsMp4FreeSpaceBox()
int SrsMp4FreeSpaceBox::nb_header()
{
- return SrsMp4Box::nb_header() + (int)data.size();
+ return SrsMp4Box::nb_header() + (int)data_.size();
}
srs_error_t SrsMp4FreeSpaceBox::encode_header(SrsBuffer *buf)
@@ -1439,8 +1439,8 @@ srs_error_t SrsMp4FreeSpaceBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- if (!data.empty()) {
- buf->write_bytes(&data[0], (int)data.size());
+ if (!data_.empty()) {
+ buf->write_bytes(&data_[0], (int)data_.size());
}
return err;
@@ -1456,8 +1456,8 @@ srs_error_t SrsMp4FreeSpaceBox::decode_header(SrsBuffer *buf)
int left = left_space(buf);
if (left) {
- data.resize(left);
- buf->read_bytes(&data[0], left);
+ data_.resize(left);
+ buf->read_bytes(&data_[0], left);
}
return err;
@@ -1467,19 +1467,19 @@ stringstream &SrsMp4FreeSpaceBox::dumps_detail(stringstream &ss, SrsMp4DumpConte
{
SrsMp4Box::dumps_detail(ss, dc);
- ss << ", free " << data.size() << "B";
+ ss << ", free " << data_.size() << "B";
- if (!data.empty()) {
+ if (!data_.empty()) {
ss << endl;
srs_mp4_padding(ss, dc.indent());
- srs_dumps_array(&data[0], (int)data.size(), ss, dc.indent(), srs_mp4_pfn_hex, srs_mp4_delimiter_inspace);
+ srs_dumps_array(&data_[0], (int)data_.size(), ss, dc.indent(), srs_mp4_pfn_hex, srs_mp4_delimiter_inspace);
}
return ss;
}
SrsMp4MovieBox::SrsMp4MovieBox()
{
- type = SrsMp4BoxTypeMOOV;
+ type_ = SrsMp4BoxTypeMOOV;
}
SrsMp4MovieBox::~SrsMp4MovieBox()
@@ -1495,7 +1495,7 @@ SrsMp4MovieHeaderBox *SrsMp4MovieBox::mvhd()
void SrsMp4MovieBox::set_mvhd(SrsMp4MovieHeaderBox *v)
{
remove(SrsMp4BoxTypeMVHD);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4MovieExtendsBox *SrsMp4MovieBox::mvex()
@@ -1507,14 +1507,14 @@ SrsMp4MovieExtendsBox *SrsMp4MovieBox::mvex()
void SrsMp4MovieBox::set_mvex(SrsMp4MovieExtendsBox *v)
{
remove(SrsMp4BoxTypeMVEX);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4TrackBox *SrsMp4MovieBox::video()
{
- for (int i = 0; i < (int)boxes.size(); i++) {
- SrsMp4Box *box = boxes.at(i);
- if (box->type == SrsMp4BoxTypeTRAK) {
+ for (int i = 0; i < (int)boxes_.size(); i++) {
+ SrsMp4Box *box = boxes_.at(i);
+ if (box->type_ == SrsMp4BoxTypeTRAK) {
SrsMp4TrackBox *trak = dynamic_cast(box);
if ((trak->track_type() & SrsMp4TrackTypeVideo) == SrsMp4TrackTypeVideo) {
return trak;
@@ -1526,9 +1526,9 @@ SrsMp4TrackBox *SrsMp4MovieBox::video()
SrsMp4TrackBox *SrsMp4MovieBox::audio()
{
- for (int i = 0; i < (int)boxes.size(); i++) {
- SrsMp4Box *box = boxes.at(i);
- if (box->type == SrsMp4BoxTypeTRAK) {
+ for (int i = 0; i < (int)boxes_.size(); i++) {
+ SrsMp4Box *box = boxes_.at(i);
+ if (box->type_ == SrsMp4BoxTypeTRAK) {
SrsMp4TrackBox *trak = dynamic_cast(box);
if ((trak->track_type() & SrsMp4TrackTypeAudio) == SrsMp4TrackTypeAudio) {
return trak;
@@ -1540,16 +1540,16 @@ SrsMp4TrackBox *SrsMp4MovieBox::audio()
void SrsMp4MovieBox::add_trak(SrsMp4TrackBox *v)
{
- boxes.push_back(v);
+ boxes_.push_back(v);
}
int SrsMp4MovieBox::nb_vide_tracks()
{
int nb_tracks = 0;
- for (int i = 0; i < (int)boxes.size(); i++) {
- SrsMp4Box *box = boxes.at(i);
- if (box->type == SrsMp4BoxTypeTRAK) {
+ for (int i = 0; i < (int)boxes_.size(); i++) {
+ SrsMp4Box *box = boxes_.at(i);
+ if (box->type_ == SrsMp4BoxTypeTRAK) {
SrsMp4TrackBox *trak = dynamic_cast(box);
if ((trak->track_type() & SrsMp4TrackTypeVideo) == SrsMp4TrackTypeVideo) {
nb_tracks++;
@@ -1564,9 +1564,9 @@ int SrsMp4MovieBox::nb_soun_tracks()
{
int nb_tracks = 0;
- for (int i = 0; i < (int)boxes.size(); i++) {
- SrsMp4Box *box = boxes.at(i);
- if (box->type == SrsMp4BoxTypeTRAK) {
+ for (int i = 0; i < (int)boxes_.size(); i++) {
+ SrsMp4Box *box = boxes_.at(i);
+ if (box->type_ == SrsMp4BoxTypeTRAK) {
SrsMp4TrackBox *trak = dynamic_cast(box);
if ((trak->track_type() & SrsMp4TrackTypeAudio) == SrsMp4TrackTypeAudio) {
nb_tracks++;
@@ -1604,21 +1604,21 @@ srs_error_t SrsMp4MovieBox::decode_header(SrsBuffer *buf)
return err;
}
-SrsMp4MovieHeaderBox::SrsMp4MovieHeaderBox() : creation_time(0), modification_time(0), timescale(0), duration_in_tbn(0)
+SrsMp4MovieHeaderBox::SrsMp4MovieHeaderBox() : creation_time_(0), modification_time_(0), timescale_(0), duration_in_tbn_(0)
{
- type = SrsMp4BoxTypeMVHD;
+ type_ = SrsMp4BoxTypeMVHD;
- rate = 0x00010000; // typically 1.0
- volume = 0x0100; // typically, full volume
- reserved0 = 0;
- reserved1 = 0;
+ rate_ = 0x00010000; // typically 1.0
+ volume_ = 0x0100; // typically, full volume
+ reserved0_ = 0;
+ reserved1_ = 0;
int32_t v[] = {0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000};
- memcpy(matrix, v, 36);
+ memcpy(matrix_, v, 36);
- memset(pre_defined, 0, 24);
+ memset(pre_defined_, 0, 24);
- next_track_ID = 0;
+ next_track_ID_ = 0;
}
SrsMp4MovieHeaderBox::~SrsMp4MovieHeaderBox()
@@ -1627,17 +1627,17 @@ SrsMp4MovieHeaderBox::~SrsMp4MovieHeaderBox()
uint64_t SrsMp4MovieHeaderBox::duration()
{
- if (timescale <= 0) {
+ if (timescale_ <= 0) {
return 0;
}
- return duration_in_tbn * 1000 / timescale;
+ return duration_in_tbn_ * 1000 / timescale_;
}
int SrsMp4MovieHeaderBox::nb_header()
{
int size = SrsMp4FullBox::nb_header();
- if (version == 1) {
+ if (version_ == 1) {
size += 8 + 8 + 4 + 8;
} else {
size += 4 + 4 + 4 + 4;
@@ -1656,29 +1656,29 @@ srs_error_t SrsMp4MovieHeaderBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- if (version == 1) {
- buf->write_8bytes(creation_time);
- buf->write_8bytes(modification_time);
- buf->write_4bytes(timescale);
- buf->write_8bytes(duration_in_tbn);
+ if (version_ == 1) {
+ buf->write_8bytes(creation_time_);
+ buf->write_8bytes(modification_time_);
+ buf->write_4bytes(timescale_);
+ buf->write_8bytes(duration_in_tbn_);
} else {
- buf->write_4bytes((uint32_t)creation_time);
- buf->write_4bytes((uint32_t)modification_time);
- buf->write_4bytes(timescale);
- buf->write_4bytes((uint32_t)duration_in_tbn);
+ buf->write_4bytes((uint32_t)creation_time_);
+ buf->write_4bytes((uint32_t)modification_time_);
+ buf->write_4bytes(timescale_);
+ buf->write_4bytes((uint32_t)duration_in_tbn_);
}
- buf->write_4bytes(rate);
- buf->write_2bytes(volume);
- buf->write_2bytes(reserved0);
- buf->write_8bytes(reserved1);
+ buf->write_4bytes(rate_);
+ buf->write_2bytes(volume_);
+ buf->write_2bytes(reserved0_);
+ buf->write_8bytes(reserved1_);
for (int i = 0; i < 9; i++) {
- buf->write_4bytes(matrix[i]);
+ buf->write_4bytes(matrix_[i]);
}
for (int i = 0; i < 6; i++) {
- buf->write_4bytes(pre_defined[i]);
+ buf->write_4bytes(pre_defined_[i]);
}
- buf->write_4bytes(next_track_ID);
+ buf->write_4bytes(next_track_ID_);
return err;
}
@@ -1691,27 +1691,27 @@ srs_error_t SrsMp4MovieHeaderBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- if (version == 1) {
- creation_time = buf->read_8bytes();
- modification_time = buf->read_8bytes();
- timescale = buf->read_4bytes();
- duration_in_tbn = buf->read_8bytes();
+ if (version_ == 1) {
+ creation_time_ = buf->read_8bytes();
+ modification_time_ = buf->read_8bytes();
+ timescale_ = buf->read_4bytes();
+ duration_in_tbn_ = buf->read_8bytes();
} else {
- creation_time = buf->read_4bytes();
- modification_time = buf->read_4bytes();
- timescale = buf->read_4bytes();
- duration_in_tbn = buf->read_4bytes();
+ creation_time_ = buf->read_4bytes();
+ modification_time_ = buf->read_4bytes();
+ timescale_ = buf->read_4bytes();
+ duration_in_tbn_ = buf->read_4bytes();
}
- rate = buf->read_4bytes();
- volume = buf->read_2bytes();
+ rate_ = buf->read_4bytes();
+ volume_ = buf->read_2bytes();
buf->skip(2);
buf->skip(8);
for (int i = 0; i < 9; i++) {
- matrix[i] = buf->read_4bytes();
+ matrix_[i] = buf->read_4bytes();
}
buf->skip(24);
- next_track_ID = buf->read_4bytes();
+ next_track_ID_ = buf->read_4bytes();
return err;
}
@@ -1720,13 +1720,13 @@ stringstream &SrsMp4MovieHeaderBox::dumps_detail(stringstream &ss, SrsMp4DumpCon
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", " << std::setprecision(2) << duration() << "ms, TBN=" << timescale << ", nTID=" << next_track_ID;
+ ss << ", " << std::setprecision(2) << duration() << "ms, TBN=" << timescale_ << ", nTID=" << next_track_ID_;
return ss;
}
SrsMp4MovieExtendsBox::SrsMp4MovieExtendsBox()
{
- type = SrsMp4BoxTypeMVEX;
+ type_ = SrsMp4BoxTypeMVEX;
}
SrsMp4MovieExtendsBox::~SrsMp4MovieExtendsBox()
@@ -1735,14 +1735,14 @@ SrsMp4MovieExtendsBox::~SrsMp4MovieExtendsBox()
void SrsMp4MovieExtendsBox::add_trex(SrsMp4TrackExtendsBox *v)
{
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4TrackExtendsBox::SrsMp4TrackExtendsBox()
{
- type = SrsMp4BoxTypeTREX;
- track_ID = default_sample_size = default_sample_flags = 0;
- default_sample_size = default_sample_duration = default_sample_description_index = 0;
+ type_ = SrsMp4BoxTypeTREX;
+ track_ID_ = default_sample_size_ = default_sample_flags_ = 0;
+ default_sample_size_ = default_sample_duration_ = default_sample_description_index_ = 0;
}
SrsMp4TrackExtendsBox::~SrsMp4TrackExtendsBox()
@@ -1762,11 +1762,11 @@ srs_error_t SrsMp4TrackExtendsBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes(track_ID);
- buf->write_4bytes(default_sample_description_index);
- buf->write_4bytes(default_sample_duration);
- buf->write_4bytes(default_sample_size);
- buf->write_4bytes(default_sample_flags);
+ buf->write_4bytes(track_ID_);
+ buf->write_4bytes(default_sample_description_index_);
+ buf->write_4bytes(default_sample_duration_);
+ buf->write_4bytes(default_sample_size_);
+ buf->write_4bytes(default_sample_flags_);
return err;
}
@@ -1779,11 +1779,11 @@ srs_error_t SrsMp4TrackExtendsBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- track_ID = buf->read_4bytes();
- default_sample_description_index = buf->read_4bytes();
- default_sample_duration = buf->read_4bytes();
- default_sample_size = buf->read_4bytes();
- default_sample_flags = buf->read_4bytes();
+ track_ID_ = buf->read_4bytes();
+ default_sample_description_index_ = buf->read_4bytes();
+ default_sample_duration_ = buf->read_4bytes();
+ default_sample_size_ = buf->read_4bytes();
+ default_sample_flags_ = buf->read_4bytes();
return err;
}
@@ -1792,15 +1792,15 @@ stringstream &SrsMp4TrackExtendsBox::dumps_detail(stringstream &ss, SrsMp4DumpCo
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", track=#" << track_ID << ", default-sample("
- << "index:" << default_sample_description_index << ", size:" << default_sample_size
- << ", duration:" << default_sample_duration << ", flags:" << default_sample_flags << ")";
+ ss << ", track=#" << track_ID_ << ", default-sample("
+ << "index:" << default_sample_description_index_ << ", size:" << default_sample_size_
+ << ", duration:" << default_sample_duration_ << ", flags:" << default_sample_flags_ << ")";
return ss;
}
SrsMp4TrackBox::SrsMp4TrackBox()
{
- type = SrsMp4BoxTypeTRAK;
+ type_ = SrsMp4BoxTypeTRAK;
}
SrsMp4TrackBox::~SrsMp4TrackBox()
@@ -1826,13 +1826,13 @@ SrsMp4TrackHeaderBox *SrsMp4TrackBox::tkhd()
void SrsMp4TrackBox::set_tkhd(SrsMp4TrackHeaderBox *v)
{
remove(SrsMp4BoxTypeTKHD);
- boxes.insert(boxes.begin(), v);
+ boxes_.insert(boxes_.begin(), v);
}
void SrsMp4TrackBox::set_edts(SrsMp4EditBox *v)
{
remove(SrsMp4BoxTypeEDTS);
- boxes.insert(boxes.begin(), v);
+ boxes_.insert(boxes_.begin(), v);
}
SrsMp4ChunkOffsetBox *SrsMp4TrackBox::stco()
@@ -1889,7 +1889,7 @@ SrsVideoCodecId SrsMp4TrackBox::vide_codec()
}
SrsMp4SampleEntry *entry = box->entrie_at(0);
- switch (entry->type) {
+ switch (entry->type_) {
case SrsMp4BoxTypeAVC1:
return SrsVideoCodecIdAVC;
default:
@@ -1909,7 +1909,7 @@ SrsAudioCodecId SrsMp4TrackBox::soun_codec()
}
SrsMp4EsdsBox *esds_box = mp4a()->esds();
- switch (esds_box->es->decConfigDescr.objectTypeIndication) {
+ switch (esds_box->es->decConfigDescr_.objectTypeIndication) {
case SrsMp4ObjectTypeAac:
return SrsAudioCodecIdAAC;
case SrsMp4ObjectTypeMp3:
@@ -1941,7 +1941,7 @@ SrsMp4MediaBox *SrsMp4TrackBox::mdia()
void SrsMp4TrackBox::set_mdia(SrsMp4MediaBox *v)
{
remove(SrsMp4BoxTypeMDIA);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4MediaInformationBox *SrsMp4TrackBox::minf()
@@ -1974,21 +1974,21 @@ SrsMp4AudioSampleEntry *SrsMp4TrackBox::mp4a()
return box ? box->mp4a() : NULL;
}
-SrsMp4TrackHeaderBox::SrsMp4TrackHeaderBox() : creation_time(0), modification_time(0), track_ID(0), duration(0)
+SrsMp4TrackHeaderBox::SrsMp4TrackHeaderBox() : creation_time_(0), modification_time_(0), track_ID_(0), duration_(0)
{
- type = SrsMp4BoxTypeTKHD;
+ type_ = SrsMp4BoxTypeTKHD;
- reserved0 = 0;
- reserved1 = 0;
- reserved2 = 0;
- layer = alternate_group = 0;
- volume = 0; // if track_is_audio 0x0100 else 0
+ reserved0_ = 0;
+ reserved1_ = 0;
+ reserved2_ = 0;
+ layer_ = alternate_group_ = 0;
+ volume_ = 0; // if track_is_audio 0x0100 else 0
int32_t v[] = {0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000};
- memcpy(matrix, v, 36);
+ memcpy(matrix_, v, 36);
- width = height = 0;
- flags = 0x03;
+ width_ = height_ = 0;
+ flags_ = 0x03;
}
SrsMp4TrackHeaderBox::~SrsMp4TrackHeaderBox()
@@ -1999,7 +1999,7 @@ int SrsMp4TrackHeaderBox::nb_header()
{
int size = SrsMp4FullBox::nb_header();
- if (version == 1) {
+ if (version_ == 1) {
size += 8 + 8 + 4 + 4 + 8;
} else {
size += 4 + 4 + 4 + 4 + 4;
@@ -2018,30 +2018,30 @@ srs_error_t SrsMp4TrackHeaderBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- if (version == 1) {
- buf->write_8bytes(creation_time);
- buf->write_8bytes(modification_time);
- buf->write_4bytes(track_ID);
- buf->write_4bytes(reserved0);
- buf->write_8bytes(duration);
+ if (version_ == 1) {
+ buf->write_8bytes(creation_time_);
+ buf->write_8bytes(modification_time_);
+ buf->write_4bytes(track_ID_);
+ buf->write_4bytes(reserved0_);
+ buf->write_8bytes(duration_);
} else {
- buf->write_4bytes((uint32_t)creation_time);
- buf->write_4bytes((uint32_t)modification_time);
- buf->write_4bytes(track_ID);
- buf->write_4bytes(reserved0);
- buf->write_4bytes((uint32_t)duration);
+ buf->write_4bytes((uint32_t)creation_time_);
+ buf->write_4bytes((uint32_t)modification_time_);
+ buf->write_4bytes(track_ID_);
+ buf->write_4bytes(reserved0_);
+ buf->write_4bytes((uint32_t)duration_);
}
- buf->write_8bytes(reserved1);
- buf->write_2bytes(layer);
- buf->write_2bytes(alternate_group);
- buf->write_2bytes(volume);
- buf->write_2bytes(reserved2);
+ buf->write_8bytes(reserved1_);
+ buf->write_2bytes(layer_);
+ buf->write_2bytes(alternate_group_);
+ buf->write_2bytes(volume_);
+ buf->write_2bytes(reserved2_);
for (int i = 0; i < 9; i++) {
- buf->write_4bytes(matrix[i]);
+ buf->write_4bytes(matrix_[i]);
}
- buf->write_4bytes(width);
- buf->write_4bytes(height);
+ buf->write_4bytes(width_);
+ buf->write_4bytes(height_);
return err;
}
@@ -2054,30 +2054,30 @@ srs_error_t SrsMp4TrackHeaderBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- if (version == 1) {
- creation_time = buf->read_8bytes();
- modification_time = buf->read_8bytes();
- track_ID = buf->read_4bytes();
+ if (version_ == 1) {
+ creation_time_ = buf->read_8bytes();
+ modification_time_ = buf->read_8bytes();
+ track_ID_ = buf->read_4bytes();
buf->skip(4);
- duration = buf->read_8bytes();
+ duration_ = buf->read_8bytes();
} else {
- creation_time = buf->read_4bytes();
- modification_time = buf->read_4bytes();
- track_ID = buf->read_4bytes();
+ creation_time_ = buf->read_4bytes();
+ modification_time_ = buf->read_4bytes();
+ track_ID_ = buf->read_4bytes();
buf->skip(4);
- duration = buf->read_4bytes();
+ duration_ = buf->read_4bytes();
}
buf->skip(8);
- layer = buf->read_2bytes();
- alternate_group = buf->read_2bytes();
- volume = buf->read_2bytes();
+ layer_ = buf->read_2bytes();
+ alternate_group_ = buf->read_2bytes();
+ volume_ = buf->read_2bytes();
buf->skip(2);
for (int i = 0; i < 9; i++) {
- matrix[i] = buf->read_4bytes();
+ matrix_[i] = buf->read_4bytes();
}
- width = buf->read_4bytes();
- height = buf->read_4bytes();
+ width_ = buf->read_4bytes();
+ height_ = buf->read_4bytes();
return err;
}
@@ -2086,20 +2086,20 @@ stringstream &SrsMp4TrackHeaderBox::dumps_detail(stringstream &ss, SrsMp4DumpCon
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", track #" << track_ID << ", " << duration << "TBN";
+ ss << ", track #" << track_ID_ << ", " << duration_ << "TBN";
- if (volume) {
- ss << ", volume=" << uint32_t(volume >> 8) << "." << uint32_t(volume & 0xFF);
+ if (volume_) {
+ ss << ", volume=" << uint32_t(volume_ >> 8) << "." << uint32_t(volume_ & 0xFF);
}
- ss << ", size=" << uint16_t(width >> 16) << "x" << uint16_t(height >> 16);
+ ss << ", size=" << uint16_t(width_ >> 16) << "x" << uint16_t(height_ >> 16);
return ss;
}
SrsMp4EditBox::SrsMp4EditBox()
{
- type = SrsMp4BoxTypeEDTS;
+ type_ = SrsMp4BoxTypeEDTS;
}
SrsMp4EditBox::~SrsMp4EditBox()
@@ -2109,12 +2109,12 @@ SrsMp4EditBox::~SrsMp4EditBox()
void SrsMp4EditBox::set_elst(SrsMp4EditListBox *v)
{
remove(SrsMp4BoxTypeELST);
- boxes.insert(boxes.begin(), v);
+ boxes_.insert(boxes_.begin(), v);
}
-SrsMp4ElstEntry::SrsMp4ElstEntry() : segment_duration(0), media_time(0), media_rate_integer(0)
+SrsMp4ElstEntry::SrsMp4ElstEntry() : segment_duration_(0), media_time_(0), media_rate_integer_(0)
{
- media_rate_fraction = 0;
+ media_rate_fraction_ = 0;
}
SrsMp4ElstEntry::~SrsMp4ElstEntry()
@@ -2128,14 +2128,14 @@ stringstream &SrsMp4ElstEntry::dumps(stringstream &ss, SrsMp4DumpContext dc)
stringstream &SrsMp4ElstEntry::dumps_detail(stringstream &ss, SrsMp4DumpContext dc)
{
- ss << "Entry, " << segment_duration << "TBN, start=" << media_time << "TBN"
- << ", rate=" << media_rate_integer << "," << media_rate_fraction;
+ ss << "Entry, " << segment_duration_ << "TBN, start=" << media_time_ << "TBN"
+ << ", rate=" << media_rate_integer_ << "," << media_rate_fraction_;
return ss;
}
SrsMp4EditListBox::SrsMp4EditListBox()
{
- type = SrsMp4BoxTypeELST;
+ type_ = SrsMp4BoxTypeELST;
}
SrsMp4EditListBox::~SrsMp4EditListBox()
@@ -2146,10 +2146,10 @@ int SrsMp4EditListBox::nb_header()
{
int size = SrsMp4FullBox::nb_header() + 4;
- if (version == 1) {
- size += entries.size() * (2 + 2 + 8 + 8);
+ if (version_ == 1) {
+ size += entries_.size() * (2 + 2 + 8 + 8);
} else {
- size += entries.size() * (2 + 2 + 4 + 4);
+ size += entries_.size() * (2 + 2 + 4 + 4);
}
return size;
@@ -2163,20 +2163,20 @@ srs_error_t SrsMp4EditListBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes((int)entries.size());
- for (size_t i = 0; i < (size_t)entries.size(); i++) {
- SrsMp4ElstEntry &entry = entries[i];
+ buf->write_4bytes((int)entries_.size());
+ for (size_t i = 0; i < (size_t)entries_.size(); i++) {
+ SrsMp4ElstEntry &entry = entries_[i];
- if (version == 1) {
- buf->write_8bytes(entry.segment_duration);
- buf->write_8bytes(entry.media_time);
+ if (version_ == 1) {
+ buf->write_8bytes(entry.segment_duration_);
+ buf->write_8bytes(entry.media_time_);
} else {
- buf->write_4bytes((uint32_t)entry.segment_duration);
- buf->write_4bytes((int32_t)entry.media_time);
+ buf->write_4bytes((uint32_t)entry.segment_duration_);
+ buf->write_4bytes((int32_t)entry.media_time_);
}
- buf->write_2bytes(entry.media_rate_integer);
- buf->write_2bytes(entry.media_rate_fraction);
+ buf->write_2bytes(entry.media_rate_integer_);
+ buf->write_2bytes(entry.media_rate_fraction_);
}
return err;
@@ -2192,30 +2192,30 @@ srs_error_t SrsMp4EditListBox::decode_header(SrsBuffer *buf)
uint32_t entry_count = buf->read_4bytes();
if (entry_count > 0) {
- entries.resize(entry_count);
+ entries_.resize(entry_count);
}
for (int i = 0; i < (int)entry_count; i++) {
- SrsMp4ElstEntry &entry = entries[i];
+ SrsMp4ElstEntry &entry = entries_[i];
- if (version == 1) {
+ if (version_ == 1) {
if (!buf->require(16)) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "no space");
}
- entry.segment_duration = buf->read_8bytes();
- entry.media_time = buf->read_8bytes();
+ entry.segment_duration_ = buf->read_8bytes();
+ entry.media_time_ = buf->read_8bytes();
} else {
if (!buf->require(8)) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "no space");
}
- entry.segment_duration = buf->read_4bytes();
- entry.media_time = buf->read_4bytes();
+ entry.segment_duration_ = buf->read_4bytes();
+ entry.media_time_ = buf->read_4bytes();
}
if (!buf->require(4)) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "no space");
}
- entry.media_rate_integer = buf->read_2bytes();
- entry.media_rate_fraction = buf->read_2bytes();
+ entry.media_rate_integer_ = buf->read_2bytes();
+ entry.media_rate_fraction_ = buf->read_2bytes();
}
return err;
@@ -2225,12 +2225,12 @@ stringstream &SrsMp4EditListBox::dumps_detail(stringstream &ss, SrsMp4DumpContex
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", " << entries.size() << " childs";
+ ss << ", " << entries_.size() << " childs";
- if (!entries.empty()) {
+ if (!entries_.empty()) {
ss << "(+)" << endl;
srs_mp4_padding(ss, dc.indent());
- srs_dumps_array(entries, ss, dc.indent(), srs_mp4_pfn_detail, srs_mp4_delimiter_newline);
+ srs_dumps_array(entries_, ss, dc.indent(), srs_mp4_pfn_detail, srs_mp4_delimiter_newline);
}
return ss;
@@ -2238,7 +2238,7 @@ stringstream &SrsMp4EditListBox::dumps_detail(stringstream &ss, SrsMp4DumpContex
SrsMp4MediaBox::SrsMp4MediaBox()
{
- type = SrsMp4BoxTypeMDIA;
+ type_ = SrsMp4BoxTypeMDIA;
}
SrsMp4MediaBox::~SrsMp4MediaBox()
@@ -2253,9 +2253,9 @@ SrsMp4TrackType SrsMp4MediaBox::track_type()
}
SrsMp4HandlerReferenceBox *hdlr = dynamic_cast(box);
- if (hdlr->handler_type == SrsMp4HandlerTypeSOUN) {
+ if (hdlr->handler_type_ == SrsMp4HandlerTypeSOUN) {
return SrsMp4TrackTypeAudio;
- } else if (hdlr->handler_type == SrsMp4HandlerTypeVIDE) {
+ } else if (hdlr->handler_type_ == SrsMp4HandlerTypeVIDE) {
return SrsMp4TrackTypeVideo;
} else {
return SrsMp4TrackTypeForbidden;
@@ -2271,7 +2271,7 @@ SrsMp4MediaHeaderBox *SrsMp4MediaBox::mdhd()
void SrsMp4MediaBox::set_mdhd(SrsMp4MediaHeaderBox *v)
{
remove(SrsMp4BoxTypeMDHD);
- boxes.insert(boxes.begin(), v);
+ boxes_.insert(boxes_.begin(), v);
}
SrsMp4HandlerReferenceBox *SrsMp4MediaBox::hdlr()
@@ -2283,7 +2283,7 @@ SrsMp4HandlerReferenceBox *SrsMp4MediaBox::hdlr()
void SrsMp4MediaBox::set_hdlr(SrsMp4HandlerReferenceBox *v)
{
remove(SrsMp4BoxTypeHDLR);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4MediaInformationBox *SrsMp4MediaBox::minf()
@@ -2295,14 +2295,14 @@ SrsMp4MediaInformationBox *SrsMp4MediaBox::minf()
void SrsMp4MediaBox::set_minf(SrsMp4MediaInformationBox *v)
{
remove(SrsMp4BoxTypeMINF);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
-SrsMp4MediaHeaderBox::SrsMp4MediaHeaderBox() : creation_time(0), modification_time(0), timescale(0), duration(0)
+SrsMp4MediaHeaderBox::SrsMp4MediaHeaderBox() : creation_time_(0), modification_time_(0), timescale_(0), duration_(0)
{
- type = SrsMp4BoxTypeMDHD;
- language = 0;
- pre_defined = 0;
+ type_ = SrsMp4BoxTypeMDHD;
+ language_ = 0;
+ pre_defined_ = 0;
}
SrsMp4MediaHeaderBox::~SrsMp4MediaHeaderBox()
@@ -2311,39 +2311,39 @@ SrsMp4MediaHeaderBox::~SrsMp4MediaHeaderBox()
char SrsMp4MediaHeaderBox::language0()
{
- return (char)(((language >> 10) & 0x1f) + 0x60);
+ return (char)(((language_ >> 10) & 0x1f) + 0x60);
}
void SrsMp4MediaHeaderBox::set_language0(char v)
{
- language |= uint16_t((uint8_t(v) - 0x60) & 0x1f) << 10;
+ language_ |= uint16_t((uint8_t(v) - 0x60) & 0x1f) << 10;
}
char SrsMp4MediaHeaderBox::language1()
{
- return (char)(((language >> 5) & 0x1f) + 0x60);
+ return (char)(((language_ >> 5) & 0x1f) + 0x60);
}
void SrsMp4MediaHeaderBox::set_language1(char v)
{
- language |= uint16_t((uint8_t(v) - 0x60) & 0x1f) << 5;
+ language_ |= uint16_t((uint8_t(v) - 0x60) & 0x1f) << 5;
}
char SrsMp4MediaHeaderBox::language2()
{
- return (char)((language & 0x1f) + 0x60);
+ return (char)((language_ & 0x1f) + 0x60);
}
void SrsMp4MediaHeaderBox::set_language2(char v)
{
- language |= uint16_t((uint8_t(v) - 0x60) & 0x1f);
+ language_ |= uint16_t((uint8_t(v) - 0x60) & 0x1f);
}
int SrsMp4MediaHeaderBox::nb_header()
{
int size = SrsMp4FullBox::nb_header();
- if (version == 1) {
+ if (version_ == 1) {
size += 8 + 8 + 4 + 8;
} else {
size += 4 + 4 + 4 + 4;
@@ -2362,20 +2362,20 @@ srs_error_t SrsMp4MediaHeaderBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- if (version == 1) {
- buf->write_8bytes(creation_time);
- buf->write_8bytes(modification_time);
- buf->write_4bytes(timescale);
- buf->write_8bytes(duration);
+ if (version_ == 1) {
+ buf->write_8bytes(creation_time_);
+ buf->write_8bytes(modification_time_);
+ buf->write_4bytes(timescale_);
+ buf->write_8bytes(duration_);
} else {
- buf->write_4bytes((uint32_t)creation_time);
- buf->write_4bytes((uint32_t)modification_time);
- buf->write_4bytes(timescale);
- buf->write_4bytes((uint32_t)duration);
+ buf->write_4bytes((uint32_t)creation_time_);
+ buf->write_4bytes((uint32_t)modification_time_);
+ buf->write_4bytes(timescale_);
+ buf->write_4bytes((uint32_t)duration_);
}
- buf->write_2bytes(language);
- buf->write_2bytes(pre_defined);
+ buf->write_2bytes(language_);
+ buf->write_2bytes(pre_defined_);
return err;
}
@@ -2388,19 +2388,19 @@ srs_error_t SrsMp4MediaHeaderBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- if (version == 1) {
- creation_time = buf->read_8bytes();
- modification_time = buf->read_8bytes();
- timescale = buf->read_4bytes();
- duration = buf->read_8bytes();
+ if (version_ == 1) {
+ creation_time_ = buf->read_8bytes();
+ modification_time_ = buf->read_8bytes();
+ timescale_ = buf->read_4bytes();
+ duration_ = buf->read_8bytes();
} else {
- creation_time = buf->read_4bytes();
- modification_time = buf->read_4bytes();
- timescale = buf->read_4bytes();
- duration = buf->read_4bytes();
+ creation_time_ = buf->read_4bytes();
+ modification_time_ = buf->read_4bytes();
+ timescale_ = buf->read_4bytes();
+ duration_ = buf->read_4bytes();
}
- language = buf->read_2bytes();
+ language_ = buf->read_2bytes();
buf->skip(2);
return err;
@@ -2410,8 +2410,8 @@ stringstream &SrsMp4MediaHeaderBox::dumps_detail(stringstream &ss, SrsMp4DumpCon
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", TBN=" << timescale << ", " << duration << "TBN";
- if (language) {
+ ss << ", TBN=" << timescale_ << ", " << duration_ << "TBN";
+ if (language_) {
ss << ", LANG=" << language0() << language1() << language2();
}
return ss;
@@ -2419,12 +2419,12 @@ stringstream &SrsMp4MediaHeaderBox::dumps_detail(stringstream &ss, SrsMp4DumpCon
SrsMp4HandlerReferenceBox::SrsMp4HandlerReferenceBox()
{
- type = SrsMp4BoxTypeHDLR;
+ type_ = SrsMp4BoxTypeHDLR;
- pre_defined = 0;
- memset(reserved, 0, 12);
+ pre_defined_ = 0;
+ memset(reserved_, 0, 12);
- handler_type = SrsMp4HandlerTypeForbidden;
+ handler_type_ = SrsMp4HandlerTypeForbidden;
}
SrsMp4HandlerReferenceBox::~SrsMp4HandlerReferenceBox()
@@ -2433,17 +2433,17 @@ SrsMp4HandlerReferenceBox::~SrsMp4HandlerReferenceBox()
bool SrsMp4HandlerReferenceBox::is_video()
{
- return handler_type == SrsMp4HandlerTypeVIDE;
+ return handler_type_ == SrsMp4HandlerTypeVIDE;
}
bool SrsMp4HandlerReferenceBox::is_audio()
{
- return handler_type == SrsMp4HandlerTypeSOUN;
+ return handler_type_ == SrsMp4HandlerTypeSOUN;
}
int SrsMp4HandlerReferenceBox::nb_header()
{
- return SrsMp4FullBox::nb_header() + 4 + 4 + 12 + srs_mp4_string_length(name);
+ return SrsMp4FullBox::nb_header() + 4 + 4 + 12 + srs_mp4_string_length(name_);
}
srs_error_t SrsMp4HandlerReferenceBox::encode_header(SrsBuffer *buf)
@@ -2454,12 +2454,12 @@ srs_error_t SrsMp4HandlerReferenceBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes(pre_defined);
- buf->write_4bytes(handler_type);
- buf->write_4bytes(reserved[0]);
- buf->write_4bytes(reserved[1]);
- buf->write_4bytes(reserved[2]);
- srs_mp4_string_write(buf, name);
+ buf->write_4bytes(pre_defined_);
+ buf->write_4bytes(handler_type_);
+ buf->write_4bytes(reserved_[0]);
+ buf->write_4bytes(reserved_[1]);
+ buf->write_4bytes(reserved_[2]);
+ srs_mp4_string_write(buf, name_);
return err;
}
@@ -2473,10 +2473,10 @@ srs_error_t SrsMp4HandlerReferenceBox::decode_header(SrsBuffer *buf)
}
buf->skip(4);
- handler_type = (SrsMp4HandlerType)buf->read_4bytes();
+ handler_type_ = (SrsMp4HandlerType)buf->read_4bytes();
buf->skip(12);
- if ((err = srs_mp4_string_read(buf, name, left_space(buf))) != srs_success) {
+ if ((err = srs_mp4_string_read(buf, name_, left_space(buf))) != srs_success) {
return srs_error_wrap(err, "hdlr read string");
}
@@ -2488,9 +2488,9 @@ stringstream &SrsMp4HandlerReferenceBox::dumps_detail(stringstream &ss, SrsMp4Du
SrsMp4FullBox::dumps_detail(ss, dc);
ss << ", ";
- srs_print_mp4_type(ss, (uint32_t)handler_type);
- if (!name.empty()) {
- ss << ", " << name;
+ srs_print_mp4_type(ss, (uint32_t)handler_type_);
+ if (!name_.empty()) {
+ ss << ", " << name_;
}
return ss;
@@ -2498,7 +2498,7 @@ stringstream &SrsMp4HandlerReferenceBox::dumps_detail(stringstream &ss, SrsMp4Du
SrsMp4MediaInformationBox::SrsMp4MediaInformationBox()
{
- type = SrsMp4BoxTypeMINF;
+ type_ = SrsMp4BoxTypeMINF;
}
SrsMp4MediaInformationBox::~SrsMp4MediaInformationBox()
@@ -2514,7 +2514,7 @@ SrsMp4VideoMeidaHeaderBox *SrsMp4MediaInformationBox::vmhd()
void SrsMp4MediaInformationBox::set_vmhd(SrsMp4VideoMeidaHeaderBox *v)
{
remove(SrsMp4BoxTypeVMHD);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4SoundMeidaHeaderBox *SrsMp4MediaInformationBox::smhd()
@@ -2526,7 +2526,7 @@ SrsMp4SoundMeidaHeaderBox *SrsMp4MediaInformationBox::smhd()
void SrsMp4MediaInformationBox::set_smhd(SrsMp4SoundMeidaHeaderBox *v)
{
remove(SrsMp4BoxTypeSMHD);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4DataInformationBox *SrsMp4MediaInformationBox::dinf()
@@ -2538,7 +2538,7 @@ SrsMp4DataInformationBox *SrsMp4MediaInformationBox::dinf()
void SrsMp4MediaInformationBox::set_dinf(SrsMp4DataInformationBox *v)
{
remove(SrsMp4BoxTypeDINF);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4SampleTableBox *SrsMp4MediaInformationBox::stbl()
@@ -2550,17 +2550,17 @@ SrsMp4SampleTableBox *SrsMp4MediaInformationBox::stbl()
void SrsMp4MediaInformationBox::set_stbl(SrsMp4SampleTableBox *v)
{
remove(SrsMp4BoxTypeSTBL);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4VideoMeidaHeaderBox::SrsMp4VideoMeidaHeaderBox()
{
- type = SrsMp4BoxTypeVMHD;
- version = 0;
- flags = 1;
+ type_ = SrsMp4BoxTypeVMHD;
+ version_ = 0;
+ flags_ = 1;
- graphicsmode = 0;
- memset(opcolor, 0, 6);
+ graphicsmode_ = 0;
+ memset(opcolor_, 0, 6);
}
SrsMp4VideoMeidaHeaderBox::~SrsMp4VideoMeidaHeaderBox()
@@ -2580,10 +2580,10 @@ srs_error_t SrsMp4VideoMeidaHeaderBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_2bytes(graphicsmode);
- buf->write_2bytes(opcolor[0]);
- buf->write_2bytes(opcolor[1]);
- buf->write_2bytes(opcolor[2]);
+ buf->write_2bytes(graphicsmode_);
+ buf->write_2bytes(opcolor_[0]);
+ buf->write_2bytes(opcolor_[1]);
+ buf->write_2bytes(opcolor_[2]);
return err;
}
@@ -2596,19 +2596,19 @@ srs_error_t SrsMp4VideoMeidaHeaderBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- graphicsmode = buf->read_2bytes();
- opcolor[0] = buf->read_2bytes();
- opcolor[1] = buf->read_2bytes();
- opcolor[2] = buf->read_2bytes();
+ graphicsmode_ = buf->read_2bytes();
+ opcolor_[0] = buf->read_2bytes();
+ opcolor_[1] = buf->read_2bytes();
+ opcolor_[2] = buf->read_2bytes();
return err;
}
SrsMp4SoundMeidaHeaderBox::SrsMp4SoundMeidaHeaderBox()
{
- type = SrsMp4BoxTypeSMHD;
+ type_ = SrsMp4BoxTypeSMHD;
- reserved = balance = 0;
+ reserved_ = balance_ = 0;
}
SrsMp4SoundMeidaHeaderBox::~SrsMp4SoundMeidaHeaderBox()
@@ -2628,8 +2628,8 @@ srs_error_t SrsMp4SoundMeidaHeaderBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_2bytes(balance);
- buf->write_2bytes(reserved);
+ buf->write_2bytes(balance_);
+ buf->write_2bytes(reserved_);
return err;
}
@@ -2642,7 +2642,7 @@ srs_error_t SrsMp4SoundMeidaHeaderBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- balance = buf->read_2bytes();
+ balance_ = buf->read_2bytes();
buf->skip(2);
return err;
@@ -2650,7 +2650,7 @@ srs_error_t SrsMp4SoundMeidaHeaderBox::decode_header(SrsBuffer *buf)
SrsMp4DataInformationBox::SrsMp4DataInformationBox()
{
- type = SrsMp4BoxTypeDINF;
+ type_ = SrsMp4BoxTypeDINF;
}
SrsMp4DataInformationBox::~SrsMp4DataInformationBox()
@@ -2666,7 +2666,7 @@ SrsMp4DataReferenceBox *SrsMp4DataInformationBox::dref()
void SrsMp4DataInformationBox::set_dref(SrsMp4DataReferenceBox *v)
{
remove(SrsMp4BoxTypeDREF);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4DataEntryBox::SrsMp4DataEntryBox()
@@ -2684,7 +2684,7 @@ bool SrsMp4DataEntryBox::boxes_in_header()
SrsMp4DataEntryUrlBox::SrsMp4DataEntryUrlBox()
{
- type = SrsMp4BoxTypeURL;
+ type_ = SrsMp4BoxTypeURL;
}
SrsMp4DataEntryUrlBox::~SrsMp4DataEntryUrlBox()
@@ -2693,7 +2693,7 @@ SrsMp4DataEntryUrlBox::~SrsMp4DataEntryUrlBox()
int SrsMp4DataEntryUrlBox::nb_header()
{
- return SrsMp4FullBox::nb_header() + srs_mp4_string_length(location);
+ return SrsMp4FullBox::nb_header() + srs_mp4_string_length(location_);
}
srs_error_t SrsMp4DataEntryUrlBox::encode_header(SrsBuffer *buf)
@@ -2702,15 +2702,15 @@ srs_error_t SrsMp4DataEntryUrlBox::encode_header(SrsBuffer *buf)
// 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 (location_.empty()) {
+ flags_ = 0x01;
}
if ((err = SrsMp4FullBox::encode_header(buf)) != srs_success) {
return srs_error_wrap(err, "encode header");
}
- srs_mp4_string_write(buf, location);
+ srs_mp4_string_write(buf, location_);
return err;
}
@@ -2723,7 +2723,7 @@ srs_error_t SrsMp4DataEntryUrlBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- if ((err = srs_mp4_string_read(buf, location, left_space(buf))) != srs_success) {
+ if ((err = srs_mp4_string_read(buf, location_, left_space(buf))) != srs_success) {
return srs_error_wrap(err, "url read location");
}
@@ -2734,8 +2734,8 @@ stringstream &SrsMp4DataEntryUrlBox::dumps_detail(stringstream &ss, SrsMp4DumpCo
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", URL: " << location;
- if (location.empty()) {
+ ss << ", URL: " << location_;
+ if (location_.empty()) {
ss << "Same file";
}
return ss;
@@ -2743,7 +2743,7 @@ stringstream &SrsMp4DataEntryUrlBox::dumps_detail(stringstream &ss, SrsMp4DumpCo
SrsMp4DataEntryUrnBox::SrsMp4DataEntryUrnBox()
{
- type = SrsMp4BoxTypeURN;
+ type_ = SrsMp4BoxTypeURN;
}
SrsMp4DataEntryUrnBox::~SrsMp4DataEntryUrnBox()
@@ -2752,7 +2752,7 @@ SrsMp4DataEntryUrnBox::~SrsMp4DataEntryUrnBox()
int SrsMp4DataEntryUrnBox::nb_header()
{
- return SrsMp4FullBox::nb_header() + srs_mp4_string_length(location) + srs_mp4_string_length(name);
+ return SrsMp4FullBox::nb_header() + srs_mp4_string_length(location_) + srs_mp4_string_length(name_);
}
srs_error_t SrsMp4DataEntryUrnBox::encode_header(SrsBuffer *buf)
@@ -2761,16 +2761,16 @@ srs_error_t SrsMp4DataEntryUrnBox::encode_header(SrsBuffer *buf)
// 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 (location_.empty()) {
+ flags_ = 0x01;
}
if ((err = SrsMp4DataEntryBox::encode_header(buf)) != srs_success) {
return srs_error_wrap(err, "encode entry");
}
- srs_mp4_string_write(buf, location);
- srs_mp4_string_write(buf, name);
+ srs_mp4_string_write(buf, location_);
+ srs_mp4_string_write(buf, name_);
return err;
}
@@ -2783,11 +2783,11 @@ srs_error_t SrsMp4DataEntryUrnBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode entry");
}
- if ((err = srs_mp4_string_read(buf, location, left_space(buf))) != srs_success) {
+ if ((err = srs_mp4_string_read(buf, location_, left_space(buf))) != srs_success) {
return srs_error_wrap(err, "urn read location");
}
- if ((err = srs_mp4_string_read(buf, name, left_space(buf))) != srs_success) {
+ if ((err = srs_mp4_string_read(buf, name_, left_space(buf))) != srs_success) {
return srs_error_wrap(err, "urn read name");
}
@@ -2798,12 +2798,12 @@ stringstream &SrsMp4DataEntryUrnBox::dumps_detail(stringstream &ss, SrsMp4DumpCo
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", URL: " << location;
- if (location.empty()) {
+ ss << ", URL: " << location_;
+ if (location_.empty()) {
ss << "Same file";
}
- if (!name.empty()) {
- ss << ", " << name;
+ if (!name_.empty()) {
+ ss << ", " << name_;
}
return ss;
@@ -2811,33 +2811,33 @@ stringstream &SrsMp4DataEntryUrnBox::dumps_detail(stringstream &ss, SrsMp4DumpCo
SrsMp4DataReferenceBox::SrsMp4DataReferenceBox()
{
- type = SrsMp4BoxTypeDREF;
+ type_ = SrsMp4BoxTypeDREF;
}
SrsMp4DataReferenceBox::~SrsMp4DataReferenceBox()
{
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); ++it) {
+ for (it = entries_.begin(); it != entries_.end(); ++it) {
SrsMp4DataEntryBox *entry = *it;
srs_freep(entry);
}
- entries.clear();
+ entries_.clear();
}
uint32_t SrsMp4DataReferenceBox::entry_count()
{
- return (uint32_t)entries.size();
+ return (uint32_t)entries_.size();
}
SrsMp4DataEntryBox *SrsMp4DataReferenceBox::entry_at(int index)
{
- return entries.at(index);
+ return entries_.at(index);
}
// Note that box must be SrsMp4DataEntryBox*
void SrsMp4DataReferenceBox::append(SrsMp4Box *box)
{
- entries.push_back((SrsMp4DataEntryBox *)box);
+ entries_.push_back((SrsMp4DataEntryBox *)box);
}
int SrsMp4DataReferenceBox::nb_header()
@@ -2847,7 +2847,7 @@ int SrsMp4DataReferenceBox::nb_header()
size += 4;
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); ++it) {
+ for (it = entries_.begin(); it != entries_.end(); ++it) {
SrsMp4DataEntryBox *entry = *it;
size += entry->nb_bytes();
}
@@ -2863,10 +2863,10 @@ srs_error_t SrsMp4DataReferenceBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes((int32_t)entries.size());
+ buf->write_4bytes((int32_t)entries_.size());
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); ++it) {
+ for (it = entries_.begin(); it != entries_.end(); ++it) {
SrsMp4DataEntryBox *entry = *it;
if ((err = entry->encode(buf)) != srs_success) {
return srs_error_wrap(err, "encode entry");
@@ -2897,14 +2897,14 @@ srs_error_t SrsMp4DataReferenceBox::decode_header(SrsBuffer *buf)
SrsMp4FullBox *fbox = dynamic_cast(box);
if (fbox) {
- fbox->version = version;
- fbox->flags = flags;
+ fbox->version_ = version_;
+ fbox->flags_ = flags_;
}
- if (box->type == SrsMp4BoxTypeURL) {
- entries.push_back(dynamic_cast(box));
- } else if (box->type == SrsMp4BoxTypeURN) {
- entries.push_back(dynamic_cast(box));
+ if (box->type_ == SrsMp4BoxTypeURL) {
+ entries_.push_back(dynamic_cast(box));
+ } else if (box->type_ == SrsMp4BoxTypeURN) {
+ entries_.push_back(dynamic_cast(box));
} else {
srs_freep(box);
}
@@ -2917,17 +2917,17 @@ stringstream &SrsMp4DataReferenceBox::dumps_detail(stringstream &ss, SrsMp4DumpC
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", " << entries.size() << " childs";
- if (!entries.empty()) {
+ ss << ", " << entries_.size() << " childs";
+ if (!entries_.empty()) {
ss << "(+)" << endl;
- srs_dumps_array(entries, ss, dc.indent(), srs_mp4_pfn_box2, srs_mp4_delimiter_newline);
+ srs_dumps_array(entries_, ss, dc.indent(), srs_mp4_pfn_box2, srs_mp4_delimiter_newline);
}
return ss;
}
SrsMp4SampleTableBox::SrsMp4SampleTableBox()
{
- type = SrsMp4BoxTypeSTBL;
+ type_ = SrsMp4BoxTypeSTBL;
}
SrsMp4SampleTableBox::~SrsMp4SampleTableBox()
@@ -2943,7 +2943,7 @@ SrsMp4SampleDescriptionBox *SrsMp4SampleTableBox::stsd()
void SrsMp4SampleTableBox::set_stsd(SrsMp4SampleDescriptionBox *v)
{
remove(SrsMp4BoxTypeSTSD);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4ChunkOffsetBox *SrsMp4SampleTableBox::stco()
@@ -2955,7 +2955,7 @@ SrsMp4ChunkOffsetBox *SrsMp4SampleTableBox::stco()
void SrsMp4SampleTableBox::set_stco(SrsMp4ChunkOffsetBox *v)
{
remove(SrsMp4BoxTypeSTCO);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4ChunkLargeOffsetBox *SrsMp4SampleTableBox::co64()
@@ -2967,7 +2967,7 @@ SrsMp4ChunkLargeOffsetBox *SrsMp4SampleTableBox::co64()
void SrsMp4SampleTableBox::set_co64(SrsMp4ChunkLargeOffsetBox *v)
{
remove(SrsMp4BoxTypeCO64);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4SampleSizeBox *SrsMp4SampleTableBox::stsz()
@@ -2979,7 +2979,7 @@ SrsMp4SampleSizeBox *SrsMp4SampleTableBox::stsz()
void SrsMp4SampleTableBox::set_stsz(SrsMp4SampleSizeBox *v)
{
remove(SrsMp4BoxTypeSTSZ);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4Sample2ChunkBox *SrsMp4SampleTableBox::stsc()
@@ -2991,7 +2991,7 @@ SrsMp4Sample2ChunkBox *SrsMp4SampleTableBox::stsc()
void SrsMp4SampleTableBox::set_stsc(SrsMp4Sample2ChunkBox *v)
{
remove(SrsMp4BoxTypeSTSC);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4DecodingTime2SampleBox *SrsMp4SampleTableBox::stts()
@@ -3003,7 +3003,7 @@ SrsMp4DecodingTime2SampleBox *SrsMp4SampleTableBox::stts()
void SrsMp4SampleTableBox::set_stts(SrsMp4DecodingTime2SampleBox *v)
{
remove(SrsMp4BoxTypeSTTS);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4CompositionTime2SampleBox *SrsMp4SampleTableBox::ctts()
@@ -3015,7 +3015,7 @@ SrsMp4CompositionTime2SampleBox *SrsMp4SampleTableBox::ctts()
void SrsMp4SampleTableBox::set_ctts(SrsMp4CompositionTime2SampleBox *v)
{
remove(SrsMp4BoxTypeCTTS);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4SyncSampleBox *SrsMp4SampleTableBox::stss()
@@ -3027,7 +3027,7 @@ SrsMp4SyncSampleBox *SrsMp4SampleTableBox::stss()
void SrsMp4SampleTableBox::set_stss(SrsMp4SyncSampleBox *v)
{
remove(SrsMp4BoxTypeSTSS);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
int SrsMp4SampleTableBox::nb_header()
@@ -3057,7 +3057,7 @@ srs_error_t SrsMp4SampleTableBox::decode_header(SrsBuffer *buf)
return err;
}
-SrsMp4SampleEntry::SrsMp4SampleEntry() : data_reference_index(0)
+SrsMp4SampleEntry::SrsMp4SampleEntry() : data_reference_index_(0)
{
memset(reserved, 0, 6);
}
@@ -3082,7 +3082,7 @@ srs_error_t SrsMp4SampleEntry::encode_header(SrsBuffer *buf)
for (int i = 0; i < 6; i++) {
buf->write_1bytes(reserved[i]);
}
- buf->write_2bytes(data_reference_index);
+ buf->write_2bytes(data_reference_index_);
return err;
}
@@ -3096,7 +3096,7 @@ srs_error_t SrsMp4SampleEntry::decode_header(SrsBuffer *buf)
}
buf->skip(6);
- data_reference_index = buf->read_2bytes();
+ data_reference_index_ = buf->read_2bytes();
return err;
}
@@ -3105,24 +3105,24 @@ stringstream &SrsMp4SampleEntry::dumps_detail(stringstream &ss, SrsMp4DumpContex
{
SrsMp4Box::dumps_detail(ss, dc);
- ss << ", refs#" << data_reference_index;
+ ss << ", refs#" << data_reference_index_;
return ss;
}
-SrsMp4VisualSampleEntry::SrsMp4VisualSampleEntry(SrsMp4BoxType boxType) : width(0), height(0)
+SrsMp4VisualSampleEntry::SrsMp4VisualSampleEntry(SrsMp4BoxType boxType) : width_(0), height_(0)
{
- type = boxType;
+ type_ = boxType;
- pre_defined0 = 0;
- reserved0 = 0;
- reserved1 = 0;
- memset(pre_defined1, 0, 12);
- memset(compressorname, 0, 32);
- frame_count = 1;
- horizresolution = 0x00480000; // 72 dpi
- vertresolution = 0x00480000; // 72 dpi
- depth = 0x0018;
- pre_defined2 = -1;
+ pre_defined0_ = 0;
+ reserved0_ = 0;
+ reserved1_ = 0;
+ memset(pre_defined1_, 0, 12);
+ memset(compressorname_, 0, 32);
+ frame_count_ = 1;
+ horizresolution_ = 0x00480000; // 72 dpi
+ vertresolution_ = 0x00480000; // 72 dpi
+ depth_ = 0x0018;
+ pre_defined2_ = -1;
}
SrsMp4VisualSampleEntry::~SrsMp4VisualSampleEntry()
@@ -3138,7 +3138,7 @@ SrsMp4AvccBox *SrsMp4VisualSampleEntry::avcC()
void SrsMp4VisualSampleEntry::set_avcC(SrsMp4AvccBox *v)
{
remove(SrsMp4BoxTypeAVCC);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4HvcCBox *SrsMp4VisualSampleEntry::hvcC()
@@ -3150,7 +3150,7 @@ SrsMp4HvcCBox *SrsMp4VisualSampleEntry::hvcC()
void SrsMp4VisualSampleEntry::set_hvcC(SrsMp4HvcCBox *v)
{
remove(SrsMp4BoxTypeHVCC);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
int SrsMp4VisualSampleEntry::nb_header()
@@ -3166,20 +3166,20 @@ srs_error_t SrsMp4VisualSampleEntry::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode entry");
}
- buf->write_2bytes(pre_defined0);
- buf->write_2bytes(reserved0);
- buf->write_4bytes(pre_defined1[0]);
- buf->write_4bytes(pre_defined1[1]);
- buf->write_4bytes(pre_defined1[2]);
- buf->write_2bytes(width);
- buf->write_2bytes(height);
- buf->write_4bytes(horizresolution);
- buf->write_4bytes(vertresolution);
- buf->write_4bytes(reserved1);
- buf->write_2bytes(frame_count);
- buf->write_bytes(compressorname, 32);
- buf->write_2bytes(depth);
- buf->write_2bytes(pre_defined2);
+ buf->write_2bytes(pre_defined0_);
+ buf->write_2bytes(reserved0_);
+ buf->write_4bytes(pre_defined1_[0]);
+ buf->write_4bytes(pre_defined1_[1]);
+ buf->write_4bytes(pre_defined1_[2]);
+ buf->write_2bytes(width_);
+ buf->write_2bytes(height_);
+ buf->write_4bytes(horizresolution_);
+ buf->write_4bytes(vertresolution_);
+ buf->write_4bytes(reserved1_);
+ buf->write_2bytes(frame_count_);
+ buf->write_bytes(compressorname_, 32);
+ buf->write_2bytes(depth_);
+ buf->write_2bytes(pre_defined2_);
return err;
}
@@ -3195,14 +3195,14 @@ srs_error_t SrsMp4VisualSampleEntry::decode_header(SrsBuffer *buf)
buf->skip(2);
buf->skip(2);
buf->skip(12);
- width = buf->read_2bytes();
- height = buf->read_2bytes();
- horizresolution = buf->read_4bytes();
- vertresolution = buf->read_4bytes();
+ width_ = buf->read_2bytes();
+ height_ = buf->read_2bytes();
+ horizresolution_ = buf->read_4bytes();
+ vertresolution_ = buf->read_4bytes();
buf->skip(4);
- frame_count = buf->read_2bytes();
- buf->read_bytes(compressorname, 32);
- depth = buf->read_2bytes();
+ frame_count_ = buf->read_2bytes();
+ buf->read_bytes(compressorname_, 32);
+ depth_ = buf->read_2bytes();
buf->skip(2);
return err;
@@ -3212,13 +3212,13 @@ stringstream &SrsMp4VisualSampleEntry::dumps_detail(stringstream &ss, SrsMp4Dump
{
SrsMp4SampleEntry::dumps_detail(ss, dc);
- ss << ", size=" << width << "x" << height;
+ ss << ", size=" << width_ << "x" << height_;
return ss;
}
SrsMp4AvccBox::SrsMp4AvccBox()
{
- type = SrsMp4BoxTypeAVCC;
+ type_ = SrsMp4BoxTypeAVCC;
}
SrsMp4AvccBox::~SrsMp4AvccBox()
@@ -3227,7 +3227,7 @@ SrsMp4AvccBox::~SrsMp4AvccBox()
int SrsMp4AvccBox::nb_header()
{
- return SrsMp4Box::nb_header() + (int)avc_config.size();
+ return SrsMp4Box::nb_header() + (int)avc_config_.size();
}
srs_error_t SrsMp4AvccBox::encode_header(SrsBuffer *buf)
@@ -3238,8 +3238,8 @@ srs_error_t SrsMp4AvccBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- if (!avc_config.empty()) {
- buf->write_bytes(&avc_config[0], (int)avc_config.size());
+ if (!avc_config_.empty()) {
+ buf->write_bytes(&avc_config_[0], (int)avc_config_.size());
}
return err;
@@ -3255,8 +3255,8 @@ srs_error_t SrsMp4AvccBox::decode_header(SrsBuffer *buf)
int nb_config = left_space(buf);
if (nb_config) {
- avc_config.resize(nb_config);
- buf->read_bytes(&avc_config[0], nb_config);
+ avc_config_.resize(nb_config);
+ buf->read_bytes(&avc_config_[0], nb_config);
}
return err;
@@ -3266,15 +3266,15 @@ stringstream &SrsMp4AvccBox::dumps_detail(stringstream &ss, SrsMp4DumpContext dc
{
SrsMp4Box::dumps_detail(ss, dc);
- ss << ", AVC Config: " << (int)avc_config.size() << "B" << endl;
+ ss << ", AVC Config: " << (int)avc_config_.size() << "B" << endl;
srs_mp4_padding(ss, dc.indent());
- srs_mp4_print_bytes(ss, (const char *)&avc_config[0], (int)avc_config.size(), dc.indent());
+ srs_mp4_print_bytes(ss, (const char *)&avc_config_[0], (int)avc_config_.size(), dc.indent());
return ss;
}
SrsMp4HvcCBox::SrsMp4HvcCBox()
{
- type = SrsMp4BoxTypeHVCC;
+ type_ = SrsMp4BoxTypeHVCC;
}
SrsMp4HvcCBox::~SrsMp4HvcCBox()
@@ -3283,7 +3283,7 @@ SrsMp4HvcCBox::~SrsMp4HvcCBox()
int SrsMp4HvcCBox::nb_header()
{
- return SrsMp4Box::nb_header() + (int)hevc_config.size();
+ return SrsMp4Box::nb_header() + (int)hevc_config_.size();
}
srs_error_t SrsMp4HvcCBox::encode_header(SrsBuffer *buf)
@@ -3294,8 +3294,8 @@ srs_error_t SrsMp4HvcCBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- if (!hevc_config.empty()) {
- buf->write_bytes(&hevc_config[0], (int)hevc_config.size());
+ if (!hevc_config_.empty()) {
+ buf->write_bytes(&hevc_config_[0], (int)hevc_config_.size());
}
return err;
@@ -3311,8 +3311,8 @@ srs_error_t SrsMp4HvcCBox::decode_header(SrsBuffer *buf)
int nb_config = left_space(buf);
if (nb_config) {
- hevc_config.resize(nb_config);
- buf->read_bytes(&hevc_config[0], nb_config);
+ hevc_config_.resize(nb_config);
+ buf->read_bytes(&hevc_config_[0], nb_config);
}
return err;
@@ -3322,21 +3322,21 @@ stringstream &SrsMp4HvcCBox::dumps_detail(stringstream &ss, SrsMp4DumpContext dc
{
SrsMp4Box::dumps_detail(ss, dc);
- ss << ", HEVC Config: " << (int)hevc_config.size() << "B" << endl;
+ ss << ", HEVC Config: " << (int)hevc_config_.size() << "B" << endl;
srs_mp4_padding(ss, dc.indent());
- srs_mp4_print_bytes(ss, (const char *)&hevc_config[0], (int)hevc_config.size(), dc.indent());
+ srs_mp4_print_bytes(ss, (const char *)&hevc_config_[0], (int)hevc_config_.size(), dc.indent());
return ss;
}
-SrsMp4AudioSampleEntry::SrsMp4AudioSampleEntry() : samplerate(0)
+SrsMp4AudioSampleEntry::SrsMp4AudioSampleEntry() : samplerate_(0)
{
- type = SrsMp4BoxTypeMP4A;
+ type_ = SrsMp4BoxTypeMP4A;
- reserved0 = 0;
- pre_defined0 = 0;
- reserved1 = 0;
- channelcount = 2;
- samplesize = 16;
+ reserved0_ = 0;
+ pre_defined0_ = 0;
+ reserved1_ = 0;
+ channelcount_ = 2;
+ samplesize_ = 16;
}
SrsMp4AudioSampleEntry::~SrsMp4AudioSampleEntry()
@@ -3352,7 +3352,7 @@ SrsMp4EsdsBox *SrsMp4AudioSampleEntry::esds()
void SrsMp4AudioSampleEntry::set_esds(SrsMp4EsdsBox *v)
{
remove(SrsMp4BoxTypeESDS);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4DecoderSpecificInfo *SrsMp4AudioSampleEntry::asc()
@@ -3374,12 +3374,12 @@ srs_error_t SrsMp4AudioSampleEntry::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode entry");
}
- buf->write_8bytes(reserved0);
- buf->write_2bytes(channelcount);
- buf->write_2bytes(samplesize);
- buf->write_2bytes(pre_defined0);
- buf->write_2bytes(reserved1);
- buf->write_4bytes(samplerate);
+ buf->write_8bytes(reserved0_);
+ buf->write_2bytes(channelcount_);
+ buf->write_2bytes(samplesize_);
+ buf->write_2bytes(pre_defined0_);
+ buf->write_2bytes(reserved1_);
+ buf->write_4bytes(samplerate_);
return err;
}
@@ -3393,11 +3393,11 @@ srs_error_t SrsMp4AudioSampleEntry::decode_header(SrsBuffer *buf)
}
buf->skip(8);
- channelcount = buf->read_2bytes();
- samplesize = buf->read_2bytes();
+ channelcount_ = buf->read_2bytes();
+ samplesize_ = buf->read_2bytes();
buf->skip(2);
buf->skip(2);
- samplerate = buf->read_4bytes();
+ samplerate_ = buf->read_4bytes();
return err;
}
@@ -3406,8 +3406,8 @@ stringstream &SrsMp4AudioSampleEntry::dumps_detail(stringstream &ss, SrsMp4DumpC
{
SrsMp4SampleEntry::dumps_detail(ss, dc);
- ss << ", " << channelcount << " channels, " << samplesize << " bits"
- << ", " << (samplerate >> 16) << " Hz";
+ ss << ", " << channelcount_ << " channels, " << samplesize_ << " bits"
+ << ", " << (samplerate_ >> 16) << " Hz";
return ss;
}
@@ -3538,15 +3538,15 @@ SrsMp4DecoderSpecificInfo::~SrsMp4DecoderSpecificInfo()
int32_t SrsMp4DecoderSpecificInfo::nb_payload()
{
- return (int)asc.size();
+ return (int)asc_.size();
}
srs_error_t SrsMp4DecoderSpecificInfo::encode_payload(SrsBuffer *buf)
{
srs_error_t err = srs_success;
- if (!asc.empty()) {
- buf->write_bytes(&asc[0], (int)asc.size());
+ if (!asc_.empty()) {
+ buf->write_bytes(&asc_[0], (int)asc_.size());
}
return err;
@@ -3558,8 +3558,8 @@ srs_error_t SrsMp4DecoderSpecificInfo::decode_payload(SrsBuffer *buf)
int nb_asc = vlen;
if (nb_asc) {
- asc.resize(nb_asc);
- buf->read_bytes(&asc[0], nb_asc);
+ asc_.resize(nb_asc);
+ buf->read_bytes(&asc_[0], nb_asc);
}
return err;
@@ -3569,30 +3569,30 @@ stringstream &SrsMp4DecoderSpecificInfo::dumps_detail(stringstream &ss, SrsMp4Du
{
SrsMp4BaseDescriptor::dumps_detail(ss, dc);
- ss << ", ASC " << asc.size() << "B";
+ ss << ", ASC " << asc_.size() << "B";
ss << endl;
srs_mp4_padding(ss, dc.indent());
- return srs_mp4_print_bytes(ss, (const char *)&asc[0], (int)asc.size(), dc.indent());
+ return srs_mp4_print_bytes(ss, (const char *)&asc_[0], (int)asc_.size(), dc.indent());
}
-SrsMp4DecoderConfigDescriptor::SrsMp4DecoderConfigDescriptor() : upStream(0), bufferSizeDB(0), maxBitrate(0), avgBitrate(0)
+SrsMp4DecoderConfigDescriptor::SrsMp4DecoderConfigDescriptor() : upStream(0), bufferSizeDB_(0), maxBitrate_(0), avgBitrate_(0)
{
tag = SrsMp4ESTagESDecoderConfigDescrTag;
objectTypeIndication = SrsMp4ObjectTypeForbidden;
streamType = SrsMp4StreamTypeForbidden;
- decSpecificInfo = NULL;
+ decSpecificInfo_ = NULL;
reserved = 1;
}
SrsMp4DecoderConfigDescriptor::~SrsMp4DecoderConfigDescriptor()
{
- srs_freep(decSpecificInfo);
+ srs_freep(decSpecificInfo_);
}
int32_t SrsMp4DecoderConfigDescriptor::nb_payload()
{
- return 13 + (decSpecificInfo ? decSpecificInfo->nb_bytes() : 0);
+ return 13 + (decSpecificInfo_ ? decSpecificInfo_->nb_bytes() : 0);
}
srs_error_t SrsMp4DecoderConfigDescriptor::encode_payload(SrsBuffer *buf)
@@ -3606,11 +3606,11 @@ srs_error_t SrsMp4DecoderConfigDescriptor::encode_payload(SrsBuffer *buf)
v |= uint8_t(streamType & 0x3f) << 2;
buf->write_1bytes(v);
- buf->write_3bytes(bufferSizeDB);
- buf->write_4bytes(maxBitrate);
- buf->write_4bytes(avgBitrate);
+ buf->write_3bytes(bufferSizeDB_);
+ buf->write_4bytes(maxBitrate_);
+ buf->write_4bytes(avgBitrate_);
- if (decSpecificInfo && (err = decSpecificInfo->encode(buf)) != srs_success) {
+ if (decSpecificInfo_ && (err = decSpecificInfo_->encode(buf)) != srs_success) {
return srs_error_wrap(err, "encode des specific info");
}
@@ -3628,14 +3628,14 @@ srs_error_t SrsMp4DecoderConfigDescriptor::decode_payload(SrsBuffer *buf)
streamType = (SrsMp4StreamType)((v >> 2) & 0x3f);
reserved = v & 0x01;
- bufferSizeDB = buf->read_3bytes();
- maxBitrate = buf->read_4bytes();
- avgBitrate = buf->read_4bytes();
+ bufferSizeDB_ = buf->read_3bytes();
+ maxBitrate_ = buf->read_4bytes();
+ avgBitrate_ = buf->read_4bytes();
int left = left_space(buf);
if (left > 0) {
- decSpecificInfo = new SrsMp4DecoderSpecificInfo();
- if ((err = decSpecificInfo->decode(buf)) != srs_success) {
+ decSpecificInfo_ = new SrsMp4DecoderSpecificInfo();
+ if ((err = decSpecificInfo_->decode(buf)) != srs_success) {
return srs_error_wrap(err, "decode dec specific info");
}
}
@@ -3653,8 +3653,8 @@ stringstream &SrsMp4DecoderConfigDescriptor::dumps_detail(stringstream &ss, SrsM
srs_mp4_padding(ss, dc.indent());
ss << "decoder specific";
- if (decSpecificInfo) {
- decSpecificInfo->dumps_detail(ss, dc.indent());
+ if (decSpecificInfo_) {
+ decSpecificInfo_->dumps_detail(ss, dc.indent());
}
return ss;
@@ -3663,7 +3663,7 @@ stringstream &SrsMp4DecoderConfigDescriptor::dumps_detail(stringstream &ss, SrsM
SrsMp4SLConfigDescriptor::SrsMp4SLConfigDescriptor()
{
tag = SrsMp4ESTagESSLConfigDescrTag;
- predefined = 2;
+ predefined_ = 2;
}
SrsMp4SLConfigDescriptor::~SrsMp4SLConfigDescriptor()
@@ -3679,7 +3679,7 @@ srs_error_t SrsMp4SLConfigDescriptor::encode_payload(SrsBuffer *buf)
{
srs_error_t err = srs_success;
- buf->write_1bytes(predefined);
+ buf->write_1bytes(predefined_);
return err;
}
@@ -3688,20 +3688,20 @@ srs_error_t SrsMp4SLConfigDescriptor::decode_payload(SrsBuffer *buf)
{
srs_error_t err = srs_success;
- predefined = buf->read_1bytes();
+ predefined_ = buf->read_1bytes();
// TODO: FIXME: To support complete SL Config.
- if (predefined != 0x02) {
- return srs_error_new(ERROR_MP4_ESDS_SL_Config, "illegal ESDS SL Config, predefined=%d", predefined);
+ if (predefined_ != 0x02) {
+ return srs_error_new(ERROR_MP4_ESDS_SL_Config, "illegal ESDS SL Config, predefined=%d", predefined_);
}
return err;
}
-SrsMp4ES_Descriptor::SrsMp4ES_Descriptor() : ES_ID(0), dependsOn_ES_ID(0), OCR_ES_Id(0)
+SrsMp4ES_Descriptor::SrsMp4ES_Descriptor() : ES_ID_(0), dependsOn_ES_ID_(0), OCR_ES_Id_(0)
{
tag = SrsMp4ESTagESDescrTag;
- streamPriority = streamDependenceFlag = URL_Flag = OCRstreamFlag = 0;
+ streamPriority_ = streamDependenceFlag_ = URL_Flag_ = OCRstreamFlag_ = 0;
}
SrsMp4ES_Descriptor::~SrsMp4ES_Descriptor()
@@ -3711,12 +3711,12 @@ SrsMp4ES_Descriptor::~SrsMp4ES_Descriptor()
int32_t SrsMp4ES_Descriptor::nb_payload()
{
int size = 2 + 1;
- size += streamDependenceFlag ? 2 : 0;
- if (URL_Flag) {
- size += 1 + URLstring.size();
+ size += streamDependenceFlag_ ? 2 : 0;
+ if (URL_Flag_) {
+ size += 1 + URLstring_.size();
}
- size += OCRstreamFlag ? 2 : 0;
- size += decConfigDescr.nb_bytes() + slConfigDescr.nb_bytes();
+ size += OCRstreamFlag_ ? 2 : 0;
+ size += decConfigDescr_.nb_bytes() + slConfigDescr_.nb_bytes();
return size;
}
@@ -3724,32 +3724,32 @@ srs_error_t SrsMp4ES_Descriptor::encode_payload(SrsBuffer *buf)
{
srs_error_t err = srs_success;
- buf->write_2bytes(ES_ID);
+ buf->write_2bytes(ES_ID_);
- uint8_t v = streamPriority & 0x1f;
- v |= (streamDependenceFlag & 0x01) << 7;
- v |= (URL_Flag & 0x01) << 6;
- v |= (OCRstreamFlag & 0x01) << 5;
+ uint8_t v = streamPriority_ & 0x1f;
+ v |= (streamDependenceFlag_ & 0x01) << 7;
+ v |= (URL_Flag_ & 0x01) << 6;
+ v |= (OCRstreamFlag_ & 0x01) << 5;
buf->write_1bytes(v);
- if (streamDependenceFlag) {
- buf->write_2bytes(dependsOn_ES_ID);
+ if (streamDependenceFlag_) {
+ buf->write_2bytes(dependsOn_ES_ID_);
}
- if (URL_Flag && !URLstring.empty()) {
- buf->write_1bytes(URLstring.size());
- buf->write_bytes(&URLstring[0], (int)URLstring.size());
+ if (URL_Flag_ && !URLstring_.empty()) {
+ buf->write_1bytes(URLstring_.size());
+ buf->write_bytes(&URLstring_[0], (int)URLstring_.size());
}
- if (OCRstreamFlag) {
- buf->write_2bytes(OCR_ES_Id);
+ if (OCRstreamFlag_) {
+ buf->write_2bytes(OCR_ES_Id_);
}
- if ((err = decConfigDescr.encode(buf)) != srs_success) {
+ if ((err = decConfigDescr_.encode(buf)) != srs_success) {
return srs_error_wrap(err, "encode dec config");
}
- if ((err = slConfigDescr.encode(buf)) != srs_success) {
+ if ((err = slConfigDescr_.encode(buf)) != srs_success) {
return srs_error_wrap(err, "encode sl config");
}
@@ -3760,22 +3760,22 @@ srs_error_t SrsMp4ES_Descriptor::decode_payload(SrsBuffer *buf)
{
srs_error_t err = srs_success;
- ES_ID = buf->read_2bytes();
+ ES_ID_ = buf->read_2bytes();
uint8_t v = buf->read_1bytes();
- streamPriority = v & 0x1f;
- streamDependenceFlag = (v >> 7) & 0x01;
- URL_Flag = (v >> 6) & 0x01;
- OCRstreamFlag = (v >> 5) & 0x01;
+ streamPriority_ = v & 0x1f;
+ streamDependenceFlag_ = (v >> 7) & 0x01;
+ URL_Flag_ = (v >> 6) & 0x01;
+ OCRstreamFlag_ = (v >> 5) & 0x01;
- if (streamDependenceFlag) {
+ if (streamDependenceFlag_) {
if (!buf->require(2)) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "ES requires 2 only %d bytes", buf->left());
}
- dependsOn_ES_ID = buf->read_2bytes();
+ dependsOn_ES_ID_ = buf->read_2bytes();
}
- if (URL_Flag) {
+ if (URL_Flag_) {
if (!buf->require(1)) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "URLlength requires 1 only %d bytes", buf->left());
}
@@ -3784,22 +3784,22 @@ srs_error_t SrsMp4ES_Descriptor::decode_payload(SrsBuffer *buf)
if (!buf->require(URLlength)) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "URL requires %d only %d bytes", URLlength, buf->left());
}
- URLstring.resize(URLlength);
- buf->read_bytes(&URLstring[0], URLlength);
+ URLstring_.resize(URLlength);
+ buf->read_bytes(&URLstring_[0], URLlength);
}
- if (OCRstreamFlag) {
+ if (OCRstreamFlag_) {
if (!buf->require(2)) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "OCR requires 2 only %d bytes", buf->left());
}
- OCR_ES_Id = buf->read_2bytes();
+ OCR_ES_Id_ = buf->read_2bytes();
}
- if ((err = decConfigDescr.decode(buf)) != srs_success) {
+ if ((err = decConfigDescr_.decode(buf)) != srs_success) {
return srs_error_wrap(err, "decode dec config");
}
- if ((err = slConfigDescr.decode(buf)) != srs_success) {
+ if ((err = slConfigDescr_.decode(buf)) != srs_success) {
return srs_error_wrap(err, "decode sl config");
}
@@ -3810,19 +3810,19 @@ stringstream &SrsMp4ES_Descriptor::dumps_detail(stringstream &ss, SrsMp4DumpCont
{
SrsMp4BaseDescriptor::dumps_detail(ss, dc);
- ss << ", ID=" << ES_ID;
+ ss << ", ID=" << ES_ID_;
ss << endl;
srs_mp4_padding(ss, dc.indent());
ss << "decoder config";
- decConfigDescr.dumps_detail(ss, dc.indent());
+ decConfigDescr_.dumps_detail(ss, dc.indent());
return ss;
}
SrsMp4EsdsBox::SrsMp4EsdsBox()
{
- type = SrsMp4BoxTypeESDS;
+ type_ = SrsMp4BoxTypeESDS;
es = new SrsMp4ES_Descriptor();
}
@@ -3833,7 +3833,7 @@ SrsMp4EsdsBox::~SrsMp4EsdsBox()
SrsMp4DecoderSpecificInfo *SrsMp4EsdsBox::asc()
{
- return es->decConfigDescr.decSpecificInfo;
+ return es->decConfigDescr_.decSpecificInfo_;
}
int SrsMp4EsdsBox::nb_header()
@@ -3888,25 +3888,25 @@ stringstream &SrsMp4EsdsBox::dumps_detail(stringstream &ss, SrsMp4DumpContext dc
SrsMp4SampleDescriptionBox::SrsMp4SampleDescriptionBox()
{
- type = SrsMp4BoxTypeSTSD;
+ type_ = SrsMp4BoxTypeSTSD;
}
SrsMp4SampleDescriptionBox::~SrsMp4SampleDescriptionBox()
{
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); ++it) {
+ for (it = entries_.begin(); it != entries_.end(); ++it) {
SrsMp4SampleEntry *entry = *it;
srs_freep(entry);
}
- entries.clear();
+ entries_.clear();
}
SrsMp4VisualSampleEntry *SrsMp4SampleDescriptionBox::avc1()
{
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); ++it) {
+ for (it = entries_.begin(); it != entries_.end(); ++it) {
SrsMp4SampleEntry *entry = *it;
- if (entry->type == SrsMp4BoxTypeAVC1) {
+ if (entry->type_ == SrsMp4BoxTypeAVC1) {
return dynamic_cast(entry);
}
}
@@ -3916,9 +3916,9 @@ SrsMp4VisualSampleEntry *SrsMp4SampleDescriptionBox::avc1()
SrsMp4AudioSampleEntry *SrsMp4SampleDescriptionBox::mp4a()
{
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); ++it) {
+ for (it = entries_.begin(); it != entries_.end(); ++it) {
SrsMp4SampleEntry *entry = *it;
- if (entry->type == SrsMp4BoxTypeMP4A) {
+ if (entry->type_ == SrsMp4BoxTypeMP4A) {
return dynamic_cast(entry);
}
}
@@ -3927,18 +3927,18 @@ SrsMp4AudioSampleEntry *SrsMp4SampleDescriptionBox::mp4a()
uint32_t SrsMp4SampleDescriptionBox::entry_count()
{
- return (uint32_t)entries.size();
+ return (uint32_t)entries_.size();
}
SrsMp4SampleEntry *SrsMp4SampleDescriptionBox::entrie_at(int index)
{
- return entries.at(index);
+ return entries_.at(index);
}
// Note that box must be SrsMp4SampleEntry*
void SrsMp4SampleDescriptionBox::append(SrsMp4Box *box)
{
- entries.push_back((SrsMp4SampleEntry *)box);
+ entries_.push_back((SrsMp4SampleEntry *)box);
}
int SrsMp4SampleDescriptionBox::nb_header()
@@ -3948,7 +3948,7 @@ int SrsMp4SampleDescriptionBox::nb_header()
size += 4;
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); ++it) {
+ for (it = entries_.begin(); it != entries_.end(); ++it) {
SrsMp4SampleEntry *entry = *it;
size += entry->nb_bytes();
}
@@ -3967,7 +3967,7 @@ srs_error_t SrsMp4SampleDescriptionBox::encode_header(SrsBuffer *buf)
buf->write_4bytes(entry_count());
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); ++it) {
+ for (it = entries_.begin(); it != entries_.end(); ++it) {
SrsMp4SampleEntry *entry = *it;
if ((err = entry->encode(buf)) != srs_success) {
return srs_error_wrap(err, "encode entry");
@@ -3998,7 +3998,7 @@ srs_error_t SrsMp4SampleDescriptionBox::decode_header(SrsBuffer *buf)
SrsMp4SampleEntry *entry = dynamic_cast(box);
if (entry) {
- entries.push_back(entry);
+ entries_.push_back(entry);
} else {
srs_freep(box);
}
@@ -4016,18 +4016,18 @@ stringstream &SrsMp4SampleDescriptionBox::dumps_detail(stringstream &ss, SrsMp4D
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", " << entries.size() << " childs";
- if (!entries.empty()) {
+ ss << ", " << entries_.size() << " childs";
+ if (!entries_.empty()) {
ss << "(+)" << endl;
- srs_dumps_array(entries, ss, dc.indent(), srs_mp4_pfn_box2, srs_mp4_delimiter_newline);
+ srs_dumps_array(entries_, ss, dc.indent(), srs_mp4_pfn_box2, srs_mp4_delimiter_newline);
}
return ss;
}
SrsMp4SttsEntry::SrsMp4SttsEntry()
{
- sample_count = 0;
- sample_delta = 0;
+ sample_count_ = 0;
+ sample_delta_ = 0;
}
SrsMp4SttsEntry::~SrsMp4SttsEntry()
@@ -4036,15 +4036,15 @@ SrsMp4SttsEntry::~SrsMp4SttsEntry()
stringstream &SrsMp4SttsEntry::dumps_detail(stringstream &ss, SrsMp4DumpContext dc)
{
- ss << "count=" << sample_count << ", delta=" << sample_delta;
+ ss << "count=" << sample_count_ << ", delta=" << sample_delta_;
return ss;
}
SrsMp4DecodingTime2SampleBox::SrsMp4DecodingTime2SampleBox()
{
- type = SrsMp4BoxTypeSTTS;
+ type_ = SrsMp4BoxTypeSTTS;
- index = count = 0;
+ index_ = count_ = 0;
}
SrsMp4DecodingTime2SampleBox::~SrsMp4DecodingTime2SampleBox()
@@ -4056,16 +4056,16 @@ srs_error_t SrsMp4DecodingTime2SampleBox::initialize_counter()
srs_error_t err = srs_success;
// If only sps/pps and no frames, there is no stts entries.
- if (entries.empty()) {
+ if (entries_.empty()) {
return err;
}
- index = 0;
- if (index >= entries.size()) {
+ index_ = 0;
+ if (index_ >= entries_.size()) {
return srs_error_new(ERROR_MP4_ILLEGAL_TIMESTAMP, "illegal ts, empty stts");
}
- count = entries[0].sample_count;
+ count_ = entries_[0].sample_count_;
return err;
}
@@ -4074,24 +4074,24 @@ srs_error_t SrsMp4DecodingTime2SampleBox::on_sample(uint32_t sample_index, SrsMp
{
srs_error_t err = srs_success;
- if (sample_index + 1 > count) {
- index++;
+ if (sample_index + 1 > count_) {
+ index_++;
- if (index >= entries.size()) {
- return srs_error_new(ERROR_MP4_ILLEGAL_TIMESTAMP, "illegal ts, stts overflow, count=%zd", entries.size());
+ if (index_ >= entries_.size()) {
+ return srs_error_new(ERROR_MP4_ILLEGAL_TIMESTAMP, "illegal ts, stts overflow, count=%zd", entries_.size());
}
- count += entries[index].sample_count;
+ count_ += entries_[index_].sample_count_;
}
- *ppentry = &entries[index];
+ *ppentry = &entries_[index_];
return err;
}
int SrsMp4DecodingTime2SampleBox::nb_header()
{
- return SrsMp4FullBox::nb_header() + 4 + 8 * (int)entries.size();
+ return SrsMp4FullBox::nb_header() + 4 + 8 * (int)entries_.size();
}
srs_error_t SrsMp4DecodingTime2SampleBox::encode_header(SrsBuffer *buf)
@@ -4102,11 +4102,11 @@ srs_error_t SrsMp4DecodingTime2SampleBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes((int)entries.size());
- for (size_t i = 0; i < (size_t)entries.size(); i++) {
- SrsMp4SttsEntry &entry = entries[i];
- buf->write_4bytes(entry.sample_count);
- buf->write_4bytes(entry.sample_delta);
+ buf->write_4bytes((int)entries_.size());
+ for (size_t i = 0; i < (size_t)entries_.size(); i++) {
+ SrsMp4SttsEntry &entry = entries_[i];
+ buf->write_4bytes(entry.sample_count_);
+ buf->write_4bytes(entry.sample_delta_);
}
return err;
@@ -4122,16 +4122,16 @@ srs_error_t SrsMp4DecodingTime2SampleBox::decode_header(SrsBuffer *buf)
uint32_t entry_count = buf->read_4bytes();
if (entry_count) {
- entries.resize(entry_count);
+ entries_.resize(entry_count);
}
for (size_t i = 0; i < (size_t)entry_count; i++) {
if (!buf->require(8)) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "no space");
}
- SrsMp4SttsEntry &entry = entries[i];
- entry.sample_count = buf->read_4bytes();
- entry.sample_delta = buf->read_4bytes();
+ SrsMp4SttsEntry &entry = entries_[i];
+ entry.sample_count_ = buf->read_4bytes();
+ entry.sample_delta_ = buf->read_4bytes();
}
return err;
@@ -4141,19 +4141,19 @@ stringstream &SrsMp4DecodingTime2SampleBox::dumps_detail(stringstream &ss, SrsMp
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", " << entries.size() << " childs (+)";
- if (!entries.empty()) {
+ 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_detail, srs_mp4_delimiter_newline);
+ srs_dumps_array(entries_, ss, dc.indent(), srs_mp4_pfn_detail, srs_mp4_delimiter_newline);
}
return ss;
}
SrsMp4CttsEntry::SrsMp4CttsEntry()
{
- sample_count = 0;
- sample_offset = 0;
+ sample_count_ = 0;
+ sample_offset_ = 0;
}
SrsMp4CttsEntry::~SrsMp4CttsEntry()
@@ -4162,15 +4162,15 @@ SrsMp4CttsEntry::~SrsMp4CttsEntry()
stringstream &SrsMp4CttsEntry::dumps_detail(stringstream &ss, SrsMp4DumpContext dc)
{
- ss << "count=" << sample_count << ", offset=" << sample_offset;
+ ss << "count=" << sample_count_ << ", offset=" << sample_offset_;
return ss;
}
SrsMp4CompositionTime2SampleBox::SrsMp4CompositionTime2SampleBox()
{
- type = SrsMp4BoxTypeCTTS;
+ type_ = SrsMp4BoxTypeCTTS;
- index = count = 0;
+ index_ = count_ = 0;
}
SrsMp4CompositionTime2SampleBox::~SrsMp4CompositionTime2SampleBox()
@@ -4182,16 +4182,16 @@ srs_error_t SrsMp4CompositionTime2SampleBox::initialize_counter()
srs_error_t err = srs_success;
// If only sps/pps and no frames, there is no stts entries.
- if (entries.empty()) {
+ if (entries_.empty()) {
return err;
}
- index = 0;
- if (index >= entries.size()) {
+ index_ = 0;
+ if (index_ >= entries_.size()) {
return srs_error_new(ERROR_MP4_ILLEGAL_TIMESTAMP, "illegal ts, empty ctts");
}
- count = entries[0].sample_count;
+ count_ = entries_[0].sample_count_;
return err;
}
@@ -4200,24 +4200,24 @@ srs_error_t SrsMp4CompositionTime2SampleBox::on_sample(uint32_t sample_index, Sr
{
srs_error_t err = srs_success;
- if (sample_index + 1 > count) {
- index++;
+ if (sample_index + 1 > count_) {
+ index_++;
- if (index >= entries.size()) {
- return srs_error_new(ERROR_MP4_ILLEGAL_TIMESTAMP, "illegal ts, ctts overflow, count=%d", (int)entries.size());
+ if (index_ >= entries_.size()) {
+ return srs_error_new(ERROR_MP4_ILLEGAL_TIMESTAMP, "illegal ts, ctts overflow, count=%d", (int)entries_.size());
}
- count += entries[index].sample_count;
+ count_ += entries_[index_].sample_count_;
}
- *ppentry = &entries[index];
+ *ppentry = &entries_[index_];
return err;
}
int SrsMp4CompositionTime2SampleBox::nb_header()
{
- return SrsMp4FullBox::nb_header() + 4 + 8 * (int)entries.size();
+ return SrsMp4FullBox::nb_header() + 4 + 8 * (int)entries_.size();
}
srs_error_t SrsMp4CompositionTime2SampleBox::encode_header(SrsBuffer *buf)
@@ -4228,14 +4228,14 @@ srs_error_t SrsMp4CompositionTime2SampleBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes((int)entries.size());
- for (size_t i = 0; i < (size_t)entries.size(); i++) {
- SrsMp4CttsEntry &entry = entries[i];
- buf->write_4bytes(entry.sample_count);
- if (version == 0) {
- buf->write_4bytes((uint32_t)entry.sample_offset);
- } else if (version == 1) {
- buf->write_4bytes((int32_t)entry.sample_offset);
+ buf->write_4bytes((int)entries_.size());
+ for (size_t i = 0; i < (size_t)entries_.size(); i++) {
+ SrsMp4CttsEntry &entry = entries_[i];
+ buf->write_4bytes(entry.sample_count_);
+ if (version_ == 0) {
+ buf->write_4bytes((uint32_t)entry.sample_offset_);
+ } else if (version_ == 1) {
+ buf->write_4bytes((int32_t)entry.sample_offset_);
}
}
@@ -4252,15 +4252,15 @@ srs_error_t SrsMp4CompositionTime2SampleBox::decode_header(SrsBuffer *buf)
uint32_t entry_count = buf->read_4bytes();
if (entry_count) {
- entries.resize(entry_count);
+ entries_.resize(entry_count);
}
for (size_t i = 0; i < (size_t)entry_count; i++) {
- SrsMp4CttsEntry &entry = entries[i];
- entry.sample_count = buf->read_4bytes();
- if (version == 0) {
- entry.sample_offset = (uint32_t)buf->read_4bytes();
- } else if (version == 1) {
- entry.sample_offset = (int32_t)buf->read_4bytes();
+ SrsMp4CttsEntry &entry = entries_[i];
+ entry.sample_count_ = buf->read_4bytes();
+ if (version_ == 0) {
+ entry.sample_offset_ = (uint32_t)buf->read_4bytes();
+ } else if (version_ == 1) {
+ entry.sample_offset_ = (int32_t)buf->read_4bytes();
}
}
@@ -4271,32 +4271,32 @@ stringstream &SrsMp4CompositionTime2SampleBox::dumps_detail(stringstream &ss, Sr
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", " << entries.size() << " childs (+)";
- if (!entries.empty()) {
+ 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_detail, srs_mp4_delimiter_newline);
+ srs_dumps_array(entries_, ss, dc.indent(), srs_mp4_pfn_detail, srs_mp4_delimiter_newline);
}
return ss;
}
SrsMp4SyncSampleBox::SrsMp4SyncSampleBox()
{
- type = SrsMp4BoxTypeSTSS;
+ type_ = SrsMp4BoxTypeSTSS;
- entry_count = 0;
- sample_numbers = NULL;
+ entry_count_ = 0;
+ sample_numbers_ = NULL;
}
SrsMp4SyncSampleBox::~SrsMp4SyncSampleBox()
{
- srs_freepa(sample_numbers);
+ srs_freepa(sample_numbers_);
}
bool SrsMp4SyncSampleBox::is_sync(uint32_t sample_index)
{
- for (uint32_t i = 0; i < entry_count; i++) {
- if (sample_index + 1 == sample_numbers[i]) {
+ for (uint32_t i = 0; i < entry_count_; i++) {
+ if (sample_index + 1 == sample_numbers_[i]) {
return true;
}
}
@@ -4305,7 +4305,7 @@ bool SrsMp4SyncSampleBox::is_sync(uint32_t sample_index)
int SrsMp4SyncSampleBox::nb_header()
{
- return SrsMp4FullBox::nb_header() + 4 + 4 * entry_count;
+ return SrsMp4FullBox::nb_header() + 4 + 4 * entry_count_;
}
srs_error_t SrsMp4SyncSampleBox::encode_header(SrsBuffer *buf)
@@ -4316,9 +4316,9 @@ srs_error_t SrsMp4SyncSampleBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes(entry_count);
- for (uint32_t i = 0; i < entry_count; i++) {
- uint32_t sample_number = sample_numbers[i];
+ buf->write_4bytes(entry_count_);
+ for (uint32_t i = 0; i < entry_count_; i++) {
+ uint32_t sample_number = sample_numbers_[i];
buf->write_4bytes(sample_number);
}
@@ -4333,12 +4333,12 @@ srs_error_t SrsMp4SyncSampleBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- entry_count = buf->read_4bytes();
- if (entry_count > 0) {
- sample_numbers = new uint32_t[entry_count];
+ entry_count_ = buf->read_4bytes();
+ if (entry_count_ > 0) {
+ sample_numbers_ = new uint32_t[entry_count_];
}
- for (uint32_t i = 0; i < entry_count; i++) {
- sample_numbers[i] = buf->read_4bytes();
+ for (uint32_t i = 0; i < entry_count_; i++) {
+ sample_numbers_[i] = buf->read_4bytes();
}
return err;
@@ -4348,64 +4348,64 @@ stringstream &SrsMp4SyncSampleBox::dumps_detail(stringstream &ss, SrsMp4DumpCont
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", count=" << entry_count;
- if (entry_count > 0) {
+ ss << ", count=" << entry_count_;
+ if (entry_count_ > 0) {
ss << endl;
srs_mp4_padding(ss, dc.indent());
- srs_dumps_array(sample_numbers, entry_count, ss, dc.indent(), srs_mp4_pfn_elem, srs_mp4_delimiter_inspace);
+ srs_dumps_array(sample_numbers_, entry_count_, ss, dc.indent(), srs_mp4_pfn_elem, srs_mp4_delimiter_inspace);
}
return ss;
}
SrsMp4StscEntry::SrsMp4StscEntry()
{
- first_chunk = 0;
- samples_per_chunk = 0;
- sample_description_index = 0;
+ first_chunk_ = 0;
+ samples_per_chunk_ = 0;
+ sample_description_index_ = 0;
}
stringstream &SrsMp4StscEntry::dumps_detail(stringstream &ss, SrsMp4DumpContext dc)
{
- ss << "first=" << first_chunk << ", samples=" << samples_per_chunk << ", index=" << sample_description_index;
+ ss << "first=" << first_chunk_ << ", samples=" << samples_per_chunk_ << ", index=" << sample_description_index_;
return ss;
}
SrsMp4Sample2ChunkBox::SrsMp4Sample2ChunkBox()
{
- type = SrsMp4BoxTypeSTSC;
+ type_ = SrsMp4BoxTypeSTSC;
- entry_count = 0;
- entries = NULL;
- index = 0;
+ entry_count_ = 0;
+ entries_ = NULL;
+ index_ = 0;
}
SrsMp4Sample2ChunkBox::~SrsMp4Sample2ChunkBox()
{
- srs_freepa(entries);
+ srs_freepa(entries_);
}
void SrsMp4Sample2ChunkBox::initialize_counter()
{
- index = 0;
+ index_ = 0;
}
SrsMp4StscEntry *SrsMp4Sample2ChunkBox::on_chunk(uint32_t chunk_index)
{
// Last chunk?
- if (index >= entry_count - 1) {
- return &entries[index];
+ if (index_ >= entry_count_ - 1) {
+ return &entries_[index_];
}
// Move next chunk?
- if (chunk_index + 1 >= entries[index + 1].first_chunk) {
- index++;
+ if (chunk_index + 1 >= entries_[index_ + 1].first_chunk_) {
+ index_++;
}
- return &entries[index];
+ return &entries_[index_];
}
int SrsMp4Sample2ChunkBox::nb_header()
{
- return SrsMp4FullBox::nb_header() + 4 + 12 * entry_count;
+ return SrsMp4FullBox::nb_header() + 4 + 12 * entry_count_;
}
srs_error_t SrsMp4Sample2ChunkBox::encode_header(SrsBuffer *buf)
@@ -4416,12 +4416,12 @@ srs_error_t SrsMp4Sample2ChunkBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes(entry_count);
- for (uint32_t i = 0; i < entry_count; i++) {
- SrsMp4StscEntry &entry = entries[i];
- buf->write_4bytes(entry.first_chunk);
- buf->write_4bytes(entry.samples_per_chunk);
- buf->write_4bytes(entry.sample_description_index);
+ buf->write_4bytes(entry_count_);
+ for (uint32_t i = 0; i < entry_count_; i++) {
+ SrsMp4StscEntry &entry = entries_[i];
+ buf->write_4bytes(entry.first_chunk_);
+ buf->write_4bytes(entry.samples_per_chunk_);
+ buf->write_4bytes(entry.sample_description_index_);
}
return err;
@@ -4435,15 +4435,15 @@ srs_error_t SrsMp4Sample2ChunkBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- entry_count = buf->read_4bytes();
- if (entry_count) {
- entries = new SrsMp4StscEntry[entry_count];
+ entry_count_ = buf->read_4bytes();
+ if (entry_count_) {
+ entries_ = new SrsMp4StscEntry[entry_count_];
}
- for (uint32_t i = 0; i < entry_count; i++) {
- SrsMp4StscEntry &entry = entries[i];
- entry.first_chunk = buf->read_4bytes();
- entry.samples_per_chunk = buf->read_4bytes();
- entry.sample_description_index = buf->read_4bytes();
+ for (uint32_t i = 0; i < entry_count_; i++) {
+ SrsMp4StscEntry &entry = entries_[i];
+ entry.first_chunk_ = buf->read_4bytes();
+ entry.samples_per_chunk_ = buf->read_4bytes();
+ entry.sample_description_index_ = buf->read_4bytes();
}
return err;
@@ -4453,31 +4453,31 @@ stringstream &SrsMp4Sample2ChunkBox::dumps_detail(stringstream &ss, SrsMp4DumpCo
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", " << entry_count << " childs (+)";
- if (entry_count > 0) {
+ ss << ", " << entry_count_ << " childs (+)";
+ if (entry_count_ > 0) {
ss << endl;
srs_mp4_padding(ss, dc.indent());
- srs_dumps_array(entries, entry_count, ss, dc.indent(), srs_mp4_pfn_detail, srs_mp4_delimiter_newline);
+ srs_dumps_array(entries_, entry_count_, ss, dc.indent(), srs_mp4_pfn_detail, srs_mp4_delimiter_newline);
}
return ss;
}
SrsMp4ChunkOffsetBox::SrsMp4ChunkOffsetBox()
{
- type = SrsMp4BoxTypeSTCO;
+ type_ = SrsMp4BoxTypeSTCO;
- entry_count = 0;
- entries = NULL;
+ entry_count_ = 0;
+ entries_ = NULL;
}
SrsMp4ChunkOffsetBox::~SrsMp4ChunkOffsetBox()
{
- srs_freepa(entries);
+ srs_freepa(entries_);
}
int SrsMp4ChunkOffsetBox::nb_header()
{
- return SrsMp4FullBox::nb_header() + 4 + 4 * entry_count;
+ return SrsMp4FullBox::nb_header() + 4 + 4 * entry_count_;
}
srs_error_t SrsMp4ChunkOffsetBox::encode_header(SrsBuffer *buf)
@@ -4488,9 +4488,9 @@ srs_error_t SrsMp4ChunkOffsetBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes(entry_count);
- for (uint32_t i = 0; i < entry_count; i++) {
- buf->write_4bytes(entries[i]);
+ buf->write_4bytes(entry_count_);
+ for (uint32_t i = 0; i < entry_count_; i++) {
+ buf->write_4bytes(entries_[i]);
}
return err;
@@ -4504,12 +4504,12 @@ srs_error_t SrsMp4ChunkOffsetBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- entry_count = buf->read_4bytes();
- if (entry_count) {
- entries = new uint32_t[entry_count];
+ entry_count_ = buf->read_4bytes();
+ if (entry_count_) {
+ entries_ = new uint32_t[entry_count_];
}
- for (uint32_t i = 0; i < entry_count; i++) {
- entries[i] = buf->read_4bytes();
+ for (uint32_t i = 0; i < entry_count_; i++) {
+ entries_[i] = buf->read_4bytes();
}
return err;
@@ -4519,31 +4519,31 @@ stringstream &SrsMp4ChunkOffsetBox::dumps_detail(stringstream &ss, SrsMp4DumpCon
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", " << entry_count << " childs (+)";
- if (entry_count > 0) {
+ ss << ", " << entry_count_ << " childs (+)";
+ if (entry_count_ > 0) {
ss << endl;
srs_mp4_padding(ss, dc.indent());
- srs_dumps_array(entries, entry_count, ss, dc.indent(), srs_mp4_pfn_elem, srs_mp4_delimiter_inspace);
+ srs_dumps_array(entries_, entry_count_, ss, dc.indent(), srs_mp4_pfn_elem, srs_mp4_delimiter_inspace);
}
return ss;
}
SrsMp4ChunkLargeOffsetBox::SrsMp4ChunkLargeOffsetBox()
{
- type = SrsMp4BoxTypeCO64;
+ type_ = SrsMp4BoxTypeCO64;
- entry_count = 0;
- entries = NULL;
+ entry_count_ = 0;
+ entries_ = NULL;
}
SrsMp4ChunkLargeOffsetBox::~SrsMp4ChunkLargeOffsetBox()
{
- srs_freepa(entries);
+ srs_freepa(entries_);
}
int SrsMp4ChunkLargeOffsetBox::nb_header()
{
- return SrsMp4FullBox::nb_header() + 4 + 8 * entry_count;
+ return SrsMp4FullBox::nb_header() + 4 + 8 * entry_count_;
}
srs_error_t SrsMp4ChunkLargeOffsetBox::encode_header(SrsBuffer *buf)
@@ -4554,9 +4554,9 @@ srs_error_t SrsMp4ChunkLargeOffsetBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes(entry_count);
- for (uint32_t i = 0; i < entry_count; i++) {
- buf->write_8bytes(entries[i]);
+ buf->write_4bytes(entry_count_);
+ for (uint32_t i = 0; i < entry_count_; i++) {
+ buf->write_8bytes(entries_[i]);
}
return err;
@@ -4570,12 +4570,12 @@ srs_error_t SrsMp4ChunkLargeOffsetBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- entry_count = buf->read_4bytes();
- if (entry_count) {
- entries = new uint64_t[entry_count];
+ entry_count_ = buf->read_4bytes();
+ if (entry_count_) {
+ entries_ = new uint64_t[entry_count_];
}
- for (uint32_t i = 0; i < entry_count; i++) {
- entries[i] = buf->read_8bytes();
+ for (uint32_t i = 0; i < entry_count_; i++) {
+ entries_[i] = buf->read_8bytes();
}
return err;
@@ -4585,41 +4585,41 @@ stringstream &SrsMp4ChunkLargeOffsetBox::dumps_detail(stringstream &ss, SrsMp4Du
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", " << entry_count << " childs (+)";
- if (entry_count > 0) {
+ ss << ", " << entry_count_ << " childs (+)";
+ if (entry_count_ > 0) {
ss << endl;
srs_mp4_padding(ss, dc.indent());
- srs_dumps_array(entries, entry_count, ss, dc.indent(), srs_mp4_pfn_elem, srs_mp4_delimiter_inspace);
+ srs_dumps_array(entries_, entry_count_, ss, dc.indent(), srs_mp4_pfn_elem, srs_mp4_delimiter_inspace);
}
return ss;
}
SrsMp4SampleSizeBox::SrsMp4SampleSizeBox()
{
- type = SrsMp4BoxTypeSTSZ;
+ type_ = SrsMp4BoxTypeSTSZ;
- sample_size = sample_count = 0;
- entry_sizes = NULL;
+ sample_size_ = sample_count_ = 0;
+ entry_sizes_ = NULL;
}
SrsMp4SampleSizeBox::~SrsMp4SampleSizeBox()
{
- srs_freepa(entry_sizes);
+ srs_freepa(entry_sizes_);
}
srs_error_t SrsMp4SampleSizeBox::get_sample_size(uint32_t sample_index, uint32_t *psample_size)
{
srs_error_t err = srs_success;
- if (sample_size != 0) {
- *psample_size = sample_size;
+ if (sample_size_ != 0) {
+ *psample_size = sample_size_;
return err;
}
- if (sample_index >= sample_count) {
- return srs_error_new(ERROR_MP4_MOOV_OVERFLOW, "stsz overflow, sample_count=%d", sample_count);
+ if (sample_index >= sample_count_) {
+ return srs_error_new(ERROR_MP4_MOOV_OVERFLOW, "stsz overflow, sample_count=%d", sample_count_);
}
- *psample_size = entry_sizes[sample_index];
+ *psample_size = entry_sizes_[sample_index];
return err;
}
@@ -4627,8 +4627,8 @@ srs_error_t SrsMp4SampleSizeBox::get_sample_size(uint32_t sample_index, uint32_t
int SrsMp4SampleSizeBox::nb_header()
{
int size = SrsMp4FullBox::nb_header() + 4 + 4;
- if (sample_size == 0) {
- size += 4 * sample_count;
+ if (sample_size_ == 0) {
+ size += 4 * sample_count_;
}
return size;
}
@@ -4641,10 +4641,10 @@ srs_error_t SrsMp4SampleSizeBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes(sample_size);
- buf->write_4bytes(sample_count);
- for (uint32_t i = 0; i < sample_count && sample_size == 0; i++) {
- buf->write_4bytes(entry_sizes[i]);
+ buf->write_4bytes(sample_size_);
+ buf->write_4bytes(sample_count_);
+ for (uint32_t i = 0; i < sample_count_ && sample_size_ == 0; i++) {
+ buf->write_4bytes(entry_sizes_[i]);
}
return err;
@@ -4658,13 +4658,13 @@ srs_error_t SrsMp4SampleSizeBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- sample_size = buf->read_4bytes();
- sample_count = buf->read_4bytes();
- if (!sample_size && sample_count) {
- entry_sizes = new uint32_t[sample_count];
+ sample_size_ = buf->read_4bytes();
+ sample_count_ = buf->read_4bytes();
+ if (!sample_size_ && sample_count_) {
+ entry_sizes_ = new uint32_t[sample_count_];
}
- for (uint32_t i = 0; i < sample_count && sample_size == 0; i++) {
- entry_sizes[i] = buf->read_4bytes();
+ for (uint32_t i = 0; i < sample_count_ && sample_size_ == 0; i++) {
+ entry_sizes_[i] = buf->read_4bytes();
}
return err;
@@ -4674,18 +4674,18 @@ stringstream &SrsMp4SampleSizeBox::dumps_detail(stringstream &ss, SrsMp4DumpCont
{
SrsMp4FullBox::dumps_detail(ss, dc);
- ss << ", size=" << sample_size << ", " << sample_count << " childs (+)";
- if (!sample_size && sample_count > 0) {
+ ss << ", size=" << sample_size_ << ", " << sample_count_ << " childs (+)";
+ if (!sample_size_ && sample_count_ > 0) {
ss << endl;
srs_mp4_padding(ss, dc.indent());
- srs_dumps_array(entry_sizes, sample_count, ss, dc.indent(), srs_mp4_pfn_elem, srs_mp4_delimiter_inspace);
+ srs_dumps_array(entry_sizes_, sample_count_, ss, dc.indent(), srs_mp4_pfn_elem, srs_mp4_delimiter_inspace);
}
return ss;
}
SrsMp4UserDataBox::SrsMp4UserDataBox()
{
- type = SrsMp4BoxTypeUDTA;
+ type_ = SrsMp4BoxTypeUDTA;
}
SrsMp4UserDataBox::~SrsMp4UserDataBox()
@@ -4694,7 +4694,7 @@ SrsMp4UserDataBox::~SrsMp4UserDataBox()
int SrsMp4UserDataBox::nb_header()
{
- return SrsMp4Box::nb_header() + (int)data.size();
+ return SrsMp4Box::nb_header() + (int)data_.size();
}
srs_error_t SrsMp4UserDataBox::encode_header(SrsBuffer *buf)
@@ -4705,8 +4705,8 @@ srs_error_t SrsMp4UserDataBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- if (!data.empty()) {
- buf->write_bytes(&data[0], (int)data.size());
+ if (!data_.empty()) {
+ buf->write_bytes(&data_[0], (int)data_.size());
}
return err;
@@ -4722,8 +4722,8 @@ srs_error_t SrsMp4UserDataBox::decode_header(SrsBuffer *buf)
int nb_data = left_space(buf);
if (nb_data) {
- data.resize(nb_data);
- buf->read_bytes(&data[0], (int)data.size());
+ data_.resize(nb_data);
+ buf->read_bytes(&data_[0], (int)data_.size());
}
return err;
@@ -4733,22 +4733,22 @@ stringstream &SrsMp4UserDataBox::dumps_detail(stringstream &ss, SrsMp4DumpContex
{
SrsMp4Box::dumps_detail(ss, dc);
- ss << ", total " << data.size() << "B";
+ ss << ", total " << data_.size() << "B";
- if (!data.empty()) {
+ if (!data_.empty()) {
ss << endl;
srs_mp4_padding(ss, dc.indent());
- srs_dumps_array(&data[0], (int)data.size(), ss, dc.indent(), srs_mp4_pfn_hex, srs_mp4_delimiter_inspace);
+ srs_dumps_array(&data_[0], (int)data_.size(), ss, dc.indent(), srs_mp4_pfn_hex, srs_mp4_delimiter_inspace);
}
return ss;
}
SrsMp4SegmentIndexBox::SrsMp4SegmentIndexBox()
{
- type = SrsMp4BoxTypeSIDX;
- version = 0;
- flags = reference_id = timescale = 0;
- earliest_presentation_time = first_offset = 0;
+ type_ = SrsMp4BoxTypeSIDX;
+ version_ = 0;
+ flags_ = reference_id_ = timescale_ = 0;
+ earliest_presentation_time_ = first_offset_ = 0;
}
SrsMp4SegmentIndexBox::~SrsMp4SegmentIndexBox()
@@ -4757,7 +4757,7 @@ SrsMp4SegmentIndexBox::~SrsMp4SegmentIndexBox()
int SrsMp4SegmentIndexBox::nb_header()
{
- return SrsMp4Box::nb_header() + 4 + 4 + 4 + (!version ? 8 : 16) + 4 + 12 * entries.size();
+ return SrsMp4Box::nb_header() + 4 + 4 + 4 + (!version_ ? 8 : 16) + 4 + 12 * entries_.size();
}
srs_error_t SrsMp4SegmentIndexBox::encode_header(SrsBuffer *buf)
@@ -4768,31 +4768,31 @@ srs_error_t SrsMp4SegmentIndexBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_1bytes(version);
- buf->write_3bytes(flags);
- buf->write_4bytes(reference_id);
- buf->write_4bytes(timescale);
- if (!version) {
- buf->write_4bytes(earliest_presentation_time);
- buf->write_4bytes(first_offset);
+ buf->write_1bytes(version_);
+ buf->write_3bytes(flags_);
+ buf->write_4bytes(reference_id_);
+ buf->write_4bytes(timescale_);
+ if (!version_) {
+ buf->write_4bytes(earliest_presentation_time_);
+ buf->write_4bytes(first_offset_);
} else {
- buf->write_8bytes(earliest_presentation_time);
- buf->write_8bytes(first_offset);
+ buf->write_8bytes(earliest_presentation_time_);
+ buf->write_8bytes(first_offset_);
}
- buf->write_4bytes((uint32_t)entries.size());
- for (int i = 0; i < (int)entries.size(); i++) {
- SrsMp4SegmentIndexEntry &entry = entries.at(i);
+ buf->write_4bytes((uint32_t)entries_.size());
+ for (int i = 0; i < (int)entries_.size(); i++) {
+ SrsMp4SegmentIndexEntry &entry = entries_.at(i);
- uint32_t v = uint32_t(entry.reference_type & 0x01) << 31;
- v |= entry.referenced_size & 0x7fffffff;
+ uint32_t v = uint32_t(entry.reference_type_ & 0x01) << 31;
+ v |= entry.referenced_size_ & 0x7fffffff;
buf->write_4bytes(v);
- buf->write_4bytes(entry.subsegment_duration);
+ buf->write_4bytes(entry.subsegment_duration_);
- v = uint32_t(entry.starts_with_SAP & 0x01) << 31;
- v |= uint32_t(entry.SAP_type & 0x7) << 28;
- v |= entry.SAP_delta_time & 0xfffffff;
+ v = uint32_t(entry.starts_with_SAP_ & 0x01) << 31;
+ v |= uint32_t(entry.SAP_type_ & 0x7) << 28;
+ v |= entry.SAP_delta_time_ & 0xfffffff;
buf->write_4bytes(v);
}
@@ -4807,23 +4807,23 @@ srs_error_t SrsMp4SegmentIndexBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- version = buf->read_1bytes();
- flags = buf->read_3bytes();
- reference_id = buf->read_4bytes();
- timescale = buf->read_4bytes();
+ version_ = buf->read_1bytes();
+ flags_ = buf->read_3bytes();
+ reference_id_ = buf->read_4bytes();
+ timescale_ = buf->read_4bytes();
- if (!version) {
+ if (!version_) {
if (!buf->require(8)) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "no space");
}
- earliest_presentation_time = buf->read_4bytes();
- first_offset = buf->read_4bytes();
+ earliest_presentation_time_ = buf->read_4bytes();
+ first_offset_ = buf->read_4bytes();
} else {
if (!buf->require(16)) {
return srs_error_new(ERROR_MP4_BOX_REQUIRE_SPACE, "no space");
}
- earliest_presentation_time = buf->read_8bytes();
- first_offset = buf->read_8bytes();
+ earliest_presentation_time_ = buf->read_8bytes();
+ first_offset_ = buf->read_8bytes();
}
uint32_t nn_entries = (uint32_t)(buf->read_4bytes() & 0xffff);
@@ -4835,17 +4835,17 @@ srs_error_t SrsMp4SegmentIndexBox::decode_header(SrsBuffer *buf)
SrsMp4SegmentIndexEntry entry;
uint32_t v = buf->read_4bytes();
- entry.reference_type = uint8_t((v & 0x80000000) >> 31);
- entry.referenced_size = v & 0x7fffffff;
+ entry.reference_type_ = uint8_t((v & 0x80000000) >> 31);
+ entry.referenced_size_ = v & 0x7fffffff;
- entry.subsegment_duration = buf->read_4bytes();
+ entry.subsegment_duration_ = buf->read_4bytes();
v = buf->read_4bytes();
- entry.starts_with_SAP = uint8_t((v & 0x80000000) >> 31);
- entry.SAP_type = uint8_t((v & 0x70000000) >> 28);
- entry.SAP_delta_time = v & 0xfffffff;
+ entry.starts_with_SAP_ = uint8_t((v & 0x80000000) >> 31);
+ entry.SAP_type_ = uint8_t((v & 0x70000000) >> 28);
+ entry.SAP_delta_time_ = v & 0xfffffff;
- entries.push_back(entry);
+ entries_.push_back(entry);
}
return err;
@@ -4855,17 +4855,17 @@ stringstream &SrsMp4SegmentIndexBox::dumps_detail(stringstream &ss, SrsMp4DumpCo
{
SrsMp4Box::dumps_detail(ss, dc);
- ss << ", v" << (int)version << ", flags=" << flags << ", refs#" << reference_id
- << ", TBN=" << timescale << ", ePTS=" << earliest_presentation_time;
+ ss << ", v" << (int)version_ << ", flags=" << flags_ << ", refs#" << reference_id_
+ << ", TBN=" << timescale_ << ", ePTS=" << earliest_presentation_time_;
- for (int i = 0; i < (int)entries.size(); i++) {
- SrsMp4SegmentIndexEntry &entry = entries.at(i);
+ for (int i = 0; i < (int)entries_.size(); i++) {
+ SrsMp4SegmentIndexEntry &entry = entries_.at(i);
ss << endl;
srs_mp4_padding(ss, dc.indent());
- ss << "#" << i << ", ref=" << (int)entry.reference_type << "/" << entry.referenced_size
- << ", duration=" << entry.subsegment_duration << ", SAP=" << (int)entry.starts_with_SAP
- << "/" << (int)entry.SAP_type << "/" << entry.SAP_delta_time;
+ ss << "#" << i << ", ref=" << (int)entry.reference_type_ << "/" << entry.referenced_size_
+ << ", duration=" << entry.subsegment_duration_ << ", SAP=" << (int)entry.starts_with_SAP_
+ << "/" << (int)entry.SAP_type_ << "/" << entry.SAP_delta_time_;
}
return ss;
@@ -4873,7 +4873,7 @@ stringstream &SrsMp4SegmentIndexBox::dumps_detail(stringstream &ss, SrsMp4DumpCo
SrsMp4SampleAuxiliaryInfoSizeBox::SrsMp4SampleAuxiliaryInfoSizeBox()
{
- type = SrsMp4BoxTypeSAIZ;
+ type_ = SrsMp4BoxTypeSAIZ;
}
SrsMp4SampleAuxiliaryInfoSizeBox::~SrsMp4SampleAuxiliaryInfoSizeBox()
@@ -4884,15 +4884,15 @@ int SrsMp4SampleAuxiliaryInfoSizeBox::nb_header()
{
int size = SrsMp4FullBox::nb_header();
- if (flags & 0x01) {
+ if (flags_ & 0x01) {
size += 8; // add sizeof(aux_info_type) + sizeof(aux_info_type_parameter);
}
size += 1; // sizeof(default_sample_info_size);
size += 4; // sizeof(sample_count);
- if (default_sample_info_size == 0) {
- size += sample_info_sizes.size();
+ if (default_sample_info_size_ == 0) {
+ size += sample_info_sizes_.size();
}
return size;
@@ -4906,21 +4906,21 @@ srs_error_t SrsMp4SampleAuxiliaryInfoSizeBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- if (flags & 0x01) {
- buf->write_4bytes(aux_info_type);
- buf->write_4bytes(aux_info_type_parameter);
+ if (flags_ & 0x01) {
+ buf->write_4bytes(aux_info_type_);
+ buf->write_4bytes(aux_info_type_parameter_);
}
- buf->write_1bytes(default_sample_info_size);
+ buf->write_1bytes(default_sample_info_size_);
- if (default_sample_info_size == 0) {
- buf->write_4bytes(sample_info_sizes.size());
+ if (default_sample_info_size_ == 0) {
+ buf->write_4bytes(sample_info_sizes_.size());
vector::iterator it;
- for (it = sample_info_sizes.begin(); it != sample_info_sizes.end(); ++it) {
+ for (it = sample_info_sizes_.begin(); it != sample_info_sizes_.end(); ++it) {
buf->write_1bytes(*it);
}
} else {
- buf->write_4bytes(sample_count);
+ buf->write_4bytes(sample_count_);
}
return err;
@@ -4934,17 +4934,17 @@ srs_error_t SrsMp4SampleAuxiliaryInfoSizeBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- if (flags & 0x01) {
- aux_info_type = buf->read_4bytes();
- aux_info_type_parameter = buf->read_4bytes();
+ if (flags_ & 0x01) {
+ aux_info_type_ = buf->read_4bytes();
+ aux_info_type_parameter_ = buf->read_4bytes();
}
- default_sample_info_size = buf->read_1bytes();
- sample_count = buf->read_4bytes();
+ default_sample_info_size_ = buf->read_1bytes();
+ sample_count_ = buf->read_4bytes();
- if (default_sample_info_size == 0) {
- for (int i = 0; i < sample_count; i++) {
- sample_info_sizes.push_back(buf->read_1bytes());
+ if (default_sample_info_size_ == 0) {
+ for (int i = 0; i < (int)sample_count_; i++) {
+ sample_info_sizes_.push_back(buf->read_1bytes());
}
}
@@ -4953,13 +4953,13 @@ srs_error_t SrsMp4SampleAuxiliaryInfoSizeBox::decode_header(SrsBuffer *buf)
std::stringstream &SrsMp4SampleAuxiliaryInfoSizeBox::dumps_detail(std::stringstream &ss, SrsMp4DumpContext dc)
{
- ss << "default_sample_info_size=" << (int)default_sample_info_size << ", sample_count=" << sample_count;
+ ss << "default_sample_info_size=" << (int)default_sample_info_size_ << ", sample_count=" << sample_count_;
return ss;
}
SrsMp4SampleAuxiliaryInfoOffsetBox::SrsMp4SampleAuxiliaryInfoOffsetBox()
{
- type = SrsMp4BoxTypeSAIO;
+ type_ = SrsMp4BoxTypeSAIO;
}
SrsMp4SampleAuxiliaryInfoOffsetBox::~SrsMp4SampleAuxiliaryInfoOffsetBox()
@@ -4970,15 +4970,15 @@ int SrsMp4SampleAuxiliaryInfoOffsetBox::nb_header()
{
int size = SrsMp4FullBox::nb_header();
- if (flags & 0x01) {
+ if (flags_ & 0x01) {
size += 8; // sizeof(aux_info_type) + sizeof(aux_info_type_parameter);
}
size += 4; // sizeof(entry_count);
- if (version == 0) {
- size += offsets.size() * 4;
+ if (version_ == 0) {
+ size += offsets_.size() * 4;
} else {
- size += offsets.size() * 8;
+ size += offsets_.size() * 8;
}
return size;
@@ -4992,15 +4992,15 @@ srs_error_t SrsMp4SampleAuxiliaryInfoOffsetBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- if (flags & 0x01) {
- buf->write_4bytes(aux_info_type);
- buf->write_4bytes(aux_info_type_parameter);
+ if (flags_ & 0x01) {
+ buf->write_4bytes(aux_info_type_);
+ buf->write_4bytes(aux_info_type_parameter_);
}
- buf->write_4bytes(offsets.size());
+ buf->write_4bytes(offsets_.size());
vector::iterator it;
- for (it = offsets.begin(); it != offsets.end(); ++it) {
- if (version == 0) {
+ for (it = offsets_.begin(); it != offsets_.end(); ++it) {
+ if (version_ == 0) {
buf->write_4bytes(*it);
} else {
buf->write_8bytes(*it);
@@ -5018,17 +5018,17 @@ srs_error_t SrsMp4SampleAuxiliaryInfoOffsetBox::decode_header(SrsBuffer *buf)
return srs_error_wrap(err, "decode header");
}
- if (flags & 0x01) {
- aux_info_type = buf->read_4bytes();
- aux_info_type_parameter = buf->read_4bytes();
+ if (flags_ & 0x01) {
+ aux_info_type_ = buf->read_4bytes();
+ aux_info_type_parameter_ = buf->read_4bytes();
}
uint32_t entry_count = buf->read_4bytes();
- for (int i = 0; i < entry_count; i++) {
- if (version == 0) {
- offsets.push_back(buf->read_4bytes());
+ for (int i = 0; i < (int)entry_count; i++) {
+ if (version_ == 0) {
+ offsets_.push_back(buf->read_4bytes());
} else {
- offsets.push_back(buf->read_8bytes());
+ offsets_.push_back(buf->read_8bytes());
}
}
@@ -5037,14 +5037,14 @@ srs_error_t SrsMp4SampleAuxiliaryInfoOffsetBox::decode_header(SrsBuffer *buf)
std::stringstream &SrsMp4SampleAuxiliaryInfoOffsetBox::dumps_detail(std::stringstream &ss, SrsMp4DumpContext dc)
{
- ss << "entry_count=" << offsets.size();
+ ss << "entry_count=" << offsets_.size();
return ss;
}
SrsMp4SubSampleEncryptionInfo::SrsMp4SubSampleEncryptionInfo()
{
- bytes_of_clear_data = 0;
- bytes_of_protected_data = 0;
+ bytes_of_clear_data_ = 0;
+ bytes_of_protected_data_ = 0;
}
SrsMp4SubSampleEncryptionInfo::~SrsMp4SubSampleEncryptionInfo()
@@ -5059,23 +5059,23 @@ uint64_t SrsMp4SubSampleEncryptionInfo::nb_bytes()
srs_error_t SrsMp4SubSampleEncryptionInfo::encode(SrsBuffer *buf)
{
- buf->write_2bytes(bytes_of_clear_data);
- buf->write_4bytes(bytes_of_protected_data);
+ buf->write_2bytes(bytes_of_clear_data_);
+ buf->write_4bytes(bytes_of_protected_data_);
return srs_success;
}
srs_error_t SrsMp4SubSampleEncryptionInfo::decode(SrsBuffer *buf)
{
- bytes_of_clear_data = buf->read_2bytes();
- bytes_of_protected_data = buf->read_4bytes();
+ bytes_of_clear_data_ = buf->read_2bytes();
+ bytes_of_protected_data_ = buf->read_4bytes();
return srs_success;
}
std::stringstream &SrsMp4SubSampleEncryptionInfo::dumps(std::stringstream &ss, SrsMp4DumpContext dc)
{
- ss << "bytes_of_clear_data=" << bytes_of_clear_data << ", bytes_of_protected_data=" << bytes_of_protected_data;
+ ss << "bytes_of_clear_data=" << bytes_of_clear_data_ << ", bytes_of_protected_data=" << bytes_of_protected_data_;
return ss;
}
@@ -5104,9 +5104,9 @@ srs_error_t SrsMp4SampleEncryptionEntry::set_iv(uint8_t *iv, uint8_t iv_size)
uint64_t SrsMp4SampleEncryptionEntry::nb_bytes()
{
uint64_t size = per_sample_iv_size_;
- if (senc_->flags & SrsMp4CencSampleEncryptionUseSubSample) {
+ if (senc_->flags_ & SrsMp4CencSampleEncryptionUseSubSample) {
size += 2; // size of subsample_count
- size += subsample_infos.size() * 6;
+ size += subsample_infos_.size() * 6;
}
return size;
@@ -5118,11 +5118,11 @@ srs_error_t SrsMp4SampleEncryptionEntry::encode(SrsBuffer *buf)
buf->write_bytes((char *)iv_, per_sample_iv_size_);
}
- if (senc_->flags & SrsMp4CencSampleEncryptionUseSubSample) {
- buf->write_2bytes(subsample_infos.size());
+ if (senc_->flags_ & SrsMp4CencSampleEncryptionUseSubSample) {
+ buf->write_2bytes(subsample_infos_.size());
vector::iterator it;
- for (it = subsample_infos.begin(); it != subsample_infos.end(); ++it) {
+ for (it = subsample_infos_.begin(); it != subsample_infos_.end(); ++it) {
(*it).encode(buf);
}
}
@@ -5136,12 +5136,12 @@ srs_error_t SrsMp4SampleEncryptionEntry::decode(SrsBuffer *buf)
buf->read_bytes((char *)iv_, per_sample_iv_size_);
}
- if (senc_->flags & SrsMp4CencSampleEncryptionUseSubSample) {
+ if (senc_->flags_ & SrsMp4CencSampleEncryptionUseSubSample) {
uint16_t subsample_count = buf->read_2bytes();
for (uint16_t i = 0; i < subsample_count; i++) {
SrsMp4SubSampleEncryptionInfo info;
info.decode(buf);
- subsample_infos.push_back(info);
+ subsample_infos_.push_back(info);
}
}
return srs_success;
@@ -5153,7 +5153,7 @@ std::stringstream &SrsMp4SampleEncryptionEntry::dumps(std::stringstream &ss, Srs
ss << "iv=" << iv_ << endl;
vector::iterator it;
- for (it = subsample_infos.begin(); it != subsample_infos.end(); ++it) {
+ for (it = subsample_infos_.begin(); it != subsample_infos_.end(); ++it) {
(*it).dumps(ss, dc);
ss << endl;
}
@@ -5163,9 +5163,9 @@ std::stringstream &SrsMp4SampleEncryptionEntry::dumps(std::stringstream &ss, Srs
SrsMp4SampleEncryptionBox::SrsMp4SampleEncryptionBox(uint8_t per_sample_iv_size)
{
- version = 0;
- flags = SrsMp4CencSampleEncryptionUseSubSample;
- type = SrsMp4BoxTypeSENC;
+ version_ = 0;
+ flags_ = SrsMp4CencSampleEncryptionUseSubSample;
+ type_ = SrsMp4BoxTypeSENC;
srs_assert(per_sample_iv_size == 0 || per_sample_iv_size == 8 || per_sample_iv_size == 16);
per_sample_iv_size_ = per_sample_iv_size;
}
@@ -5173,11 +5173,11 @@ SrsMp4SampleEncryptionBox::SrsMp4SampleEncryptionBox(uint8_t per_sample_iv_size)
SrsMp4SampleEncryptionBox::~SrsMp4SampleEncryptionBox()
{
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); it++) {
+ for (it = entries_.begin(); it != entries_.end(); it++) {
SrsMp4SampleEncryptionEntry *entry = *it;
srs_freep(entry);
}
- entries.clear();
+ entries_.clear();
}
int SrsMp4SampleEncryptionBox::nb_header()
@@ -5185,7 +5185,7 @@ int SrsMp4SampleEncryptionBox::nb_header()
int size = SrsMp4FullBox::nb_header() + 4;
vector::iterator it;
- for (it = entries.begin(); it < entries.end(); it++) {
+ for (it = entries_.begin(); it < entries_.end(); it++) {
size += (*it)->nb_bytes();
}
@@ -5200,9 +5200,9 @@ srs_error_t SrsMp4SampleEncryptionBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes(entries.size());
+ buf->write_4bytes(entries_.size());
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); it++) {
+ for (it = entries_.begin(); it != entries_.end(); it++) {
(*it)->encode(buf);
}
@@ -5218,17 +5218,17 @@ srs_error_t SrsMp4SampleEncryptionBox::decode_header(SrsBuffer *buf)
}
vector::iterator it;
- for (it = entries.begin(); it != entries.end(); it++) {
+ for (it = entries_.begin(); it != entries_.end(); it++) {
SrsMp4SampleEncryptionEntry *entry = *it;
srs_freep(entry);
}
- entries.clear();
+ entries_.clear();
int32_t size = buf->read_4bytes();
for (int i = 0; i < size; i++) {
SrsMp4SampleEncryptionEntry *entry = new SrsMp4SampleEncryptionEntry(this, per_sample_iv_size_);
entry->decode(buf);
- entries.push_back(entry);
+ entries_.push_back(entry);
}
return err;
@@ -5236,13 +5236,13 @@ srs_error_t SrsMp4SampleEncryptionBox::decode_header(SrsBuffer *buf)
std::stringstream &SrsMp4SampleEncryptionBox::dumps_detail(std::stringstream &ss, SrsMp4DumpContext dc)
{
- ss << "sample_count=" << entries.size() << endl;
+ ss << "sample_count=" << entries_.size() << endl;
return ss;
}
SrsMp4ProtectionSchemeInfoBox::SrsMp4ProtectionSchemeInfoBox()
{
- type = SrsMp4BoxTypeSINF;
+ type_ = SrsMp4BoxTypeSINF;
}
SrsMp4ProtectionSchemeInfoBox::~SrsMp4ProtectionSchemeInfoBox()
@@ -5258,7 +5258,7 @@ SrsMp4OriginalFormatBox *SrsMp4ProtectionSchemeInfoBox::frma()
void SrsMp4ProtectionSchemeInfoBox::set_frma(SrsMp4OriginalFormatBox *v)
{
remove(SrsMp4BoxTypeFRMA);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4SchemeTypeBox *SrsMp4ProtectionSchemeInfoBox::schm()
@@ -5270,7 +5270,7 @@ SrsMp4SchemeTypeBox *SrsMp4ProtectionSchemeInfoBox::schm()
void SrsMp4ProtectionSchemeInfoBox::set_schm(SrsMp4SchemeTypeBox *v)
{
remove(SrsMp4BoxTypeSCHM);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4SchemeInfoBox *SrsMp4ProtectionSchemeInfoBox::schi()
@@ -5282,12 +5282,12 @@ SrsMp4SchemeInfoBox *SrsMp4ProtectionSchemeInfoBox::schi()
void SrsMp4ProtectionSchemeInfoBox::set_schi(SrsMp4SchemeInfoBox *v)
{
remove(SrsMp4BoxTypeSCHI);
- boxes.push_back(v);
+ boxes_.push_back(v);
}
SrsMp4OriginalFormatBox::SrsMp4OriginalFormatBox(uint32_t original_format)
{
- type = SrsMp4BoxTypeFRMA;
+ type_ = SrsMp4BoxTypeFRMA;
data_format_ = original_format;
}
@@ -5334,8 +5334,8 @@ std::stringstream &SrsMp4OriginalFormatBox::dumps_detail(std::stringstream &ss,
SrsMp4SchemeTypeBox::SrsMp4SchemeTypeBox()
{
- type = SrsMp4BoxTypeSCHM;
- scheme_uri_size = 0;
+ type_ = SrsMp4BoxTypeSCHM;
+ scheme_uri_size_ = 0;
}
SrsMp4SchemeTypeBox::~SrsMp4SchemeTypeBox()
@@ -5345,17 +5345,17 @@ SrsMp4SchemeTypeBox::~SrsMp4SchemeTypeBox()
void SrsMp4SchemeTypeBox::set_scheme_uri(char *uri, uint32_t uri_size)
{
srs_assert(uri_size < SCHM_SCHEME_URI_MAX_SIZE);
- memcpy(scheme_uri, uri, uri_size);
- scheme_uri_size = uri_size;
- scheme_uri[uri_size] = '\0';
+ memcpy(scheme_uri_, uri, uri_size);
+ scheme_uri_size_ = uri_size;
+ scheme_uri_[uri_size] = '\0';
}
int SrsMp4SchemeTypeBox::nb_header()
{
int size = SrsMp4FullBox::nb_header() + 4 + 4; // sizeof(scheme_type) + sizeof(scheme_version)
- if (flags & 0x01) {
- size += scheme_uri_size;
+ if (flags_ & 0x01) {
+ size += scheme_uri_size_;
}
return size;
@@ -5369,11 +5369,11 @@ srs_error_t SrsMp4SchemeTypeBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_4bytes(scheme_type);
- buf->write_4bytes(scheme_version);
+ buf->write_4bytes(scheme_type_);
+ buf->write_4bytes(scheme_version_);
- if (flags & 0x01) {
- buf->write_bytes(scheme_uri, scheme_uri_size);
+ if (flags_ & 0x01) {
+ buf->write_bytes(scheme_uri_, scheme_uri_size_);
buf->write_1bytes(0);
}
@@ -5387,21 +5387,21 @@ srs_error_t SrsMp4SchemeTypeBox::decode_header(SrsBuffer *buf)
if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) {
return srs_error_wrap(err, "decode header");
}
- scheme_type = buf->read_4bytes();
- scheme_version = buf->read_4bytes();
+ scheme_type_ = buf->read_4bytes();
+ scheme_version_ = buf->read_4bytes();
- if (flags & 0x01) {
- memset(scheme_uri, 0, SCHM_SCHEME_URI_MAX_SIZE);
+ if (flags_ & 0x01) {
+ memset(scheme_uri_, 0, SCHM_SCHEME_URI_MAX_SIZE);
int s = 0;
while (s < SCHM_SCHEME_URI_MAX_SIZE - 1) {
char c = buf->read_1bytes();
- scheme_uri[s] = c;
+ scheme_uri_[s] = c;
s++;
if (c == '\0') {
break;
}
}
- scheme_uri_size = s;
+ scheme_uri_size_ = s;
}
return err;
@@ -5409,9 +5409,9 @@ srs_error_t SrsMp4SchemeTypeBox::decode_header(SrsBuffer *buf)
std::stringstream &SrsMp4SchemeTypeBox::dumps_detail(std::stringstream &ss, SrsMp4DumpContext dc)
{
- ss << "scheme_type=" << scheme_type << ", scheme_version=" << scheme_version << endl;
- if (flags & 0x01) {
- ss << "scheme_uri=" << scheme_uri << endl;
+ ss << "scheme_type=" << scheme_type_ << ", scheme_version=" << scheme_version_ << endl;
+ if (flags_ & 0x01) {
+ ss << "scheme_uri=" << scheme_uri_ << endl;
}
return ss;
@@ -5419,7 +5419,7 @@ std::stringstream &SrsMp4SchemeTypeBox::dumps_detail(std::stringstream &ss, SrsM
SrsMp4SchemeInfoBox::SrsMp4SchemeInfoBox()
{
- type = SrsMp4BoxTypeSCHI;
+ type_ = SrsMp4BoxTypeSCHI;
}
SrsMp4SchemeInfoBox::~SrsMp4SchemeInfoBox()
@@ -5428,7 +5428,7 @@ SrsMp4SchemeInfoBox::~SrsMp4SchemeInfoBox()
SrsMp4TrackEncryptionBox::SrsMp4TrackEncryptionBox()
{
- type = SrsMp4BoxTypeTENC;
+ type_ = SrsMp4BoxTypeTENC;
}
SrsMp4TrackEncryptionBox::~SrsMp4TrackEncryptionBox()
@@ -5438,8 +5438,8 @@ SrsMp4TrackEncryptionBox::~SrsMp4TrackEncryptionBox()
void SrsMp4TrackEncryptionBox::set_default_constant_IV(uint8_t *iv, uint8_t iv_size)
{
srs_assert(iv_size == 8 || iv_size == 16);
- memcpy(default_constant_IV, iv, iv_size);
- default_constant_IV_size = iv_size;
+ memcpy(default_constant_IV_, iv, iv_size);
+ default_constant_IV_size_ = iv_size;
}
int SrsMp4TrackEncryptionBox::nb_header()
@@ -5450,8 +5450,8 @@ int SrsMp4TrackEncryptionBox::nb_header()
size += 1; // sizeof(default_isProtected);
size += 1; // sizeof(default_Per_Sample_IV_Size;
size += 16; // sizeof(default_KID);
- if (default_is_protected == 1 && default_per_sample_IV_size == 0) {
- size += 1 + default_constant_IV_size; // sizeof(default_constant_IV_size) + sizeof(default_constant_IV);
+ if (default_is_protected_ == 1 && default_per_sample_IV_size_ == 0) {
+ size += 1 + default_constant_IV_size_; // sizeof(default_constant_IV_size) + sizeof(default_constant_IV);
}
return size;
@@ -5465,19 +5465,19 @@ srs_error_t SrsMp4TrackEncryptionBox::encode_header(SrsBuffer *buf)
return srs_error_wrap(err, "encode header");
}
- buf->write_1bytes(reserved);
- if (version == 0) {
- buf->write_1bytes(reserved_2);
+ buf->write_1bytes(reserved_);
+ if (version_ == 0) {
+ buf->write_1bytes(reserved_2_);
} else {
- buf->write_1bytes((default_crypt_byte_block << 4) | (default_skip_byte_block & 0x0F));
+ buf->write_1bytes((default_crypt_byte_block_ << 4) | (default_skip_byte_block_ & 0x0F));
}
- buf->write_1bytes(default_is_protected);
- buf->write_1bytes(default_per_sample_IV_size);
- buf->write_bytes((char *)default_KID, 16);
- if (default_is_protected == 1 && default_per_sample_IV_size == 0) {
- buf->write_1bytes(default_constant_IV_size);
- buf->write_bytes((char *)default_constant_IV, default_constant_IV_size);
+ buf->write_1bytes(default_is_protected_);
+ buf->write_1bytes(default_per_sample_IV_size_);
+ buf->write_bytes((char *)default_KID_, 16);
+ if (default_is_protected_ == 1 && default_per_sample_IV_size_ == 0) {
+ buf->write_1bytes(default_constant_IV_size_);
+ buf->write_bytes((char *)default_constant_IV_, default_constant_IV_size_);
}
return err;
@@ -5490,23 +5490,23 @@ srs_error_t SrsMp4TrackEncryptionBox::decode_header(SrsBuffer *buf)
if ((err = SrsMp4FullBox::decode_header(buf)) != srs_success) {
return srs_error_wrap(err, "encode header");
}
- reserved = buf->read_1bytes();
- if (version == 0) {
- reserved_2 = buf->read_1bytes();
+ reserved_ = buf->read_1bytes();
+ if (version_ == 0) {
+ reserved_2_ = buf->read_1bytes();
} else {
uint8_t v = buf->read_1bytes();
- default_crypt_byte_block = v >> 4;
- default_skip_byte_block = v & 0x0f;
+ default_crypt_byte_block_ = v >> 4;
+ default_skip_byte_block_ = v & 0x0f;
}
- default_is_protected = buf->read_1bytes();
- default_per_sample_IV_size = buf->read_1bytes();
- buf->read_bytes((char *)default_KID, 16);
+ default_is_protected_ = buf->read_1bytes();
+ default_per_sample_IV_size_ = buf->read_1bytes();
+ buf->read_bytes((char *)default_KID_, 16);
- if (default_is_protected == 1 && default_per_sample_IV_size == 0) {
- default_constant_IV_size = buf->read_1bytes();
- srs_assert(default_constant_IV_size == 8 || default_constant_IV_size == 16);
- buf->read_bytes((char *)default_constant_IV, default_constant_IV_size);
+ if (default_is_protected_ == 1 && default_per_sample_IV_size_ == 0) {
+ default_constant_IV_size_ = buf->read_1bytes();
+ srs_assert(default_constant_IV_size_ == 8 || default_constant_IV_size_ == 16);
+ buf->read_bytes((char *)default_constant_IV_, default_constant_IV_size_);
}
return err;
@@ -5514,40 +5514,40 @@ srs_error_t SrsMp4TrackEncryptionBox::decode_header(SrsBuffer *buf)
std::stringstream &SrsMp4TrackEncryptionBox::dumps_detail(std::stringstream &ss, SrsMp4DumpContext dc)
{
- if (version != 0) {
- ss << "default_crypt_byte_block=" << default_crypt_byte_block << ", default_skip_byte_block=" << default_skip_byte_block << endl;
+ if (version_ != 0) {
+ ss << "default_crypt_byte_block=" << default_crypt_byte_block_ << ", default_skip_byte_block=" << default_skip_byte_block_ << endl;
}
- ss << "default_isProtected=" << default_is_protected << ", default_per_sample_IV_size=" << default_per_sample_IV_size << endl;
+ ss << "default_isProtected=" << default_is_protected_ << ", default_per_sample_IV_size=" << default_per_sample_IV_size_ << endl;
return ss;
}
SrsMp4Sample::SrsMp4Sample()
{
- type = SrsFrameTypeForbidden;
- offset = 0;
- index = 0;
- dts = pts = 0;
- nb_data = 0;
- data = NULL;
- frame_type = SrsVideoAvcFrameTypeForbidden;
- tbn = 0;
- adjust = 0;
+ type_ = SrsFrameTypeForbidden;
+ offset_ = 0;
+ index_ = 0;
+ dts_ = pts_ = 0;
+ nb_data_ = 0;
+ data_ = NULL;
+ frame_type_ = SrsVideoAvcFrameTypeForbidden;
+ tbn_ = 0;
+ adjust_ = 0;
}
SrsMp4Sample::~SrsMp4Sample()
{
- srs_freepa(data);
+ srs_freepa(data_);
}
uint32_t SrsMp4Sample::dts_ms()
{
- return (uint32_t)(dts * 1000 / tbn) + adjust;
+ return (uint32_t)(dts_ * 1000 / tbn_) + adjust_;
}
uint32_t SrsMp4Sample::pts_ms()
{
- return (uint32_t)(pts * 1000 / tbn) + adjust;
+ return (uint32_t)(pts_ * 1000 / tbn_) + adjust_;
}
SrsMp4DvrJitter::SrsMp4DvrJitter()
@@ -5561,14 +5561,14 @@ SrsMp4DvrJitter::~SrsMp4DvrJitter()
void SrsMp4DvrJitter::on_sample(SrsMp4Sample *sample)
{
- if (!has_first_audio_ && sample->type == SrsFrameTypeAudio) {
+ if (!has_first_audio_ && sample->type_ == SrsFrameTypeAudio) {
has_first_audio_ = true;
- audio_start_dts_ = sample->dts;
+ audio_start_dts_ = sample->dts_;
}
- if (!has_first_video_ && sample->type == SrsFrameTypeVideo) {
+ if (!has_first_video_ && sample->type_ == SrsFrameTypeVideo) {
has_first_video_ = true;
- video_start_dts_ = sample->dts;
+ video_start_dts_ = sample->dts_;
}
}
@@ -5605,11 +5605,11 @@ SrsMp4SampleManager::~SrsMp4SampleManager()
srs_freep(jitter_);
vector::iterator it;
- for (it = samples.begin(); it != samples.end(); ++it) {
+ for (it = samples_.begin(); it != samples_.end(); ++it) {
SrsMp4Sample *sample = *it;
srs_freep(sample);
}
- samples.clear();
+ samples_.clear();
}
srs_error_t SrsMp4SampleManager::load(SrsMp4MovieBox *moov)
@@ -5638,9 +5638,9 @@ srs_error_t SrsMp4SampleManager::load(SrsMp4MovieBox *moov)
map::iterator it;
for (it = tses.begin(); it != tses.end(); ++it) {
SrsMp4Sample *sample = it->second;
- samples.push_back(sample);
+ samples_.push_back(sample);
- if (sample->type == SrsFrameTypeVideo) {
+ if (sample->type_ == SrsFrameTypeVideo) {
pvideo = sample;
} else if (pvideo) {
int32_t diff = sample->dts_ms() - pvideo->dts_ms();
@@ -5661,8 +5661,8 @@ srs_error_t SrsMp4SampleManager::load(SrsMp4MovieBox *moov)
map::iterator it;
for (it = tses.begin(); it != tses.end(); ++it) {
SrsMp4Sample *sample = it->second;
- if (sample->type == SrsFrameTypeAudio) {
- sample->adjust = 0 - maxp - maxn;
+ if (sample->type_ == SrsFrameTypeAudio) {
+ sample->adjust_ = 0 - maxp - maxn;
}
}
}
@@ -5672,8 +5672,8 @@ srs_error_t SrsMp4SampleManager::load(SrsMp4MovieBox *moov)
SrsMp4Sample *SrsMp4SampleManager::at(uint32_t index)
{
- if (index < samples.size()) {
- return samples.at(index);
+ if (index < samples_.size()) {
+ return samples_.at(index);
}
return NULL;
}
@@ -5681,7 +5681,7 @@ SrsMp4Sample *SrsMp4SampleManager::at(uint32_t index)
void SrsMp4SampleManager::append(SrsMp4Sample *sample)
{
jitter_->on_sample(sample);
- samples.push_back(sample);
+ samples_.push_back(sample);
}
srs_error_t SrsMp4SampleManager::write(SrsMp4MovieBox *moov)
@@ -5692,9 +5692,9 @@ srs_error_t SrsMp4SampleManager::write(SrsMp4MovieBox *moov)
if (vide) {
bool has_cts = false;
vector::iterator it;
- for (it = samples.begin(); it != samples.end(); ++it) {
+ for (it = samples_.begin(); it != samples_.end(); ++it) {
SrsMp4Sample *sample = *it;
- if (sample->dts != sample->pts && sample->type == SrsFrameTypeVideo) {
+ if (sample->dts_ != sample->pts_ && sample->type_ == SrsFrameTypeVideo) {
has_cts = true;
break;
}
@@ -5722,7 +5722,7 @@ srs_error_t SrsMp4SampleManager::write(SrsMp4MovieBox *moov)
SrsMp4FullBox *co = NULL;
// When sample offset less than UINT32_MAX, we use stco(support 32bit offset) box to save storage space.
- if (samples.empty() || (*samples.rbegin())->offset < UINT32_MAX) {
+ if (samples_.empty() || (*samples_.rbegin())->offset_ < UINT32_MAX) {
// stco support 32bit offset.
co = new SrsMp4ChunkOffsetBox();
stbl->set_stco(static_cast(co));
@@ -5754,7 +5754,7 @@ srs_error_t SrsMp4SampleManager::write(SrsMp4MovieBox *moov)
stbl->set_stsz(stsz);
SrsMp4FullBox *co = NULL;
- if (samples.empty() || (*samples.rbegin())->offset < UINT32_MAX) {
+ if (samples_.empty() || (*samples_.rbegin())->offset_ < UINT32_MAX) {
co = new SrsMp4ChunkOffsetBox();
stbl->set_stco(static_cast(co));
} else {
@@ -5775,36 +5775,36 @@ srs_error_t SrsMp4SampleManager::write(SrsMp4TrackFragmentBox *traf, uint64_t dt
srs_error_t err = srs_success;
SrsMp4TrackFragmentRunBox *trun = traf->trun();
- trun->flags = SrsMp4TrunFlagsDataOffset | SrsMp4TrunFlagsSampleDuration | SrsMp4TrunFlagsSampleSize | SrsMp4TrunFlagsSampleFlag | SrsMp4TrunFlagsSampleCtsOffset;
+ trun->flags_ = SrsMp4TrunFlagsDataOffset | SrsMp4TrunFlagsSampleDuration | SrsMp4TrunFlagsSampleSize | SrsMp4TrunFlagsSampleFlag | SrsMp4TrunFlagsSampleCtsOffset;
SrsMp4Sample *previous = NULL;
vector::iterator it;
- for (it = samples.begin(); it != samples.end(); ++it) {
+ for (it = samples_.begin(); it != samples_.end(); ++it) {
SrsMp4Sample *sample = *it;
SrsMp4TrunEntry *entry = new SrsMp4TrunEntry(trun);
if (!previous) {
previous = sample;
- entry->sample_flags = 0x02000000;
+ entry->sample_flags_ = 0x02000000;
} else {
- entry->sample_flags = 0x01000000;
+ entry->sample_flags_ = 0x01000000;
}
vector::iterator iter = (it + 1);
- if (iter == samples.end()) {
- entry->sample_duration = dts - sample->dts;
+ if (iter == samples_.end()) {
+ entry->sample_duration_ = dts - sample->dts_;
} else {
- entry->sample_duration = (*iter)->dts - sample->dts;
+ entry->sample_duration_ = (*iter)->dts_ - sample->dts_;
}
- entry->sample_size = sample->nb_data;
- entry->sample_composition_time_offset = (int64_t)(sample->pts - sample->dts);
- if (entry->sample_composition_time_offset < 0) {
- trun->version = 1;
+ entry->sample_size_ = sample->nb_data_;
+ entry->sample_composition_time_offset_ = (int64_t)(sample->pts_ - sample->dts_);
+ if (entry->sample_composition_time_offset_ < 0) {
+ trun->version_ = 1;
}
- trun->entries.push_back(entry);
+ trun->entries_.push_back(entry);
}
return err;
@@ -5828,84 +5828,84 @@ srs_error_t SrsMp4SampleManager::write_track(SrsFrameType track,
SrsMp4Sample *previous = NULL;
vector::iterator it;
- for (it = samples.begin(); it != samples.end(); ++it) {
+ for (it = samples_.begin(); it != samples_.end(); ++it) {
SrsMp4Sample *sample = *it;
- if (sample->type != track) {
+ if (sample->type_ != track) {
continue;
}
- stsz_entries.push_back(sample->nb_data);
- co_entries.push_back((uint64_t)sample->offset);
+ stsz_entries.push_back(sample->nb_data_);
+ co_entries.push_back((uint64_t)sample->offset_);
- if (sample->frame_type == SrsVideoAvcFrameTypeKeyFrame) {
- stss_entries.push_back(sample->index + 1);
+ if (sample->frame_type_ == SrsVideoAvcFrameTypeKeyFrame) {
+ stss_entries.push_back(sample->index_ + 1);
}
if (stts) {
if (previous) {
- uint32_t delta = (uint32_t)(sample->dts - previous->dts);
- if (stts_entry.sample_delta == 0 || stts_entry.sample_delta == delta) {
- stts_entry.sample_delta = delta;
- stts_entry.sample_count++;
+ uint32_t delta = (uint32_t)(sample->dts_ - previous->dts_);
+ if (stts_entry.sample_delta_ == 0 || stts_entry.sample_delta_ == delta) {
+ stts_entry.sample_delta_ = delta;
+ stts_entry.sample_count_++;
} else {
stts_entries.push_back(stts_entry);
- stts_entry.sample_count = 1;
- stts_entry.sample_delta = delta;
+ stts_entry.sample_count_ = 1;
+ stts_entry.sample_delta_ = delta;
}
} else {
// The first sample always in the STTS table.
- stts_entry.sample_count++;
- stts_entry.sample_delta = jitter_->get_first_sample_delta(track);
+ stts_entry.sample_count_++;
+ stts_entry.sample_delta_ = jitter_->get_first_sample_delta(track);
}
}
if (ctts) {
- int64_t offset = sample->pts - sample->dts;
+ int64_t offset = sample->pts_ - sample->dts_;
if (offset < 0) {
- ctts->version = 0x01;
+ ctts->version_ = 0x01;
}
- if (ctts_entry.sample_count == 0 || ctts_entry.sample_offset == offset) {
- ctts_entry.sample_count++;
+ if (ctts_entry.sample_count_ == 0 || ctts_entry.sample_offset_ == offset) {
+ ctts_entry.sample_count_++;
} else {
ctts_entries.push_back(ctts_entry);
- ctts_entry.sample_offset = offset;
- ctts_entry.sample_count = 1;
+ ctts_entry.sample_offset_ = offset;
+ ctts_entry.sample_count_ = 1;
}
}
previous = sample;
}
- if (stts && stts_entry.sample_count) {
+ if (stts && stts_entry.sample_count_) {
stts_entries.push_back(stts_entry);
}
- if (ctts && ctts_entry.sample_count) {
+ if (ctts && ctts_entry.sample_count_) {
ctts_entries.push_back(ctts_entry);
}
if (stts && !stts_entries.empty()) {
- stts->entries = stts_entries;
+ stts->entries_ = stts_entries;
}
if (ctts && !ctts_entries.empty()) {
- ctts->entries = ctts_entries;
+ ctts->entries_ = ctts_entries;
}
if (stsc) {
- stsc->entry_count = 1;
- stsc->entries = new SrsMp4StscEntry[1];
+ stsc->entry_count_ = 1;
+ stsc->entries_ = new SrsMp4StscEntry[1];
- SrsMp4StscEntry &v = stsc->entries[0];
- v.first_chunk = v.sample_description_index = v.samples_per_chunk = 1;
+ SrsMp4StscEntry &v = stsc->entries_[0];
+ v.first_chunk_ = v.sample_description_index_ = v.samples_per_chunk_ = 1;
}
if (stsz && !stsz_entries.empty()) {
- stsz->sample_size = 0;
- stsz->sample_count = (uint32_t)stsz_entries.size();
- stsz->entry_sizes = new uint32_t[stsz->sample_count];
- for (int i = 0; i < (int)stsz->sample_count; i++) {
- stsz->entry_sizes[i] = stsz_entries.at(i);
+ stsz->sample_size_ = 0;
+ stsz->sample_count_ = (uint32_t)stsz_entries.size();
+ stsz->entry_sizes_ = new uint32_t[stsz->sample_count_];
+ for (int i = 0; i < (int)stsz->sample_count_; i++) {
+ stsz->entry_sizes_[i] = stsz_entries.at(i);
}
}
@@ -5914,25 +5914,25 @@ srs_error_t SrsMp4SampleManager::write_track(SrsFrameType track,
SrsMp4ChunkLargeOffsetBox *co64 = dynamic_cast(co);
if (stco) {
- stco->entry_count = (uint32_t)co_entries.size();
- stco->entries = new uint32_t[stco->entry_count];
- for (int i = 0; i < (int)stco->entry_count; i++) {
- stco->entries[i] = co_entries.at(i);
+ stco->entry_count_ = (uint32_t)co_entries.size();
+ stco->entries_ = new uint32_t[stco->entry_count_];
+ for (int i = 0; i < (int)stco->entry_count_; i++) {
+ stco->entries_[i] = co_entries.at(i);
}
} else if (co64) {
- co64->entry_count = (uint32_t)co_entries.size();
- co64->entries = new uint64_t[co64->entry_count];
- for (int i = 0; i < (int)co64->entry_count; i++) {
- co64->entries[i] = co_entries.at(i);
+ co64->entry_count_ = (uint32_t)co_entries.size();
+ co64->entries_ = new uint64_t[co64->entry_count_];
+ for (int i = 0; i < (int)co64->entry_count_; i++) {
+ co64->entries_[i] = co_entries.at(i);
}
}
}
if (stss && !stss_entries.empty()) {
- stss->entry_count = (uint32_t)stss_entries.size();
- stss->sample_numbers = new uint32_t[stss->entry_count];
- for (int i = 0; i < (int)stss->entry_count; i++) {
- stss->sample_numbers[i] = stss_entries.at(i);
+ stss->entry_count_ = (uint32_t)stss_entries.size();
+ stss->sample_numbers_ = new uint32_t[stss->entry_count_];
+ for (int i = 0; i < (int)stss->entry_count_; i++) {
+ stss->sample_numbers_[i] = stss_entries.at(i);
}
}
@@ -6008,64 +6008,64 @@ srs_error_t SrsMp4SampleManager::load_trak(map &tses,
SrsMp4Sample *previous = NULL;
// For each chunk offset.
- for (uint32_t ci = 0; ci < stco->entry_count; ci++) {
+ for (uint32_t ci = 0; ci < stco->entry_count_; ci++) {
// The sample offset relative in chunk.
uint32_t sample_relative_offset = 0;
// Find how many samples from stsc.
SrsMp4StscEntry *stsc_entry = stsc->on_chunk(ci);
- for (uint32_t i = 0; i < stsc_entry->samples_per_chunk; i++) {
+ for (uint32_t i = 0; i < stsc_entry->samples_per_chunk_; i++) {
SrsMp4Sample *sample = new SrsMp4Sample();
- sample->type = tt;
- sample->index = (previous ? previous->index + 1 : 0);
- sample->tbn = mdhd->timescale;
- sample->offset = stco->entries[ci] + sample_relative_offset;
+ sample->type_ = tt;
+ sample->index_ = (previous ? previous->index_ + 1 : 0);
+ sample->tbn_ = mdhd->timescale_;
+ sample->offset_ = stco->entries_[ci] + sample_relative_offset;
uint32_t sample_size = 0;
- if ((err = stsz->get_sample_size(sample->index, &sample_size)) != srs_success) {
+ if ((err = stsz->get_sample_size(sample->index_, &sample_size)) != srs_success) {
srs_freep(sample);
return srs_error_wrap(err, "stsz get sample size");
}
sample_relative_offset += sample_size;
SrsMp4SttsEntry *stts_entry = NULL;
- if ((err = stts->on_sample(sample->index, &stts_entry)) != srs_success) {
+ if ((err = stts->on_sample(sample->index_, &stts_entry)) != srs_success) {
srs_freep(sample);
return srs_error_wrap(err, "stts on sample");
}
if (previous) {
- sample->pts = sample->dts = previous->dts + stts_entry->sample_delta;
+ sample->pts_ = sample->dts_ = previous->dts_ + stts_entry->sample_delta_;
}
SrsMp4CttsEntry *ctts_entry = NULL;
- if (ctts && (err = ctts->on_sample(sample->index, &ctts_entry)) != srs_success) {
+ if (ctts && (err = ctts->on_sample(sample->index_, &ctts_entry)) != srs_success) {
srs_freep(sample);
return srs_error_wrap(err, "ctts on sample");
}
if (ctts_entry) {
- sample->pts = sample->dts + ctts_entry->sample_offset;
+ sample->pts_ = sample->dts_ + ctts_entry->sample_offset_;
}
if (tt == SrsFrameTypeVideo) {
- if (!stss || stss->is_sync(sample->index)) {
- sample->frame_type = SrsVideoAvcFrameTypeKeyFrame;
+ if (!stss || stss->is_sync(sample->index_)) {
+ sample->frame_type_ = SrsVideoAvcFrameTypeKeyFrame;
} else {
- sample->frame_type = SrsVideoAvcFrameTypeInterFrame;
+ sample->frame_type_ = SrsVideoAvcFrameTypeInterFrame;
}
}
// Only set the sample size, read data from io when needed.
- sample->nb_data = sample_size;
- sample->data = NULL;
+ sample->nb_data_ = sample_size;
+ sample->data_ = NULL;
previous = sample;
- tses[sample->offset] = sample;
+ tses[sample->offset_] = sample;
}
}
// Check total samples.
- if (previous && previous->index + 1 != stsz->sample_count) {
- return srs_error_new(ERROR_MP4_ILLEGAL_SAMPLES, "illegal samples count, expect=%d, actual=%d", stsz->sample_count, previous->index + 1);
+ if (previous && previous->index_ + 1 != stsz->sample_count_) {
+ return srs_error_new(ERROR_MP4_ILLEGAL_SAMPLES, "illegal samples count, expect=%d, actual=%d", stsz->sample_count_, previous->index_ + 1);
}
return err;
@@ -6073,18 +6073,18 @@ srs_error_t SrsMp4SampleManager::load_trak(map &tses,
SrsMp4BoxReader::SrsMp4BoxReader()
{
- rsio = NULL;
- buf = new char[SRS_MP4_BUF_SIZE];
+ rsio_ = NULL;
+ buf_ = new char[SRS_MP4_BUF_SIZE];
}
SrsMp4BoxReader::~SrsMp4BoxReader()
{
- srs_freepa(buf);
+ srs_freepa(buf_);
}
srs_error_t SrsMp4BoxReader::initialize(ISrsReadSeeker *rs)
{
- rsio = rs;
+ rsio_ = rs;
return srs_success;
}
@@ -6122,12 +6122,12 @@ srs_error_t SrsMp4BoxReader::do_read(SrsSimpleStream *stream, SrsMp4Box *&box)
// Fill the stream util we can discovery box.
while (stream->length() < (int)required) {
ssize_t nread;
- if ((err = rsio->read(buf, SRS_MP4_BUF_SIZE, &nread)) != srs_success) {
+ if ((err = rsio_->read(buf_, SRS_MP4_BUF_SIZE, &nread)) != srs_success) {
return srs_error_wrap(err, "load failed, nread=%d, required=%d", (int)nread, (int)required);
}
srs_assert(nread > 0);
- stream->append(buf, (int)nread);
+ stream->append(buf_, (int)nread);
}
SrsUniquePtr buffer(new SrsBuffer(stream->bytes(), stream->length()));
@@ -6166,7 +6166,7 @@ srs_error_t SrsMp4BoxReader::skip(SrsMp4Box *box, SrsSimpleStream *stream)
} else {
stream->erase(stream->length());
}
- if (offset > 0 && (err = rsio->lseek(offset, SEEK_CUR, NULL)) != srs_success) {
+ if (offset > 0 && (err = rsio_->lseek(offset, SEEK_CUR, NULL)) != srs_success) {
return srs_error_wrap(err, "io seek");
}
} else {
@@ -6179,26 +6179,26 @@ srs_error_t SrsMp4BoxReader::skip(SrsMp4Box *box, SrsSimpleStream *stream)
SrsMp4Decoder::SrsMp4Decoder()
{
- rsio = NULL;
- brand = SrsMp4BoxBrandForbidden;
- stream = new SrsSimpleStream();
- vcodec = SrsVideoCodecIdForbidden;
- acodec = SrsAudioCodecIdForbidden;
- asc_written = avcc_written = false;
- sample_rate = SrsAudioSampleRateForbidden;
- sound_bits = SrsAudioSampleBitsForbidden;
- channels = SrsAudioChannelsForbidden;
- samples = new SrsMp4SampleManager();
- br = new SrsMp4BoxReader();
- current_index = 0;
- current_offset = 0;
+ rsio_ = NULL;
+ brand_ = SrsMp4BoxBrandForbidden;
+ stream_ = new SrsSimpleStream();
+ vcodec_ = SrsVideoCodecIdForbidden;
+ acodec_ = SrsAudioCodecIdForbidden;
+ asc_written_ = avcc_written_ = false;
+ sample_rate_ = SrsAudioSampleRateForbidden;
+ sound_bits_ = SrsAudioSampleBitsForbidden;
+ channels_ = SrsAudioChannelsForbidden;
+ samples_ = new SrsMp4SampleManager();
+ br_ = new SrsMp4BoxReader();
+ current_index_ = 0;
+ current_offset_ = 0;
}
SrsMp4Decoder::~SrsMp4Decoder()
{
- srs_freep(br);
- srs_freep(stream);
- srs_freep(samples);
+ srs_freep(br_);
+ srs_freep(stream_);
+ srs_freep(samples_);
}
srs_error_t SrsMp4Decoder::initialize(ISrsReadSeeker *rs)
@@ -6206,9 +6206,9 @@ srs_error_t SrsMp4Decoder::initialize(ISrsReadSeeker *rs)
srs_error_t err = srs_success;
srs_assert(rs);
- rsio = rs;
+ rsio_ = rs;
- if ((err = br->initialize(rs)) != srs_success) {
+ if ((err = br_->initialize(rs)) != srs_success) {
return srs_error_wrap(err, "init box reader");
}
@@ -6229,7 +6229,7 @@ srs_error_t SrsMp4Decoder::initialize(ISrsReadSeeker *rs)
}
} else if (box->is_mdat()) {
off_t cur = 0;
- if ((err = rsio->lseek(0, SEEK_CUR, &cur)) != srs_success) {
+ if ((err = rsio_->lseek(0, SEEK_CUR, &cur)) != srs_success) {
return srs_error_wrap(err, "io seek");
}
offset = off_t(cur - box->sz());
@@ -6242,13 +6242,13 @@ srs_error_t SrsMp4Decoder::initialize(ISrsReadSeeker *rs)
}
}
- if (brand == SrsMp4BoxBrandForbidden) {
+ if (brand_ == SrsMp4BoxBrandForbidden) {
return srs_error_new(ERROR_MP4_BOX_ILLEGAL_SCHEMA, "missing ftyp");
}
// Set the offset to the mdat.
if (offset >= 0) {
- if ((err = rsio->lseek(offset, SEEK_SET, ¤t_offset)) != srs_success) {
+ if ((err = rsio_->lseek(offset, SEEK_SET, ¤t_offset_)) != srs_success) {
return srs_error_wrap(err, "seek to mdat");
}
}
@@ -6260,14 +6260,14 @@ srs_error_t SrsMp4Decoder::read_sample(SrsMp4HandlerType *pht, uint16_t *pft, ui
{
srs_error_t err = srs_success;
- if (!avcc_written && !pavcc.empty()) {
- avcc_written = true;
+ if (!avcc_written_ && !pavcc_.empty()) {
+ avcc_written_ = true;
*pdts = *ppts = 0;
*pht = SrsMp4HandlerTypeVIDE;
- uint32_t nb_sample = *pnb_sample = (uint32_t)pavcc.size();
+ uint32_t nb_sample = *pnb_sample = (uint32_t)pavcc_.size();
uint8_t *sample = *psample = new uint8_t[nb_sample];
- memcpy(sample, &pavcc[0], nb_sample);
+ memcpy(sample, &pavcc_[0], nb_sample);
*pft = SrsVideoAvcFrameTypeKeyFrame;
*pct = SrsVideoAvcFrameTraitSequenceHeader;
@@ -6275,14 +6275,14 @@ srs_error_t SrsMp4Decoder::read_sample(SrsMp4HandlerType *pht, uint16_t *pft, ui
return err;
}
- if (!asc_written && !pasc.empty()) {
- asc_written = true;
+ if (!asc_written_ && !pasc_.empty()) {
+ asc_written_ = true;
*pdts = *ppts = 0;
*pht = SrsMp4HandlerTypeSOUN;
- uint32_t nb_sample = *pnb_sample = (uint32_t)pasc.size();
+ uint32_t nb_sample = *pnb_sample = (uint32_t)pasc_.size();
uint8_t *sample = *psample = new uint8_t[nb_sample];
- memcpy(sample, &pasc[0], nb_sample);
+ memcpy(sample, &pasc_[0], nb_sample);
*pft = 0x00;
*pct = SrsAudioAacFrameTraitSequenceHeader;
@@ -6290,12 +6290,12 @@ srs_error_t SrsMp4Decoder::read_sample(SrsMp4HandlerType *pht, uint16_t *pft, ui
return err;
}
- SrsMp4Sample *ps = samples->at(current_index++);
+ SrsMp4Sample *ps = samples_->at(current_index_++);
if (!ps) {
return srs_error_new(ERROR_SYSTEM_FILE_EOF, "EOF");
}
- if (ps->type == SrsFrameTypeVideo) {
+ if (ps->type_ == SrsFrameTypeVideo) {
*pht = SrsMp4HandlerTypeVIDE;
*pct = SrsVideoAvcFrameTraitNALU;
} else {
@@ -6304,26 +6304,26 @@ srs_error_t SrsMp4Decoder::read_sample(SrsMp4HandlerType *pht, uint16_t *pft, ui
}
*pdts = ps->dts_ms();
*ppts = ps->pts_ms();
- *pft = ps->frame_type;
+ *pft = ps->frame_type_;
// Read sample from io, for we never preload the samples(too large).
- if (ps->offset != current_offset) {
- if ((err = rsio->lseek(ps->offset, SEEK_SET, ¤t_offset)) != srs_success) {
+ if (ps->offset_ != current_offset_) {
+ if ((err = rsio_->lseek(ps->offset_, SEEK_SET, ¤t_offset_)) != srs_success) {
return srs_error_wrap(err, "seek to sample");
}
}
- uint32_t nb_sample = ps->nb_data;
+ uint32_t nb_sample = ps->nb_data_;
uint8_t *sample = new uint8_t[nb_sample];
// TODO: FIXME: Use fully read.
- if ((err = rsio->read(sample, nb_sample, NULL)) != srs_success) {
+ if ((err = rsio_->read(sample, nb_sample, NULL)) != srs_success) {
srs_freepa(sample);
return srs_error_wrap(err, "read sample");
}
*psample = sample;
*pnb_sample = nb_sample;
- current_offset += nb_sample;
+ current_offset_ += nb_sample;
return err;
}
@@ -6338,16 +6338,16 @@ srs_error_t SrsMp4Decoder::parse_ftyp(SrsMp4FileTypeBox *ftyp)
SrsMp4BoxBrandISOM, SrsMp4BoxBrandISO2, SrsMp4BoxBrandAVC1, SrsMp4BoxBrandMP41,
SrsMp4BoxBrandISO5};
for (int i = 0; i < (int)(sizeof(legal_brands) / sizeof(SrsMp4BoxBrand)); i++) {
- if (ftyp->major_brand == legal_brands[i]) {
+ if (ftyp->major_brand_ == legal_brands[i]) {
legal_brand = true;
break;
}
}
if (!legal_brand) {
- return srs_error_new(ERROR_MP4_BOX_ILLEGAL_BRAND, "brand is illegal, brand=%d", ftyp->major_brand);
+ return srs_error_new(ERROR_MP4_BOX_ILLEGAL_BRAND, "brand is illegal, brand=%d", ftyp->major_brand_);
}
- brand = ftyp->major_brand;
+ brand_ = ftyp->major_brand_;
return err;
}
@@ -6369,21 +6369,21 @@ srs_error_t SrsMp4Decoder::parse_moov(SrsMp4MovieBox *moov)
SrsMp4AudioSampleEntry *mp4a = soun ? soun->mp4a() : NULL;
if (mp4a) {
- uint32_t sr = mp4a->samplerate >> 16;
- if ((sample_rate = srs_audio_sample_rate_from_number(sr)) == SrsAudioSampleRateForbidden) {
- sample_rate = srs_audio_sample_rate_guess_number(sr);
+ uint32_t sr = mp4a->samplerate_ >> 16;
+ if ((sample_rate_ = srs_audio_sample_rate_from_number(sr)) == SrsAudioSampleRateForbidden) {
+ sample_rate_ = srs_audio_sample_rate_guess_number(sr);
}
- if (mp4a->samplesize == 16) {
- sound_bits = SrsAudioSampleBits16bit;
+ if (mp4a->samplesize_ == 16) {
+ sound_bits_ = SrsAudioSampleBits16bit;
} else {
- sound_bits = SrsAudioSampleBits8bit;
+ sound_bits_ = SrsAudioSampleBits8bit;
}
- if (mp4a->channelcount == 2) {
- channels = SrsAudioChannelsStereo;
+ if (mp4a->channelcount_ == 2) {
+ channels_ = SrsAudioChannelsStereo;
} else {
- channels = SrsAudioChannelsMono;
+ channels_ = SrsAudioChannelsMono;
}
}
@@ -6396,18 +6396,18 @@ srs_error_t SrsMp4Decoder::parse_moov(SrsMp4MovieBox *moov)
return srs_error_new(ERROR_MP4_ILLEGAL_MOOV, "missing audio sequence header");
}
- vcodec = vide ? vide->vide_codec() : SrsVideoCodecIdForbidden;
- acodec = soun ? soun->soun_codec() : SrsAudioCodecIdForbidden;
+ vcodec_ = vide ? vide->vide_codec() : SrsVideoCodecIdForbidden;
+ acodec_ = soun ? soun->soun_codec() : SrsAudioCodecIdForbidden;
- if (avcc && !avcc->avc_config.empty()) {
- pavcc = avcc->avc_config;
+ if (avcc && !avcc->avc_config_.empty()) {
+ pavcc_ = avcc->avc_config_;
}
- if (asc && !asc->asc.empty()) {
- pasc = asc->asc;
+ if (asc && !asc->asc_.empty()) {
+ pasc_ = asc->asc_;
}
// Build the samples structure from moov.
- if ((err = samples->load(moov)) != srs_success) {
+ if ((err = samples_->load(moov)) != srs_success) {
return srs_error_wrap(err, "load samples");
}
@@ -6415,14 +6415,14 @@ srs_error_t SrsMp4Decoder::parse_moov(SrsMp4MovieBox *moov)
ss << "dur=" << mvhd->duration() << "ms";
// video codec.
ss << ", vide=" << moov->nb_vide_tracks() << "("
- << srs_video_codec_id2str(vcodec) << "," << pavcc.size() << "BSH"
+ << srs_video_codec_id2str(vcodec_) << "," << pavcc_.size() << "BSH"
<< ")";
// audio codec.
ss << ", soun=" << moov->nb_soun_tracks() << "("
- << srs_audio_codec_id2str(acodec) << "," << pasc.size() << "BSH"
- << "," << srs_audio_channels2str(channels)
- << "," << srs_audio_sample_bits2str(sound_bits)
- << "," << srs_audio_sample_rate2str(sample_rate)
+ << srs_audio_codec_id2str(acodec_) << "," << pasc_.size() << "BSH"
+ << "," << srs_audio_channels2str(channels_)
+ << "," << srs_audio_sample_bits2str(sound_bits_)
+ << "," << srs_audio_sample_rate2str(sample_rate_)
<< ")";
srs_trace("MP4 moov %s", ss.str().c_str());
@@ -6440,7 +6440,7 @@ srs_error_t SrsMp4Decoder::load_next_box(SrsMp4Box **ppbox, uint32_t required_bo
return srs_error_wrap(err, "load box");
}
- if (!required_box_type || (uint32_t)box->type == required_box_type) {
+ if (!required_box_type || (uint32_t)box->type_ == required_box_type) {
*ppbox = box;
return err;
}
@@ -6459,17 +6459,17 @@ srs_error_t SrsMp4Decoder::do_load_next_box(SrsMp4Box **ppbox, uint32_t required
while (true) {
SrsMp4Box *box = NULL;
- if ((err = br->read(stream, &box)) != srs_success) {
+ if ((err = br_->read(stream_, &box)) != srs_success) {
return srs_error_wrap(err, "read box");
}
- SrsUniquePtr buffer(new SrsBuffer(stream->bytes(), stream->length()));
+ SrsUniquePtr buffer(new SrsBuffer(stream_->bytes(), stream_->length()));
// Decode the box:
// 1. Any box, when no box type is required.
// 2. Matched box, when box type match the required type.
// 3. Mdat box, always decode the mdat because we only decode the header of it.
- if (!required_box_type || (uint32_t)box->type == required_box_type || box->is_mdat()) {
+ if (!required_box_type || (uint32_t)box->type_ == required_box_type || box->is_mdat()) {
err = box->decode(buffer.get());
}
@@ -6477,7 +6477,7 @@ srs_error_t SrsMp4Decoder::do_load_next_box(SrsMp4Box **ppbox, uint32_t required
// For mdat box, skip the content in stream or underylayer reader.
// For other boxes, skip it from stream because we already decoded it or ignore it.
if (err == srs_success) {
- err = br->skip(box, stream);
+ err = br_->skip(box, stream_);
}
if (err != srs_success) {
@@ -6495,38 +6495,38 @@ srs_error_t SrsMp4Decoder::do_load_next_box(SrsMp4Box **ppbox, uint32_t required
SrsMp4Encoder::SrsMp4Encoder()
{
- wsio = NULL;
- mdat_bytes = 0;
- mdat_offset = 0;
- nb_audios = nb_videos = 0;
- samples = new SrsMp4SampleManager();
- aduration = vduration = 0;
- width = height = 0;
+ wsio_ = NULL;
+ mdat_bytes_ = 0;
+ mdat_offset_ = 0;
+ nb_audios_ = nb_videos_ = 0;
+ samples_ = new SrsMp4SampleManager();
+ aduration_ = vduration_ = 0;
+ width_ = height_ = 0;
- acodec = SrsAudioCodecIdForbidden;
- sample_rate = SrsAudioSampleRateForbidden;
- sound_bits = SrsAudioSampleBitsForbidden;
- channels = SrsAudioChannelsForbidden;
- vcodec = SrsVideoCodecIdForbidden;
+ acodec_ = SrsAudioCodecIdForbidden;
+ sample_rate_ = SrsAudioSampleRateForbidden;
+ sound_bits_ = SrsAudioSampleBitsForbidden;
+ channels_ = SrsAudioChannelsForbidden;
+ vcodec_ = SrsVideoCodecIdForbidden;
}
SrsMp4Encoder::~SrsMp4Encoder()
{
- srs_freep(samples);
+ srs_freep(samples_);
}
srs_error_t SrsMp4Encoder::initialize(ISrsWriteSeeker *ws)
{
srs_error_t err = srs_success;
- wsio = ws;
+ wsio_ = ws;
// Write ftyp box.
if (true) {
SrsUniquePtr ftyp(new SrsMp4FileTypeBox());
- ftyp->major_brand = SrsMp4BoxBrandISOM;
- ftyp->minor_version = 512;
+ ftyp->major_brand_ = SrsMp4BoxBrandISOM;
+ ftyp->minor_version_ = 512;
ftyp->set_compatible_brands(SrsMp4BoxBrandISOM, SrsMp4BoxBrandISO2, SrsMp4BoxBrandMP41);
int nb_data = ftyp->nb_bytes();
@@ -6538,7 +6538,7 @@ srs_error_t SrsMp4Encoder::initialize(ISrsWriteSeeker *ws)
}
// TODO: FIXME: Ensure write ok.
- if ((err = wsio->write(&data[0], nb_data, NULL)) != srs_success) {
+ if ((err = wsio_->write(&data[0], nb_data, NULL)) != srs_success) {
return srs_error_wrap(err, "write ftyp");
}
}
@@ -6555,7 +6555,7 @@ srs_error_t SrsMp4Encoder::initialize(ISrsWriteSeeker *ws)
return srs_error_wrap(err, "encode free box");
}
- if ((err = wsio->write(&data[0], nb_data, NULL)) != srs_success) {
+ if ((err = wsio_->write(&data[0], nb_data, NULL)) != srs_success) {
return srs_error_wrap(err, "write free box");
}
}
@@ -6568,7 +6568,7 @@ srs_error_t SrsMp4Encoder::initialize(ISrsWriteSeeker *ws)
SrsUniquePtr mdat(new SrsMp4MediaDataBox());
// Update the mdat box from this offset.
- if ((err = wsio->lseek(0, SEEK_CUR, &mdat_offset)) != srs_success) {
+ if ((err = wsio_->lseek(0, SEEK_CUR, &mdat_offset_)) != srs_success) {
return srs_error_wrap(err, "seek to mdat");
}
@@ -6581,11 +6581,11 @@ srs_error_t SrsMp4Encoder::initialize(ISrsWriteSeeker *ws)
}
// TODO: FIXME: Ensure all bytes are writen.
- if ((err = wsio->write(data.get(), nb_data, NULL)) != srs_success) {
+ if ((err = wsio_->write(data.get(), nb_data, NULL)) != srs_success) {
return srs_error_wrap(err, "write mdat");
}
- mdat_bytes = 0;
+ mdat_bytes_ = 0;
}
return err;
@@ -6609,21 +6609,21 @@ srs_error_t SrsMp4Encoder::write_sample(
}
if (ht == SrsMp4HandlerTypeVIDE) {
- ps->type = SrsFrameTypeVideo;
- ps->frame_type = (SrsVideoAvcFrameType)ft;
- ps->index = nb_videos++;
- vduration = dts;
+ ps->type_ = SrsFrameTypeVideo;
+ ps->frame_type_ = (SrsVideoAvcFrameType)ft;
+ ps->index_ = nb_videos_++;
+ vduration_ = dts;
} else if (ht == SrsMp4HandlerTypeSOUN) {
- ps->type = SrsFrameTypeAudio;
- ps->index = nb_audios++;
- aduration = dts;
+ ps->type_ = SrsFrameTypeAudio;
+ ps->index_ = nb_audios_++;
+ aduration_ = dts;
} else {
srs_freep(ps);
return err;
}
- ps->tbn = 1000;
- ps->dts = dts;
- ps->pts = pts;
+ ps->tbn_ = 1000;
+ ps->dts_ = dts;
+ ps->pts_ = pts;
if ((err = do_write_sample(ps, sample, nb_sample)) != srs_success) {
srs_freep(ps);
@@ -6631,7 +6631,7 @@ srs_error_t SrsMp4Encoder::write_sample(
}
// Append to manager to build the moov.
- samples->append(ps);
+ samples_->append(ps);
return err;
}
@@ -6640,7 +6640,7 @@ srs_error_t SrsMp4Encoder::flush()
{
srs_error_t err = srs_success;
- if (!nb_audios && !nb_videos) {
+ if (!nb_audios_ && !nb_videos_) {
return srs_error_new(ERROR_MP4_ILLEGAL_MOOV, "Missing audio and video track");
}
@@ -6651,11 +6651,11 @@ srs_error_t SrsMp4Encoder::flush()
SrsMp4MovieHeaderBox *mvhd = new SrsMp4MovieHeaderBox();
moov->set_mvhd(mvhd);
- mvhd->timescale = 1000; // Use tbn ms.
- mvhd->duration_in_tbn = srs_max(vduration, aduration);
- mvhd->next_track_ID = 1; // Starts from 1, increase when use it.
+ mvhd->timescale_ = 1000; // Use tbn ms.
+ mvhd->duration_in_tbn_ = srs_max(vduration_, aduration_);
+ mvhd->next_track_ID_ = 1; // Starts from 1, increase when use it.
- if (nb_videos || !pavcc.empty() || !phvcc.empty()) {
+ if (nb_videos_ || !pavcc_.empty() || !phvcc_.empty()) {
SrsMp4TrackBox *trak = new SrsMp4TrackBox();
moov->add_trak(trak);
@@ -6664,20 +6664,20 @@ srs_error_t SrsMp4Encoder::flush()
SrsMp4EditListBox *elst = new SrsMp4EditListBox();
edts->set_elst(elst);
- elst->version = 0;
+ elst->version_ = 0;
SrsMp4ElstEntry entry;
- entry.segment_duration = mvhd->duration_in_tbn;
- entry.media_rate_integer = 1;
- elst->entries.push_back(entry);
+ entry.segment_duration_ = mvhd->duration_in_tbn_;
+ entry.media_rate_integer_ = 1;
+ elst->entries_.push_back(entry);
SrsMp4TrackHeaderBox *tkhd = new SrsMp4TrackHeaderBox();
trak->set_tkhd(tkhd);
- tkhd->track_ID = mvhd->next_track_ID++;
- tkhd->duration = vduration;
- tkhd->width = (width << 16);
- tkhd->height = (height << 16);
+ tkhd->track_ID_ = mvhd->next_track_ID_++;
+ tkhd->duration_ = vduration_;
+ tkhd->width_ = (width_ << 16);
+ tkhd->height_ = (height_ << 16);
SrsMp4MediaBox *mdia = new SrsMp4MediaBox();
trak->set_mdia(mdia);
@@ -6685,8 +6685,8 @@ srs_error_t SrsMp4Encoder::flush()
SrsMp4MediaHeaderBox *mdhd = new SrsMp4MediaHeaderBox();
mdia->set_mdhd(mdhd);
- mdhd->timescale = 1000;
- mdhd->duration = vduration;
+ mdhd->timescale_ = 1000;
+ mdhd->duration_ = vduration_;
mdhd->set_language0('u');
mdhd->set_language1('n');
mdhd->set_language2('d');
@@ -6694,8 +6694,8 @@ srs_error_t SrsMp4Encoder::flush()
SrsMp4HandlerReferenceBox *hdlr = new SrsMp4HandlerReferenceBox();
mdia->set_hdlr(hdlr);
- hdlr->handler_type = SrsMp4HandlerTypeVIDE;
- hdlr->name = "VideoHandler";
+ hdlr->handler_type_ = SrsMp4HandlerTypeVIDE;
+ hdlr->name_ = "VideoHandler";
SrsMp4MediaInformationBox *minf = new SrsMp4MediaInformationBox();
mdia->set_minf(minf);
@@ -6718,43 +6718,43 @@ srs_error_t SrsMp4Encoder::flush()
SrsMp4SampleDescriptionBox *stsd = new SrsMp4SampleDescriptionBox();
stbl->set_stsd(stsd);
- if (vcodec == SrsVideoCodecIdAVC) {
+ if (vcodec_ == SrsVideoCodecIdAVC) {
SrsMp4VisualSampleEntry *avc1 = new SrsMp4VisualSampleEntry(SrsMp4BoxTypeAVC1);
stsd->append(avc1);
- avc1->width = width;
- avc1->height = height;
- avc1->data_reference_index = 1;
+ avc1->width_ = width_;
+ avc1->height_ = height_;
+ avc1->data_reference_index_ = 1;
SrsMp4AvccBox *avcC = new SrsMp4AvccBox();
avc1->set_avcC(avcC);
- avcC->avc_config = pavcc;
+ avcC->avc_config_ = pavcc_;
} else {
SrsMp4VisualSampleEntry *hev1 = new SrsMp4VisualSampleEntry(SrsMp4BoxTypeHEV1);
stsd->append(hev1);
- hev1->width = width;
- hev1->height = height;
- hev1->data_reference_index = 1;
+ hev1->width_ = width_;
+ hev1->height_ = height_;
+ hev1->data_reference_index_ = 1;
SrsMp4HvcCBox *hvcC = new SrsMp4HvcCBox();
hev1->set_hvcC(hvcC);
- hvcC->hevc_config = phvcc;
+ hvcC->hevc_config_ = phvcc_;
}
}
- if (nb_audios || !pasc.empty()) {
+ if (nb_audios_ || !pasc_.empty()) {
SrsMp4TrackBox *trak = new SrsMp4TrackBox();
moov->add_trak(trak);
SrsMp4TrackHeaderBox *tkhd = new SrsMp4TrackHeaderBox();
- tkhd->volume = 0x0100;
+ tkhd->volume_ = 0x0100;
trak->set_tkhd(tkhd);
- tkhd->track_ID = mvhd->next_track_ID++;
- tkhd->duration = aduration;
+ tkhd->track_ID_ = mvhd->next_track_ID_++;
+ tkhd->duration_ = aduration_;
SrsMp4MediaBox *mdia = new SrsMp4MediaBox();
trak->set_mdia(mdia);
@@ -6762,8 +6762,8 @@ srs_error_t SrsMp4Encoder::flush()
SrsMp4MediaHeaderBox *mdhd = new SrsMp4MediaHeaderBox();
mdia->set_mdhd(mdhd);
- mdhd->timescale = 1000;
- mdhd->duration = aduration;
+ mdhd->timescale_ = 1000;
+ mdhd->duration_ = aduration_;
mdhd->set_language0('u');
mdhd->set_language1('n');
mdhd->set_language2('d');
@@ -6771,8 +6771,8 @@ srs_error_t SrsMp4Encoder::flush()
SrsMp4HandlerReferenceBox *hdlr = new SrsMp4HandlerReferenceBox();
mdia->set_hdlr(hdlr);
- hdlr->handler_type = SrsMp4HandlerTypeSOUN;
- hdlr->name = "SoundHandler";
+ hdlr->handler_type_ = SrsMp4HandlerTypeSOUN;
+ hdlr->name_ = "SoundHandler";
SrsMp4MediaInformationBox *minf = new SrsMp4MediaInformationBox();
mdia->set_minf(minf);
@@ -6796,17 +6796,17 @@ srs_error_t SrsMp4Encoder::flush()
stbl->set_stsd(stsd);
SrsMp4AudioSampleEntry *mp4a = new SrsMp4AudioSampleEntry();
- mp4a->data_reference_index = 1;
- mp4a->samplerate = srs_audio_sample_rate2number(sample_rate);
- if (sound_bits == SrsAudioSampleBits16bit) {
- mp4a->samplesize = 16;
+ mp4a->data_reference_index_ = 1;
+ mp4a->samplerate_ = srs_audio_sample_rate2number(sample_rate_);
+ if (sound_bits_ == SrsAudioSampleBits16bit) {
+ mp4a->samplesize_ = 16;
} else {
- mp4a->samplesize = 8;
+ mp4a->samplesize_ = 8;
}
- if (channels == SrsAudioChannelsStereo) {
- mp4a->channelcount = 2;
+ if (channels_ == SrsAudioChannelsStereo) {
+ mp4a->channelcount_ = 2;
} else {
- mp4a->channelcount = 1;
+ mp4a->channelcount_ = 1;
}
stsd->append(mp4a);
@@ -6814,21 +6814,21 @@ srs_error_t SrsMp4Encoder::flush()
mp4a->set_esds(esds);
SrsMp4ES_Descriptor *es = esds->es;
- es->ES_ID = 0x02;
+ es->ES_ID_ = 0x02;
- SrsMp4DecoderConfigDescriptor &desc = es->decConfigDescr;
+ SrsMp4DecoderConfigDescriptor &desc = es->decConfigDescr_;
desc.objectTypeIndication = get_audio_object_type();
desc.streamType = SrsMp4StreamTypeAudioStream;
- srs_freep(desc.decSpecificInfo);
+ srs_freep(desc.decSpecificInfo_);
if (SrsMp4ObjectTypeAac == desc.objectTypeIndication) {
SrsMp4DecoderSpecificInfo *asc = new SrsMp4DecoderSpecificInfo();
- desc.decSpecificInfo = asc;
- asc->asc = pasc;
+ desc.decSpecificInfo_ = asc;
+ asc->asc_ = pasc_;
}
}
- if ((err = samples->write(moov.get())) != srs_success) {
+ if ((err = samples_->write(moov.get())) != srs_success) {
return srs_error_wrap(err, "write samples");
}
@@ -6841,7 +6841,7 @@ srs_error_t SrsMp4Encoder::flush()
}
// TODO: FIXME: Ensure all bytes are writen.
- if ((err = wsio->write(data.get(), nb_data, NULL)) != srs_success) {
+ if ((err = wsio_->write(data.get(), nb_data, NULL)) != srs_success) {
return srs_error_wrap(err, "write moov");
}
}
@@ -6854,7 +6854,7 @@ srs_error_t SrsMp4Encoder::flush()
SrsUniquePtr mdat(new SrsMp4MediaDataBox());
// Update the size of mdat first, for over 2GB file.
- mdat->nb_data = mdat_bytes;
+ mdat->nb_data_ = mdat_bytes_;
mdat->update_size();
int nb_data = mdat->sz_header();
@@ -6872,16 +6872,16 @@ srs_error_t SrsMp4Encoder::flush()
return srs_error_new(ERROR_MP4_ILLEGAL_MDAT, "Invalid mdat header size %d", nb_data);
}
// Use large size, to the start of reserved free box.
- mdat_offset -= 8;
+ mdat_offset_ -= 8;
}
// Seek to the start of mdat.
- if ((err = wsio->lseek(mdat_offset, SEEK_SET, NULL)) != srs_success) {
+ if ((err = wsio_->lseek(mdat_offset_, SEEK_SET, NULL)) != srs_success) {
return srs_error_wrap(err, "seek to mdat");
}
// TODO: FIXME: Ensure all bytes are writen.
- if ((err = wsio->write(data.get(), nb_data, NULL)) != srs_success) {
+ if ((err = wsio_->write(data.get(), nb_data, NULL)) != srs_success) {
return srs_error_wrap(err, "write mdat");
}
}
@@ -6895,16 +6895,16 @@ srs_error_t SrsMp4Encoder::copy_sequence_header(SrsFormat *format, bool vsh, uin
if (vsh) {
// AVC
- if (format->vcodec->id == SrsVideoCodecIdAVC && !pavcc.empty()) {
- if (nb_sample == (uint32_t)pavcc.size() && srs_bytes_equal(sample, &pavcc[0], (int)pavcc.size())) {
+ if (format->vcodec_->id_ == SrsVideoCodecIdAVC && !pavcc_.empty()) {
+ if (nb_sample == (uint32_t)pavcc_.size() && srs_bytes_equal(sample, &pavcc_[0], (int)pavcc_.size())) {
return err;
}
return srs_error_new(ERROR_MP4_AVCC_CHANGE, "doesn't support avcc change");
}
// HEVC
- if (format->vcodec->id == SrsVideoCodecIdHEVC && !phvcc.empty()) {
- if (nb_sample == (uint32_t)phvcc.size() && srs_bytes_equal(sample, &phvcc[0], (int)phvcc.size())) {
+ if (format->vcodec_->id_ == SrsVideoCodecIdHEVC && !phvcc_.empty()) {
+ if (nb_sample == (uint32_t)phvcc_.size() && srs_bytes_equal(sample, &phvcc_[0], (int)phvcc_.size())) {
return err;
}
@@ -6912,8 +6912,8 @@ srs_error_t SrsMp4Encoder::copy_sequence_header(SrsFormat *format, bool vsh, uin
}
}
- if (!vsh && !pasc.empty()) {
- if (nb_sample == (uint32_t)pasc.size() && srs_bytes_equal(sample, &pasc[0], (int)pasc.size())) {
+ if (!vsh && !pasc_.empty()) {
+ if (nb_sample == (uint32_t)pasc_.size() && srs_bytes_equal(sample, &pasc_[0], (int)pasc_.size())) {
return err;
}
@@ -6921,19 +6921,19 @@ srs_error_t SrsMp4Encoder::copy_sequence_header(SrsFormat *format, bool vsh, uin
}
if (vsh) {
- if (format->vcodec->id == SrsVideoCodecIdHEVC) {
- phvcc = std::vector(sample, sample + nb_sample);
+ if (format->vcodec_->id_ == SrsVideoCodecIdHEVC) {
+ phvcc_ = std::vector(sample, sample + nb_sample);
} else {
- pavcc = std::vector(sample, sample + nb_sample);
+ pavcc_ = std::vector(sample, sample + nb_sample);
}
- if (format && format->vcodec) {
- width = format->vcodec->width;
- height = format->vcodec->height;
+ if (format && format->vcodec_) {
+ width_ = format->vcodec_->width_;
+ height_ = format->vcodec_->height_;
}
}
if (!vsh) {
- pasc = std::vector(sample, sample + nb_sample);
+ pasc_ = std::vector(sample, sample + nb_sample);
}
return err;
@@ -6943,32 +6943,32 @@ srs_error_t SrsMp4Encoder::do_write_sample(SrsMp4Sample *ps, uint8_t *sample, ui
{
srs_error_t err = srs_success;
- ps->nb_data = nb_sample;
+ ps->nb_data_ = nb_sample;
// Never copy data, for we already writen to writer.
- ps->data = NULL;
+ ps->data_ = NULL;
// Update the mdat box from this offset.
- if ((err = wsio->lseek(0, SEEK_CUR, &ps->offset)) != srs_success) {
+ if ((err = wsio_->lseek(0, SEEK_CUR, &ps->offset_)) != srs_success) {
return srs_error_wrap(err, "seek to offset in mdat");
}
// TODO: FIXME: Ensure all bytes are writen.
- if ((err = wsio->write(sample, nb_sample, NULL)) != srs_success) {
+ if ((err = wsio_->write(sample, nb_sample, NULL)) != srs_success) {
return srs_error_wrap(err, "write sample");
}
- mdat_bytes += nb_sample;
+ mdat_bytes_ += nb_sample;
return err;
}
SrsMp4ObjectType SrsMp4Encoder::get_audio_object_type()
{
- switch (acodec) {
+ switch (acodec_) {
case SrsAudioCodecIdAAC:
return SrsMp4ObjectTypeAac;
case SrsAudioCodecIdMP3:
- return (srs_audio_sample_rate2number(sample_rate) > 24000) ? SrsMp4ObjectTypeMp1a : SrsMp4ObjectTypeMp3; // 11172 - 3
+ return (srs_audio_sample_rate2number(sample_rate_) > 24000) ? SrsMp4ObjectTypeMp1a : SrsMp4ObjectTypeMp3; // 11172 - 3
default:
return SrsMp4ObjectTypeForbidden;
}
@@ -6976,7 +6976,7 @@ SrsMp4ObjectType SrsMp4Encoder::get_audio_object_type()
SrsMp4M2tsInitEncoder::SrsMp4M2tsInitEncoder()
{
- writer = NULL;
+ writer_ = NULL;
crypt_byte_block_ = 0;
skip_byte_block_ = 0;
iv_size_ = 0;
@@ -6989,7 +6989,7 @@ SrsMp4M2tsInitEncoder::~SrsMp4M2tsInitEncoder()
srs_error_t SrsMp4M2tsInitEncoder::initialize(ISrsWriter *w)
{
- writer = w;
+ writer_ = w;
return srs_success;
}
@@ -7013,11 +7013,11 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, bool video, int tid)
if (true) {
SrsUniquePtr ftyp(new SrsMp4FileTypeBox());
- ftyp->major_brand = SrsMp4BoxBrandISO5;
- ftyp->minor_version = 512;
+ ftyp->major_brand_ = SrsMp4BoxBrandISO5;
+ ftyp->minor_version_ = 512;
ftyp->set_compatible_brands(SrsMp4BoxBrandISO6, SrsMp4BoxBrandMP41);
- if ((err = srs_mp4_write_box(writer, ftyp.get())) != srs_success) {
+ if ((err = srs_mp4_write_box(writer_, ftyp.get())) != srs_success) {
return srs_error_wrap(err, "write ftyp");
}
}
@@ -7029,9 +7029,9 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, bool video, int tid)
SrsMp4MovieHeaderBox *mvhd = new SrsMp4MovieHeaderBox();
moov->set_mvhd(mvhd);
- mvhd->timescale = 1000; // Use tbn ms.
- mvhd->duration_in_tbn = 0;
- mvhd->next_track_ID = tid;
+ mvhd->timescale_ = 1000; // Use tbn ms.
+ mvhd->duration_in_tbn_ = 0;
+ mvhd->next_track_ID_ = tid;
if (video) {
SrsMp4TrackBox *trak = new SrsMp4TrackBox();
@@ -7040,10 +7040,10 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, bool video, int tid)
SrsMp4TrackHeaderBox *tkhd = new SrsMp4TrackHeaderBox();
trak->set_tkhd(tkhd);
- tkhd->track_ID = mvhd->next_track_ID++;
- tkhd->duration = 0;
- tkhd->width = (format->vcodec->width << 16);
- tkhd->height = (format->vcodec->height << 16);
+ tkhd->track_ID_ = mvhd->next_track_ID_++;
+ tkhd->duration_ = 0;
+ tkhd->width_ = (format->vcodec_->width_ << 16);
+ tkhd->height_ = (format->vcodec_->height_ << 16);
SrsMp4MediaBox *mdia = new SrsMp4MediaBox();
trak->set_mdia(mdia);
@@ -7051,8 +7051,8 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, bool video, int tid)
SrsMp4MediaHeaderBox *mdhd = new SrsMp4MediaHeaderBox();
mdia->set_mdhd(mdhd);
- mdhd->timescale = 1000;
- mdhd->duration = 0;
+ mdhd->timescale_ = 1000;
+ mdhd->duration_ = 0;
mdhd->set_language0('u');
mdhd->set_language1('n');
mdhd->set_language2('d');
@@ -7060,8 +7060,8 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, bool video, int tid)
SrsMp4HandlerReferenceBox *hdlr = new SrsMp4HandlerReferenceBox();
mdia->set_hdlr(hdlr);
- hdlr->handler_type = SrsMp4HandlerTypeVIDE;
- hdlr->name = "VideoHandler";
+ hdlr->handler_type_ = SrsMp4HandlerTypeVIDE;
+ hdlr->name_ = "VideoHandler";
SrsMp4MediaInformationBox *minf = new SrsMp4MediaInformationBox();
mdia->set_minf(minf);
@@ -7084,18 +7084,18 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, bool video, int tid)
SrsMp4SampleDescriptionBox *stsd = new SrsMp4SampleDescriptionBox();
stbl->set_stsd(stsd);
- if (format->vcodec->id == SrsVideoCodecIdAVC) {
+ if (format->vcodec_->id_ == SrsVideoCodecIdAVC) {
SrsMp4VisualSampleEntry *avc1 = new SrsMp4VisualSampleEntry(SrsMp4BoxTypeAVC1);
stsd->append(avc1);
- avc1->width = format->vcodec->width;
- avc1->height = format->vcodec->height;
- avc1->data_reference_index = 1;
+ avc1->width_ = format->vcodec_->width_;
+ avc1->height_ = format->vcodec_->height_;
+ avc1->data_reference_index_ = 1;
SrsMp4AvccBox *avcC = new SrsMp4AvccBox();
avc1->set_avcC(avcC);
- avcC->avc_config = format->vcodec->avc_extra_data;
+ avcC->avc_config_ = format->vcodec_->avc_extra_data_;
if (is_protected_ && ((err = config_sample_description_encryption(avc1)) != srs_success)) {
return srs_error_wrap(err, "encrypt avc1 box");
@@ -7104,14 +7104,14 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, bool video, int tid)
SrsMp4VisualSampleEntry *hev1 = new SrsMp4VisualSampleEntry(SrsMp4BoxTypeHEV1);
stsd->append(hev1);
- hev1->width = format->vcodec->width;
- hev1->height = format->vcodec->height;
- hev1->data_reference_index = 1;
+ hev1->width_ = format->vcodec_->width_;
+ hev1->height_ = format->vcodec_->height_;
+ hev1->data_reference_index_ = 1;
SrsMp4HvcCBox *hvcC = new SrsMp4HvcCBox();
hev1->set_hvcC(hvcC);
- hvcC->hevc_config = format->vcodec->avc_extra_data;
+ hvcC->hevc_config_ = format->vcodec_->avc_extra_data_;
if (is_protected_ && ((err = config_sample_description_encryption(hev1)) != srs_success)) {
return srs_error_wrap(err, "encrypt hev1 box");
@@ -7137,18 +7137,18 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, bool video, int tid)
SrsMp4TrackExtendsBox *trex = new SrsMp4TrackExtendsBox();
mvex->add_trex(trex);
- trex->track_ID = tid;
- trex->default_sample_description_index = 1;
+ trex->track_ID_ = tid;
+ trex->default_sample_description_index_ = 1;
} else {
SrsMp4TrackBox *trak = new SrsMp4TrackBox();
moov->add_trak(trak);
SrsMp4TrackHeaderBox *tkhd = new SrsMp4TrackHeaderBox();
- tkhd->volume = 0x0100;
+ tkhd->volume_ = 0x0100;
trak->set_tkhd(tkhd);
- tkhd->track_ID = mvhd->next_track_ID++;
- tkhd->duration = 0;
+ tkhd->track_ID_ = mvhd->next_track_ID_++;
+ tkhd->duration_ = 0;
SrsMp4MediaBox *mdia = new SrsMp4MediaBox();
trak->set_mdia(mdia);
@@ -7156,8 +7156,8 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, bool video, int tid)
SrsMp4MediaHeaderBox *mdhd = new SrsMp4MediaHeaderBox();
mdia->set_mdhd(mdhd);
- mdhd->timescale = 1000;
- mdhd->duration = 0;
+ mdhd->timescale_ = 1000;
+ mdhd->duration_ = 0;
mdhd->set_language0('u');
mdhd->set_language1('n');
mdhd->set_language2('d');
@@ -7165,8 +7165,8 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, bool video, int tid)
SrsMp4HandlerReferenceBox *hdlr = new SrsMp4HandlerReferenceBox();
mdia->set_hdlr(hdlr);
- hdlr->handler_type = SrsMp4HandlerTypeSOUN;
- hdlr->name = "SoundHandler";
+ hdlr->handler_type_ = SrsMp4HandlerTypeSOUN;
+ hdlr->name_ = "SoundHandler";
SrsMp4MediaInformationBox *minf = new SrsMp4MediaInformationBox();
mdia->set_minf(minf);
@@ -7190,17 +7190,17 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, bool video, int tid)
stbl->set_stsd(stsd);
SrsMp4AudioSampleEntry *mp4a = new SrsMp4AudioSampleEntry();
- mp4a->data_reference_index = 1;
- mp4a->samplerate = uint32_t(srs_flv_srates[format->acodec->sound_rate]) << 16;
- if (format->acodec->sound_size == SrsAudioSampleBits16bit) {
- mp4a->samplesize = 16;
+ mp4a->data_reference_index_ = 1;
+ mp4a->samplerate_ = uint32_t(srs_flv_srates[format->acodec_->sound_rate_]) << 16;
+ if (format->acodec_->sound_size_ == SrsAudioSampleBits16bit) {
+ mp4a->samplesize_ = 16;
} else {
- mp4a->samplesize = 8;
+ mp4a->samplesize_ = 8;
}
- if (format->acodec->sound_type == SrsAudioChannelsStereo) {
- mp4a->channelcount = 2;
+ if (format->acodec_->sound_type_ == SrsAudioChannelsStereo) {
+ mp4a->channelcount_ = 2;
} else {
- mp4a->channelcount = 1;
+ mp4a->channelcount_ = 1;
}
stsd->append(mp4a);
@@ -7212,16 +7212,16 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, bool video, int tid)
}
SrsMp4ES_Descriptor *es = esds->es;
- es->ES_ID = 0x02;
+ es->ES_ID_ = 0x02;
- SrsMp4DecoderConfigDescriptor &desc = es->decConfigDescr;
+ SrsMp4DecoderConfigDescriptor &desc = es->decConfigDescr_;
desc.objectTypeIndication = SrsMp4ObjectTypeAac;
desc.streamType = SrsMp4StreamTypeAudioStream;
- srs_freep(desc.decSpecificInfo);
+ srs_freep(desc.decSpecificInfo_);
SrsMp4DecoderSpecificInfo *asc = new SrsMp4DecoderSpecificInfo();
- desc.decSpecificInfo = asc;
- asc->asc = format->acodec->aac_extra_data;
+ desc.decSpecificInfo_ = asc;
+ asc->asc_ = format->acodec_->aac_extra_data_;
SrsMp4DecodingTime2SampleBox *stts = new SrsMp4DecodingTime2SampleBox();
stbl->set_stts(stts);
@@ -7242,11 +7242,11 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, bool video, int tid)
SrsMp4TrackExtendsBox *trex = new SrsMp4TrackExtendsBox();
mvex->add_trex(trex);
- trex->track_ID = tid;
- trex->default_sample_description_index = 1;
+ trex->track_ID_ = tid;
+ trex->default_sample_description_index_ = 1;
}
- if ((err = srs_mp4_write_box(writer, moov.get())) != srs_success) {
+ if ((err = srs_mp4_write_box(writer_, moov.get())) != srs_success) {
return srs_error_wrap(err, "write moov");
}
}
@@ -7262,11 +7262,11 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, int v_tid, int a_tid
if (true) {
SrsUniquePtr ftyp(new SrsMp4FileTypeBox());
- ftyp->major_brand = SrsMp4BoxBrandMP42; // SrsMp4BoxBrandISO5;
- ftyp->minor_version = 512;
+ ftyp->major_brand_ = SrsMp4BoxBrandMP42; // SrsMp4BoxBrandISO5;
+ ftyp->minor_version_ = 512;
ftyp->set_compatible_brands(SrsMp4BoxBrandISO6, SrsMp4BoxBrandMP41);
- if ((err = srs_mp4_write_box(writer, ftyp.get())) != srs_success) {
+ if ((err = srs_mp4_write_box(writer_, ftyp.get())) != srs_success) {
return srs_error_wrap(err, "write ftyp");
}
}
@@ -7278,22 +7278,22 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, int v_tid, int a_tid
SrsMp4MovieHeaderBox *mvhd = new SrsMp4MovieHeaderBox();
moov->set_mvhd(mvhd);
- mvhd->timescale = 1000; // Use tbn ms.
- mvhd->duration_in_tbn = 0;
- mvhd->next_track_ID = 4294967295; // 2^32 - 1
+ mvhd->timescale_ = 1000; // Use tbn ms.
+ mvhd->duration_in_tbn_ = 0;
+ mvhd->next_track_ID_ = 4294967295; // 2^32 - 1
// write video track
- if (format->vcodec) {
+ if (format->vcodec_) {
SrsMp4TrackBox *trak = new SrsMp4TrackBox();
moov->add_trak(trak);
SrsMp4TrackHeaderBox *tkhd = new SrsMp4TrackHeaderBox();
trak->set_tkhd(tkhd);
- tkhd->track_ID = v_tid;
- tkhd->duration = 0;
- tkhd->width = (format->vcodec->width << 16);
- tkhd->height = (format->vcodec->height << 16);
+ tkhd->track_ID_ = v_tid;
+ tkhd->duration_ = 0;
+ tkhd->width_ = (format->vcodec_->width_ << 16);
+ tkhd->height_ = (format->vcodec_->height_ << 16);
SrsMp4MediaBox *mdia = new SrsMp4MediaBox();
trak->set_mdia(mdia);
@@ -7301,8 +7301,8 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, int v_tid, int a_tid
SrsMp4MediaHeaderBox *mdhd = new SrsMp4MediaHeaderBox();
mdia->set_mdhd(mdhd);
- mdhd->timescale = 1000;
- mdhd->duration = 0;
+ mdhd->timescale_ = 1000;
+ mdhd->duration_ = 0;
mdhd->set_language0('u');
mdhd->set_language1('n');
mdhd->set_language2('d');
@@ -7310,8 +7310,8 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, int v_tid, int a_tid
SrsMp4HandlerReferenceBox *hdlr = new SrsMp4HandlerReferenceBox();
mdia->set_hdlr(hdlr);
- hdlr->handler_type = SrsMp4HandlerTypeVIDE;
- hdlr->name = "VideoHandler";
+ hdlr->handler_type_ = SrsMp4HandlerTypeVIDE;
+ hdlr->name_ = "VideoHandler";
SrsMp4MediaInformationBox *minf = new SrsMp4MediaInformationBox();
mdia->set_minf(minf);
@@ -7334,18 +7334,18 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, int v_tid, int a_tid
SrsMp4SampleDescriptionBox *stsd = new SrsMp4SampleDescriptionBox();
stbl->set_stsd(stsd);
- if (format->vcodec->id == SrsVideoCodecIdAVC) {
+ if (format->vcodec_->id_ == SrsVideoCodecIdAVC) {
SrsMp4VisualSampleEntry *avc1 = new SrsMp4VisualSampleEntry(SrsMp4BoxTypeAVC1);
stsd->append(avc1);
- avc1->width = format->vcodec->width;
- avc1->height = format->vcodec->height;
- avc1->data_reference_index = 1;
+ avc1->width_ = format->vcodec_->width_;
+ avc1->height_ = format->vcodec_->height_;
+ avc1->data_reference_index_ = 1;
SrsMp4AvccBox *avcC = new SrsMp4AvccBox();
avc1->set_avcC(avcC);
- avcC->avc_config = format->vcodec->avc_extra_data;
+ avcC->avc_config_ = format->vcodec_->avc_extra_data_;
if (is_protected_ && ((err = config_sample_description_encryption(avc1)) != srs_success)) {
return srs_error_wrap(err, "encrypt avc1 box");
@@ -7354,14 +7354,14 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, int v_tid, int a_tid
SrsMp4VisualSampleEntry *hev1 = new SrsMp4VisualSampleEntry(SrsMp4BoxTypeHEV1);
stsd->append(hev1);
- hev1->width = format->vcodec->width;
- hev1->height = format->vcodec->height;
- hev1->data_reference_index = 1;
+ hev1->width_ = format->vcodec_->width_;
+ hev1->height_ = format->vcodec_->height_;
+ hev1->data_reference_index_ = 1;
SrsMp4HvcCBox *hvcC = new SrsMp4HvcCBox();
hev1->set_hvcC(hvcC);
- hvcC->hevc_config = format->vcodec->avc_extra_data;
+ hvcC->hevc_config_ = format->vcodec_->avc_extra_data_;
if (is_protected_ && ((err = config_sample_description_encryption(hev1)) != srs_success)) {
return srs_error_wrap(err, "encrypt hev1 box");
@@ -7383,16 +7383,16 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, int v_tid, int a_tid
}
// write audio track
- if (format->acodec) {
+ if (format->acodec_) {
SrsMp4TrackBox *trak = new SrsMp4TrackBox();
moov->add_trak(trak);
SrsMp4TrackHeaderBox *tkhd = new SrsMp4TrackHeaderBox();
- tkhd->volume = 0x0100;
+ tkhd->volume_ = 0x0100;
trak->set_tkhd(tkhd);
- tkhd->track_ID = a_tid;
- tkhd->duration = 0;
+ tkhd->track_ID_ = a_tid;
+ tkhd->duration_ = 0;
SrsMp4MediaBox *mdia = new SrsMp4MediaBox();
trak->set_mdia(mdia);
@@ -7400,8 +7400,8 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, int v_tid, int a_tid
SrsMp4MediaHeaderBox *mdhd = new SrsMp4MediaHeaderBox();
mdia->set_mdhd(mdhd);
- mdhd->timescale = 1000;
- mdhd->duration = 0;
+ mdhd->timescale_ = 1000;
+ mdhd->duration_ = 0;
mdhd->set_language0('u');
mdhd->set_language1('n');
mdhd->set_language2('d');
@@ -7409,8 +7409,8 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, int v_tid, int a_tid
SrsMp4HandlerReferenceBox *hdlr = new SrsMp4HandlerReferenceBox();
mdia->set_hdlr(hdlr);
- hdlr->handler_type = SrsMp4HandlerTypeSOUN;
- hdlr->name = "SoundHandler";
+ hdlr->handler_type_ = SrsMp4HandlerTypeSOUN;
+ hdlr->name_ = "SoundHandler";
SrsMp4MediaInformationBox *minf = new SrsMp4MediaInformationBox();
mdia->set_minf(minf);
@@ -7434,17 +7434,17 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, int v_tid, int a_tid
stbl->set_stsd(stsd);
SrsMp4AudioSampleEntry *mp4a = new SrsMp4AudioSampleEntry();
- mp4a->data_reference_index = 1;
- mp4a->samplerate = uint32_t(srs_flv_srates[format->acodec->sound_rate]) << 16;
- if (format->acodec->sound_size == SrsAudioSampleBits16bit) {
- mp4a->samplesize = 16;
+ mp4a->data_reference_index_ = 1;
+ mp4a->samplerate_ = uint32_t(srs_flv_srates[format->acodec_->sound_rate_]) << 16;
+ if (format->acodec_->sound_size_ == SrsAudioSampleBits16bit) {
+ mp4a->samplesize_ = 16;
} else {
- mp4a->samplesize = 8;
+ mp4a->samplesize_ = 8;
}
- if (format->acodec->sound_type == SrsAudioChannelsStereo) {
- mp4a->channelcount = 2;
+ if (format->acodec_->sound_type_ == SrsAudioChannelsStereo) {
+ mp4a->channelcount_ = 2;
} else {
- mp4a->channelcount = 1;
+ mp4a->channelcount_ = 1;
}
stsd->append(mp4a);
@@ -7455,16 +7455,16 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, int v_tid, int a_tid
}
SrsMp4ES_Descriptor *es = esds->es;
- es->ES_ID = 0x02;
+ es->ES_ID_ = 0x02;
- SrsMp4DecoderConfigDescriptor &desc = es->decConfigDescr;
+ SrsMp4DecoderConfigDescriptor &desc = es->decConfigDescr_;
desc.objectTypeIndication = SrsMp4ObjectTypeAac;
desc.streamType = SrsMp4StreamTypeAudioStream;
- srs_freep(desc.decSpecificInfo);
+ srs_freep(desc.decSpecificInfo_);
SrsMp4DecoderSpecificInfo *asc = new SrsMp4DecoderSpecificInfo();
- desc.decSpecificInfo = asc;
- asc->asc = format->acodec->aac_extra_data;
+ desc.decSpecificInfo_ = asc;
+ asc->asc_ = format->acodec_->aac_extra_data_;
SrsMp4DecodingTime2SampleBox *stts = new SrsMp4DecodingTime2SampleBox();
stbl->set_stts(stts);
@@ -7485,25 +7485,25 @@ srs_error_t SrsMp4M2tsInitEncoder::write(SrsFormat *format, int v_tid, int a_tid
moov->set_mvex(mvex);
// video trex
- if (format->vcodec) {
+ if (format->vcodec_) {
SrsMp4TrackExtendsBox *v_trex = new SrsMp4TrackExtendsBox();
mvex->add_trex(v_trex);
- v_trex->track_ID = v_tid;
- v_trex->default_sample_description_index = 1;
+ v_trex->track_ID_ = v_tid;
+ v_trex->default_sample_description_index_ = 1;
}
// audio trex
- if (format->acodec) {
+ if (format->acodec_) {
SrsMp4TrackExtendsBox *a_trex = new SrsMp4TrackExtendsBox();
mvex->add_trex(a_trex);
- a_trex->track_ID = a_tid;
- a_trex->default_sample_description_index = 1;
+ a_trex->track_ID_ = a_tid;
+ a_trex->default_sample_description_index_ = 1;
}
}
- if ((err = srs_mp4_write_box(writer, moov.get())) != srs_success) {
+ if ((err = srs_mp4_write_box(writer_, moov.get())) != srs_success) {
return srs_error_wrap(err, "write moov");
}
}
@@ -7525,13 +7525,13 @@ srs_error_t SrsMp4M2tsInitEncoder::config_sample_description_encryption(SrsMp4Sa
srs_error_t err = srs_success;
bool is_video_sample = false;
- SrsMp4BoxType original_type = box->type;
+ SrsMp4BoxType original_type = box->type_;
if (original_type == SrsMp4BoxTypeAVC1 || original_type == SrsMp4BoxTypeHEV1) {
- box->type = SrsMp4BoxTypeENCV;
+ box->type_ = SrsMp4BoxTypeENCV;
is_video_sample = true;
} else if (original_type == SrsMp4BoxTypeMP4A) {
- box->type = SrsMp4BoxTypeENCA;
+ box->type_ = SrsMp4BoxTypeENCA;
} else {
return srs_error_new(ERROR_MP4_BOX_ILLEGAL_TYPE, "unknown sample type 0x%x to encrypt", original_type);
}
@@ -7543,20 +7543,20 @@ srs_error_t SrsMp4M2tsInitEncoder::config_sample_description_encryption(SrsMp4Sa
sinf->set_frma(frma);
SrsMp4SchemeTypeBox *schm = new SrsMp4SchemeTypeBox();
- schm->scheme_type = SrsMp4CENSchemeCBCS;
- schm->scheme_version = 0x00010000;
+ schm->scheme_type_ = SrsMp4CENSchemeCBCS;
+ schm->scheme_version_ = 0x00010000;
sinf->set_schm(schm);
SrsMp4SchemeInfoBox *schi = new SrsMp4SchemeInfoBox();
SrsMp4TrackEncryptionBox *tenc = new SrsMp4TrackEncryptionBox();
- tenc->version = 1;
- tenc->default_crypt_byte_block = is_video_sample ? crypt_byte_block_ : 0;
- tenc->default_skip_byte_block = is_video_sample ? skip_byte_block_ : 0;
- tenc->default_is_protected = 1;
- tenc->default_per_sample_IV_size = 0;
- tenc->default_constant_IV_size = iv_size_;
- memcpy(tenc->default_constant_IV, iv_, iv_size_);
- memcpy(tenc->default_KID, kid_, 16);
+ tenc->version_ = 1;
+ tenc->default_crypt_byte_block_ = is_video_sample ? crypt_byte_block_ : 0;
+ tenc->default_skip_byte_block_ = is_video_sample ? skip_byte_block_ : 0;
+ tenc->default_is_protected_ = 1;
+ tenc->default_per_sample_IV_size_ = 0;
+ tenc->default_constant_IV_size_ = iv_size_;
+ memcpy(tenc->default_constant_IV_, iv_, iv_size_);
+ memcpy(tenc->default_KID_, kid_, 16);
schi->append(tenc);
sinf->set_schi(schi);
@@ -7566,42 +7566,42 @@ srs_error_t SrsMp4M2tsInitEncoder::config_sample_description_encryption(SrsMp4Sa
SrsMp4M2tsSegmentEncoder::SrsMp4M2tsSegmentEncoder()
{
- writer = NULL;
- nb_audios = nb_videos = 0;
- samples = new SrsMp4SampleManager();
- sequence_number = 0;
- decode_basetime = 0;
- styp_bytes = 0;
- mdat_bytes = 0;
- track_id = 0;
+ writer_ = NULL;
+ nb_audios_ = nb_videos_ = 0;
+ samples_ = new SrsMp4SampleManager();
+ sequence_number_ = 0;
+ decode_basetime_ = 0;
+ styp_bytes_ = 0;
+ mdat_bytes_ = 0;
+ track_id_ = 0;
}
SrsMp4M2tsSegmentEncoder::~SrsMp4M2tsSegmentEncoder()
{
- srs_freep(samples);
+ srs_freep(samples_);
}
srs_error_t SrsMp4M2tsSegmentEncoder::initialize(ISrsWriter *w, uint32_t sequence, srs_utime_t basetime, uint32_t tid)
{
srs_error_t err = srs_success;
- writer = w;
- track_id = tid;
- sequence_number = sequence;
- decode_basetime = basetime;
+ writer_ = w;
+ track_id_ = tid;
+ sequence_number_ = sequence;
+ decode_basetime_ = basetime;
// Write styp box.
if (true) {
SrsUniquePtr styp(new SrsMp4SegmentTypeBox());
- styp->major_brand = SrsMp4BoxBrandMSDH;
- styp->minor_version = 0;
+ styp->major_brand_ = SrsMp4BoxBrandMSDH;
+ styp->minor_version_ = 0;
styp->set_compatible_brands(SrsMp4BoxBrandMSDH, SrsMp4BoxBrandMSIX);
// Used for sidx to calcalute the referenced size.
- styp_bytes = styp->nb_bytes();
+ styp_bytes_ = styp->nb_bytes();
- if ((err = srs_mp4_write_box(writer, styp.get())) != srs_success) {
+ if ((err = srs_mp4_write_box(writer_, styp.get())) != srs_success) {
return srs_error_wrap(err, "write styp");
}
}
@@ -7617,31 +7617,31 @@ srs_error_t SrsMp4M2tsSegmentEncoder::write_sample(SrsMp4HandlerType ht,
SrsMp4Sample *ps = new SrsMp4Sample();
if (ht == SrsMp4HandlerTypeVIDE) {
- ps->type = SrsFrameTypeVideo;
- ps->frame_type = (SrsVideoAvcFrameType)ft;
- ps->index = nb_videos++;
+ ps->type_ = SrsFrameTypeVideo;
+ ps->frame_type_ = (SrsVideoAvcFrameType)ft;
+ ps->index_ = nb_videos_++;
} else if (ht == SrsMp4HandlerTypeSOUN) {
- ps->type = SrsFrameTypeAudio;
- ps->index = nb_audios++;
+ ps->type_ = SrsFrameTypeAudio;
+ ps->index_ = nb_audios_++;
} else {
srs_freep(ps);
return err;
}
- ps->tbn = 1000;
- ps->dts = dts;
- ps->pts = pts;
+ ps->tbn_ = 1000;
+ ps->dts_ = dts;
+ ps->pts_ = pts;
// We should copy the sample data, which is shared ptr from video/audio message.
// Furthermore, we do free the data when freeing the sample.
- ps->data = new uint8_t[nb_sample];
- memcpy(ps->data, sample, nb_sample);
- ps->nb_data = nb_sample;
+ ps->data_ = new uint8_t[nb_sample];
+ memcpy(ps->data_, sample, nb_sample);
+ ps->nb_data_ = nb_sample;
// Append to manager to build the moof.
- samples->append(ps);
+ samples_->append(ps);
- mdat_bytes += nb_sample;
+ mdat_bytes_ += nb_sample;
return err;
}
@@ -7650,29 +7650,29 @@ srs_error_t SrsMp4M2tsSegmentEncoder::flush(uint64_t &dts)
{
srs_error_t err = srs_success;
- if (!nb_audios && !nb_videos) {
+ if (!nb_audios_ && !nb_videos_) {
return srs_error_new(ERROR_MP4_ILLEGAL_MOOF, "Missing audio and video track");
}
// Although the sidx is not required to start play DASH, but it's required for AV sync.
SrsUniquePtr sidx(new SrsMp4SegmentIndexBox());
if (true) {
- sidx->version = 1;
- sidx->reference_id = 1;
- sidx->timescale = 1000;
- sidx->earliest_presentation_time = uint64_t(decode_basetime / sidx->timescale);
+ sidx->version_ = 1;
+ sidx->reference_id_ = 1;
+ sidx->timescale_ = 1000;
+ sidx->earliest_presentation_time_ = uint64_t(decode_basetime_ / sidx->timescale_);
uint64_t duration = 0;
- if (samples && !samples->samples.empty()) {
- SrsMp4Sample *first = samples->samples[0];
- duration = srs_max(0, dts - first->dts);
+ if (samples_ && !samples_->samples_.empty()) {
+ SrsMp4Sample *first = samples_->samples_[0];
+ duration = srs_max(0, dts - first->dts_);
}
SrsMp4SegmentIndexEntry entry;
memset(&entry, 0, sizeof(entry));
- entry.subsegment_duration = duration;
- entry.starts_with_SAP = 1;
- sidx->entries.push_back(entry);
+ entry.subsegment_duration_ = duration;
+ entry.starts_with_SAP_ = 1;
+ sidx->entries_.push_back(entry);
}
// Create a mdat box.
@@ -7687,7 +7687,7 @@ srs_error_t SrsMp4M2tsSegmentEncoder::flush(uint64_t &dts)
SrsMp4MovieFragmentHeaderBox *mfhd = new SrsMp4MovieFragmentHeaderBox();
moof->set_mfhd(mfhd);
- mfhd->sequence_number = sequence_number;
+ mfhd->sequence_number_ = sequence_number_;
SrsMp4TrackFragmentBox *traf = new SrsMp4TrackFragmentBox();
moof->add_traf(traf);
@@ -7695,35 +7695,35 @@ srs_error_t SrsMp4M2tsSegmentEncoder::flush(uint64_t &dts)
SrsMp4TrackFragmentHeaderBox *tfhd = new SrsMp4TrackFragmentHeaderBox();
traf->set_tfhd(tfhd);
- tfhd->track_id = track_id;
- tfhd->flags = SrsMp4TfhdFlagsDefaultBaseIsMoof;
+ tfhd->track_id_ = track_id_;
+ tfhd->flags_ = SrsMp4TfhdFlagsDefaultBaseIsMoof;
SrsMp4TrackFragmentDecodeTimeBox *tfdt = new SrsMp4TrackFragmentDecodeTimeBox();
traf->set_tfdt(tfdt);
- tfdt->version = 1;
- tfdt->base_media_decode_time = srsu2ms(decode_basetime);
+ tfdt->version_ = 1;
+ tfdt->base_media_decode_time_ = srsu2ms(decode_basetime_);
SrsMp4TrackFragmentRunBox *trun = new SrsMp4TrackFragmentRunBox();
traf->set_trun(trun);
- if ((err = samples->write(traf, dts)) != srs_success) {
+ if ((err = samples_->write(traf, dts)) != srs_success) {
return srs_error_wrap(err, "write samples");
}
// @remark Remember the data_offset of turn is size(moof)+header(mdat), not including styp or sidx.
int moof_bytes = moof->nb_bytes();
- trun->data_offset = (int32_t)(moof_bytes + mdat->sz_header());
- mdat->nb_data = mdat_bytes;
+ trun->data_offset_ = (int32_t)(moof_bytes + mdat->sz_header());
+ mdat->nb_data_ = mdat_bytes_;
// Update the size of sidx.
- SrsMp4SegmentIndexEntry *entry = &sidx->entries[0];
- entry->referenced_size = moof_bytes + mdat->nb_bytes();
- if ((err = srs_mp4_write_box(writer, sidx.get())) != srs_success) {
+ SrsMp4SegmentIndexEntry *entry = &sidx->entries_[0];
+ entry->referenced_size_ = moof_bytes + mdat->nb_bytes();
+ if ((err = srs_mp4_write_box(writer_, sidx.get())) != srs_success) {
return srs_error_wrap(err, "write sidx");
}
- if ((err = srs_mp4_write_box(writer, moof.get())) != srs_success) {
+ if ((err = srs_mp4_write_box(writer_, moof.get())) != srs_success) {
return srs_error_wrap(err, "write moof");
}
}
@@ -7739,16 +7739,16 @@ srs_error_t SrsMp4M2tsSegmentEncoder::flush(uint64_t &dts)
}
// TODO: FIXME: Ensure all bytes are writen.
- if ((err = writer->write(data.get(), nb_data, NULL)) != srs_success) {
+ if ((err = writer_->write(data.get(), nb_data, NULL)) != srs_success) {
return srs_error_wrap(err, "write mdat");
}
vector::iterator it;
- for (it = samples->samples.begin(); it != samples->samples.end(); ++it) {
+ for (it = samples_->samples_.begin(); it != samples_->samples_.end(); ++it) {
SrsMp4Sample *sample = *it;
// TODO: FIXME: Ensure all bytes are writen.
- if ((err = writer->write(sample->data, sample->nb_data, NULL)) != srs_success) {
+ if ((err = writer_->write(sample->data_, sample->nb_data_, NULL)) != srs_success) {
return srs_error_wrap(err, "write sample");
}
}
@@ -7822,14 +7822,14 @@ srs_error_t SrsFmp4SegmentEncoder::write_sample(SrsMp4HandlerType ht, uint16_t f
SrsMp4Sample *ps = new SrsMp4Sample();
if (ht == SrsMp4HandlerTypeVIDE) {
- ps->type = SrsFrameTypeVideo;
- ps->frame_type = (SrsVideoAvcFrameType)ft;
- ps->index = nb_videos_++;
+ ps->type_ = SrsFrameTypeVideo;
+ ps->frame_type_ = (SrsVideoAvcFrameType)ft;
+ ps->index_ = nb_videos_++;
video_samples_->append(ps);
mdat_video_bytes_ += nb_sample;
} else if (ht == SrsMp4HandlerTypeSOUN) {
- ps->type = SrsFrameTypeAudio;
- ps->index = nb_audios_++;
+ ps->type_ = SrsFrameTypeAudio;
+ ps->index_ = nb_audios_++;
audio_samples_->append(ps);
mdat_audio_bytes_ += nb_sample;
} else {
@@ -7837,15 +7837,15 @@ srs_error_t SrsFmp4SegmentEncoder::write_sample(SrsMp4HandlerType ht, uint16_t f
return err;
}
- ps->tbn = 1000;
- ps->dts = dts;
- ps->pts = pts;
+ ps->tbn_ = 1000;
+ ps->dts_ = dts;
+ ps->pts_ = pts;
// We should copy the sample data, which is shared ptr from video/audio message.
// Furthermore, we do free the data when freeing the sample.
- ps->data = new uint8_t[nb_sample];
- memcpy(ps->data, sample, nb_sample);
- ps->nb_data = nb_sample;
+ ps->data_ = new uint8_t[nb_sample];
+ memcpy(ps->data_, sample, nb_sample);
+ ps->nb_data_ = nb_sample;
return err;
}
@@ -7868,7 +7868,7 @@ srs_error_t SrsFmp4SegmentEncoder::flush(uint64_t dts)
SrsMp4MovieFragmentHeaderBox *mfhd = new SrsMp4MovieFragmentHeaderBox();
moof->set_mfhd(mfhd);
- mfhd->sequence_number = sequence_number_;
+ mfhd->sequence_number_ = sequence_number_;
// write video traf
if (mdat_video_bytes_ > 0) {
@@ -7879,14 +7879,14 @@ srs_error_t SrsFmp4SegmentEncoder::flush(uint64_t dts)
SrsMp4TrackFragmentHeaderBox *tfhd = new SrsMp4TrackFragmentHeaderBox();
traf->set_tfhd(tfhd);
- tfhd->track_id = video_track_id_;
- tfhd->flags = SrsMp4TfhdFlagsDefaultBaseIsMoof;
+ tfhd->track_id_ = video_track_id_;
+ tfhd->flags_ = SrsMp4TfhdFlagsDefaultBaseIsMoof;
SrsMp4TrackFragmentDecodeTimeBox *tfdt = new SrsMp4TrackFragmentDecodeTimeBox();
traf->set_tfdt(tfdt);
- tfdt->version = 1;
- tfdt->base_media_decode_time = srsu2ms(decode_basetime_);
+ tfdt->version_ = 1;
+ tfdt->base_media_decode_time_ = srsu2ms(decode_basetime_);
SrsMp4TrackFragmentRunBox *trun = new SrsMp4TrackFragmentRunBox();
traf->set_trun(trun);
@@ -7902,7 +7902,7 @@ srs_error_t SrsFmp4SegmentEncoder::flush(uint64_t dts)
// video_samples_;
vector::iterator it;
// write video sample data
- for (it = video_samples_->samples.begin(); it != video_samples_->samples.end(); ++it) {
+ for (it = video_samples_->samples_.begin(); it != video_samples_->samples_.end(); ++it) {
// SrsMp4Sample* sample = *it;
// TODO: parse hevc|avc, nalu slice header, and calculate
// sample->data;
@@ -7922,14 +7922,14 @@ srs_error_t SrsFmp4SegmentEncoder::flush(uint64_t dts)
SrsMp4TrackFragmentHeaderBox *tfhd = new SrsMp4TrackFragmentHeaderBox();
traf->set_tfhd(tfhd);
- tfhd->track_id = audio_track_id_;
- tfhd->flags = SrsMp4TfhdFlagsDefaultBaseIsMoof;
+ tfhd->track_id_ = audio_track_id_;
+ tfhd->flags_ = SrsMp4TfhdFlagsDefaultBaseIsMoof;
SrsMp4TrackFragmentDecodeTimeBox *tfdt = new SrsMp4TrackFragmentDecodeTimeBox();
traf->set_tfdt(tfdt);
- tfdt->version = 1;
- tfdt->base_media_decode_time = srsu2ms(decode_basetime_);
+ tfdt->version_ = 1;
+ tfdt->base_media_decode_time_ = srsu2ms(decode_basetime_);
SrsMp4TrackFragmentRunBox *trun = new SrsMp4TrackFragmentRunBox();
traf->set_trun(trun);
@@ -7951,11 +7951,11 @@ srs_error_t SrsFmp4SegmentEncoder::flush(uint64_t dts)
int moof_bytes = moof->nb_bytes();
// rewrite video data_offset
if (video_trun != NULL) {
- video_trun->data_offset = (int32_t)(moof_bytes + mdat->sz_header() + 0);
+ video_trun->data_offset_ = (int32_t)(moof_bytes + mdat->sz_header() + 0);
}
if (audio_trun != NULL) {
- audio_trun->data_offset = (int32_t)(moof_bytes + mdat->sz_header() + mdat_video_bytes_);
+ audio_trun->data_offset_ = (int32_t)(moof_bytes + mdat->sz_header() + mdat_video_bytes_);
}
// srs_trace("seq: %d, moof_bytes=%d, mdat->sz_header=%d", sequence_number_, moof->nb_bytes(), mdat->sz_header());
@@ -7965,7 +7965,7 @@ srs_error_t SrsFmp4SegmentEncoder::flush(uint64_t dts)
return srs_error_wrap(err, "write moof");
}
- mdat->nb_data = mdat_video_bytes_ + mdat_audio_bytes_;
+ mdat->nb_data_ = mdat_video_bytes_ + mdat_audio_bytes_;
// Write mdat.
if (true) {
int nb_data = mdat->sz_header();
@@ -7983,23 +7983,23 @@ srs_error_t SrsFmp4SegmentEncoder::flush(uint64_t dts)
vector::iterator it;
// write video sample data
- for (it = video_samples_->samples.begin(); it != video_samples_->samples.end(); ++it) {
+ for (it = video_samples_->samples_.begin(); it != video_samples_->samples_.end(); ++it) {
SrsMp4Sample *sample = *it;
// TODO: FIXME: Ensure all bytes are writen.
// TODO: do cbcs encryption here. sample are nalu_length + nalu data.
- if ((err = writer_->write(sample->data, sample->nb_data, NULL)) != srs_success) {
+ if ((err = writer_->write(sample->data_, sample->nb_data_, NULL)) != srs_success) {
return srs_error_wrap(err, "write sample");
}
}
// write audio sample data
- for (it = audio_samples_->samples.begin(); it != audio_samples_->samples.end(); ++it) {
+ for (it = audio_samples_->samples_.begin(); it != audio_samples_->samples_.end(); ++it) {
SrsMp4Sample *sample = *it;
// TODO: FIXME: Ensure all bytes are writen.
// TODO: do cbcs encryption here
- if ((err = writer_->write(sample->data, sample->nb_data, NULL)) != srs_success) {
+ if ((err = writer_->write(sample->data_, sample->nb_data_, NULL)) != srs_success) {
return srs_error_wrap(err, "write sample");
}
}
diff --git a/trunk/src/kernel/srs_kernel_mp4.hpp b/trunk/src/kernel/srs_kernel_mp4.hpp
index b1c903ae9..c56343319 100644
--- a/trunk/src/kernel/srs_kernel_mp4.hpp
+++ b/trunk/src/kernel/srs_kernel_mp4.hpp
@@ -164,8 +164,8 @@ enum SrsMp4BoxBrand {
class SrsMp4DumpContext
{
public:
- int level;
- bool summary;
+ int level_;
+ bool summary_;
SrsMp4DumpContext();
virtual ~SrsMp4DumpContext();
@@ -184,23 +184,23 @@ private:
// if size is 1 then the actual size is in the field largesize;
// if size is 0, then this box is the last one in the file, and its contents
// extend to the end of the file (normally only used for a Media Data Box)
- uint32_t smallsize;
- uint64_t largesize;
+ uint32_t smallsize_;
+ uint64_t largesize_;
public:
// identifies the box type; standard boxes use a compact type, which is normally four printable
// characters, to permit ease of identification, and is shown so in the boxes below. User extensions use
// An extended type; in this case, the type field is set to ‘uuid’.
- SrsMp4BoxType type;
+ SrsMp4BoxType type_;
// For box 'uuid'.
- std::vector usertype;
+ std::vector usertype_;
protected:
- std::vector boxes;
+ std::vector boxes_;
private:
// The position at buffer to start demux the box.
- int start_pos;
+ int start_pos_;
public:
SrsMp4Box();
@@ -268,9 +268,9 @@ class SrsMp4FullBox : public SrsMp4Box
{
public:
// An integer that specifies the version of this format of the box.
- uint8_t version;
+ uint8_t version_;
// A map of flags
- uint32_t flags;
+ uint32_t flags_;
public:
SrsMp4FullBox();
@@ -295,13 +295,13 @@ class SrsMp4FileTypeBox : public SrsMp4Box
{
public:
// A brand identifier
- SrsMp4BoxBrand major_brand;
+ SrsMp4BoxBrand major_brand_;
// An informative integer for the minor version of the major brand
- uint32_t minor_version;
+ uint32_t minor_version_;
private:
// A list, to the end of the box, of brands
- std::vector compatible_brands;
+ std::vector compatible_brands_;
public:
SrsMp4FileTypeBox();
@@ -364,7 +364,7 @@ class SrsMp4MovieFragmentHeaderBox : public SrsMp4FullBox
{
public:
// The ordinal number of this fragment, in increasing order
- uint32_t sequence_number;
+ uint32_t sequence_number_;
public:
SrsMp4MovieFragmentHeaderBox();
@@ -438,15 +438,15 @@ enum SrsMp4TfhdFlags {
class SrsMp4TrackFragmentHeaderBox : public SrsMp4FullBox
{
public:
- uint32_t track_id;
+ uint32_t track_id_;
// all the following are optional fields
public:
// The base offset to use when calculating data offsets
- uint64_t base_data_offset;
- uint32_t sample_description_index;
- uint32_t default_sample_duration;
- uint32_t default_sample_size;
- uint32_t default_sample_flags;
+ uint64_t base_data_offset_;
+ uint32_t sample_description_index_;
+ uint32_t default_sample_duration_;
+ uint32_t default_sample_size_;
+ uint32_t default_sample_flags_;
public:
SrsMp4TrackFragmentHeaderBox();
@@ -472,7 +472,7 @@ class SrsMp4TrackFragmentDecodeTimeBox : public SrsMp4FullBox
{
public:
// It's in ms.
- uint64_t base_media_decode_time;
+ uint64_t base_media_decode_time_;
public:
SrsMp4TrackFragmentDecodeTimeBox();
@@ -512,13 +512,13 @@ enum SrsMp4TrunFlags {
class SrsMp4TrunEntry : public ISrsCodec
{
public:
- SrsMp4FullBox *owner;
+ SrsMp4FullBox *owner_;
- uint32_t sample_duration;
- uint32_t sample_size;
- uint32_t sample_flags;
+ uint32_t sample_duration_;
+ uint32_t sample_size_;
+ uint32_t sample_flags_;
// if version == 0, unsigned int(32); otherwise, signed int(32).
- int64_t sample_composition_time_offset;
+ int64_t sample_composition_time_offset_;
SrsMp4TrunEntry(SrsMp4FullBox *o);
virtual ~SrsMp4TrunEntry();
@@ -543,12 +543,12 @@ public:
// The following are optional fields
public:
// added to the implicit or explicit data_offset established in the track fragment header.
- int32_t data_offset;
+ int32_t data_offset_;
// provides a set of flags for the first sample only of this run.
- uint32_t first_sample_flags;
+ uint32_t first_sample_flags_;
// all fields in the following array are optional
public:
- std::vector entries;
+ std::vector entries_;
public:
SrsMp4TrackFragmentRunBox();
@@ -612,7 +612,7 @@ class SrsMp4MediaDataBox : public SrsMp4Box
{
public:
// The contained media data, which we never directly read/write it.
- uint64_t nb_data;
+ uint64_t nb_data_;
public:
SrsMp4MediaDataBox();
@@ -642,7 +642,7 @@ public:
class SrsMp4FreeSpaceBox : public SrsMp4Box
{
private:
- std::vector data;
+ std::vector data_;
public:
SrsMp4FreeSpaceBox(SrsMp4BoxType v);
@@ -698,37 +698,37 @@ class SrsMp4MovieHeaderBox : public SrsMp4FullBox
public:
// An integer that declares the creation time of the presentation (in seconds since
// midnight, Jan. 1, 1904, in UTC time)
- uint64_t creation_time;
+ uint64_t creation_time_;
// An integer that declares the most recent time the presentation was modified (in
// seconds since midnight, Jan. 1, 1904, in UTC time)
- uint64_t modification_time;
+ uint64_t modification_time_;
public:
// An integer that specifies the time-scale for the entire presentation; this is the number of
// time units that pass in one second. For example, a time coordinate system that measures time in
// sixtieths of a second has a time scale of 60.
- uint32_t timescale;
+ uint32_t timescale_;
// An integer that declares length of the presentation (in the indicated timescale). This property
// is derived from the presentation’s tracks: the value of this field corresponds to the duration of the
// longest track in the presentation. If the duration cannot be determined then duration is set to all 1s.
- uint64_t duration_in_tbn;
+ uint64_t duration_in_tbn_;
public:
// A fixed point 16.16 number that indicates the preferred rate to play the presentation; 1.0
// (0x00010000) is normal forward playback
- uint32_t rate;
+ uint32_t rate_;
// A fixed point 8.8 number that indicates the preferred playback volume. 1.0 (0x0100) is full volume.
- uint16_t volume;
- uint16_t reserved0;
- uint64_t reserved1;
+ uint16_t volume_;
+ uint16_t reserved0_;
+ uint64_t reserved1_;
// A transformation matrix for the video; (u,v,w) are restricted here to (0,0,1), hex values (0,0,0x40000000).
- int32_t matrix[9];
- uint32_t pre_defined[6];
+ int32_t matrix_[9];
+ uint32_t pre_defined_[6];
// A non-zero integer that indicates a value to use for the track ID of the next track to be
// added to this presentation. Zero is not a valid track ID value. The value of next_track_ID shall be
// larger than the largest track-ID in use. If this value is equal to all 1s (32-bit maxint), and a new media
// track is to be added, then a search must be made in the file for an unused track identifier.
- uint32_t next_track_ID;
+ uint32_t next_track_ID_;
public:
SrsMp4MovieHeaderBox();
@@ -776,12 +776,12 @@ class SrsMp4TrackExtendsBox : public SrsMp4FullBox
{
public:
// identifies the track; this shall be the track ID of a track in the Movie Box
- uint32_t track_ID;
+ uint32_t track_ID_;
// These fields set up defaults used in the track fragments.
- uint32_t default_sample_description_index;
- uint32_t default_sample_duration;
- uint32_t default_sample_size;
- uint32_t default_sample_flags;
+ uint32_t default_sample_description_index_;
+ uint32_t default_sample_duration_;
+ uint32_t default_sample_size_;
+ uint32_t default_sample_flags_;
public:
SrsMp4TrackExtendsBox();
@@ -869,47 +869,47 @@ class SrsMp4TrackHeaderBox : public SrsMp4FullBox
public:
// An integer that declares the creation time of the presentation (in seconds since
// midnight, Jan. 1, 1904, in UTC time)
- uint64_t creation_time;
+ uint64_t creation_time_;
// An integer that declares the most recent time the presentation was modified (in
// seconds since midnight, Jan. 1, 1904, in UTC time)
- uint64_t modification_time;
+ uint64_t modification_time_;
// An integer that uniquely identifies this track over the entire life-time of this presentation.
// Track IDs are never re-used and cannot be zero.
- uint32_t track_ID;
- uint32_t reserved0;
+ uint32_t track_ID_;
+ uint32_t reserved0_;
// An integer that indicates the duration of this track (in the timescale indicated in the Movie
// Header Box). The value of this field is equal to the sum of the durations of all of the track’s edits. If
// There is no edit list, then the duration is the sum of the sample durations, converted into the timescale
// in the Movie Header Box. If the duration of this track cannot be determined then duration is set to all
// 1s.
- uint64_t duration;
+ uint64_t duration_;
public:
- uint64_t reserved1;
+ uint64_t reserved1_;
// specifies the front-to-back ordering of video tracks; tracks with lower numbers are closer to the
// viewer. 0 is the normal value, and -1 would be in front of track 0, and so on.
- int16_t layer;
+ int16_t layer_;
// An integer that specifies a group or collection of tracks. If this field is 0 there is no
// information on possible relations to other tracks. If this field is not 0, it should be the same for tracks
// that contain alternate data for one another and different for tracks belonging to different such groups.
// Only one track within an alternate group should be played or streamed at any one time, and must be
// distinguishable from other tracks in the group via attributes such as bitrate, codec, language, packet
// size etc. A group may have only one member.
- int16_t alternate_group;
+ int16_t alternate_group_;
// A fixed 8.8 value specifying the track's relative audio volume. Full volume is 1.0 (0x0100) and
// is the normal value. Its value is irrelevant for a purely visual track. Tracks may be composed by
// combining them according to their volume, and then using the overall Movie Header Box volume
// setting; or more complex audio composition (e.g. MPEG-4 BIFS) may be used.
- int16_t volume;
- uint16_t reserved2;
+ int16_t volume_;
+ uint16_t reserved2_;
// A transformation matrix for the video; (u,v,w) are restricted here to (0,0,1), hex (0,0,0x40000000).
- int32_t matrix[9];
+ int32_t matrix_[9];
// The track's visual presentation size as fixed-point 16.16 values. These need
// not be the same as the pixel dimensions of the images, which is documented in the sample
// description(s); all images in the sequence are scaled to this size, before any overall transformation of
// The track represented by the matrix. The pixel dimensions of the images are the default values.
- int32_t width;
- int32_t height;
+ int32_t width_;
+ int32_t height_;
public:
SrsMp4TrackHeaderBox();
@@ -946,19 +946,19 @@ class SrsMp4ElstEntry
public:
// An integer that specifies the duration of this edit segment in units of the timescale
// in the Movie Header Box
- uint64_t segment_duration;
+ uint64_t segment_duration_;
// An integer containing the starting time within the media of this edit segment (in media time
// scale units, in composition time). If this field is set to –1, it is an empty edit. The last edit in a track
// shall never be an empty edit. Any difference between the duration in the Movie Header Box, and the
// track’s duration is expressed as an implicit empty edit at the end.
- int64_t media_time;
+ int64_t media_time_;
public:
// specifies the relative rate at which to play the media corresponding to this edit segment. If this value is 0,
// Then the edit is specifying a ‘dwell’: the media at media-time is presented for the segment-duration. Otherwise
// this field shall contain the value 1.
- int16_t media_rate_integer;
- int16_t media_rate_fraction;
+ int16_t media_rate_integer_;
+ int16_t media_rate_fraction_;
public:
SrsMp4ElstEntry();
@@ -979,7 +979,7 @@ class SrsMp4EditListBox : public SrsMp4FullBox
{
public:
// An integer that gives the number of entries in the following table
- std::vector entries;
+ std::vector entries_;
public:
SrsMp4EditListBox();
@@ -1029,25 +1029,25 @@ class SrsMp4MediaHeaderBox : public SrsMp4FullBox
public:
// An integer that declares the creation time of the presentation (in seconds since
// midnight, Jan. 1, 1904, in UTC time)
- uint64_t creation_time;
+ uint64_t creation_time_;
// An integer that declares the most recent time the presentation was modified (in
// seconds since midnight, Jan. 1, 1904, in UTC time)
- uint64_t modification_time;
+ uint64_t modification_time_;
// An integer that specifies the time-scale for the entire presentation; this is the number of
// time units that pass in one second. For example, a time coordinate system that measures time in
// sixtieths of a second has a time scale of 60.
- uint32_t timescale;
+ uint32_t timescale_;
// An integer that declares length of the presentation (in the indicated timescale). This property
// is derived from the presentation’s tracks: the value of this field corresponds to the duration of the
// longest track in the presentation. If the duration cannot be determined then duration is set to all 1s.
- uint64_t duration;
+ uint64_t duration_;
private:
// The language code for this media. See ISO 639-2/T for the set of three character
// codes. Each character is packed as the difference between its ASCII value and 0x60. Since the code
// is confined to being three lower-case letters, these values are strictly positive.
- uint16_t language;
- uint16_t pre_defined;
+ uint16_t language_;
+ uint16_t pre_defined_;
public:
SrsMp4MediaHeaderBox();
@@ -1083,15 +1083,15 @@ public:
class SrsMp4HandlerReferenceBox : public SrsMp4FullBox
{
public:
- uint32_t pre_defined;
+ uint32_t pre_defined_;
// An integer containing one of the following values, or a value from a derived specification:
// ‘vide’, Video track
// ‘soun’, Audio track
- SrsMp4HandlerType handler_type;
- uint32_t reserved[3];
+ SrsMp4HandlerType handler_type_;
+ uint32_t reserved_[3];
// A null-terminated string in UTF-8 characters which gives a human-readable name for the track
// type (for debugging and inspection purposes).
- std::string name;
+ std::string name_;
public:
SrsMp4HandlerReferenceBox();
@@ -1144,9 +1144,9 @@ public:
// A composition mode for this video track, from the following enumerated set,
// which may be extended by derived specifications:
// copy = 0 copy over the existing image
- uint16_t graphicsmode;
+ uint16_t graphicsmode_;
// A set of 3 colour values (red, green, blue) available for use by graphics modes
- uint16_t opcolor[3];
+ uint16_t opcolor_[3];
public:
SrsMp4VideoMeidaHeaderBox();
@@ -1167,8 +1167,8 @@ class SrsMp4SoundMeidaHeaderBox : public SrsMp4FullBox
public:
// A fixed-point 8.8 number that places mono audio tracks in a stereo space; 0 is centre (the
// normal value); full left is -1.0 and full right is 1.0.
- int16_t balance;
- uint16_t reserved;
+ int16_t balance_;
+ uint16_t reserved_;
public:
SrsMp4SoundMeidaHeaderBox();
@@ -1202,7 +1202,7 @@ public:
class SrsMp4DataEntryBox : public SrsMp4FullBox
{
public:
- std::string location;
+ std::string location_;
public:
SrsMp4DataEntryBox();
@@ -1234,7 +1234,7 @@ public:
class SrsMp4DataEntryUrnBox : public SrsMp4DataEntryBox
{
public:
- std::string name;
+ std::string name_;
public:
SrsMp4DataEntryUrnBox();
@@ -1257,7 +1257,7 @@ public:
class SrsMp4DataReferenceBox : public SrsMp4FullBox
{
private:
- std::vector