标签：rsa sed mod exce bit after imp 视频 encoder
将音频数据封装到 ts 文件中。
/*
* mux the audio packet to ts.
* @param shared_audio, directly ptr, copy it if need to save it.
*/
int SrsHls::on_audio(SrsSharedPtrMessage* shared_audio)
{
int ret = ERROR_SUCCESS;
/* 检测是够使能了 hls */
if (!hls_enabled) {
return ret;
}
/* hls_dispose: HLS 清理的过期时间(s)，系统重启或者超过这个时间时，
* 清理 HLS 所有的文件，包括 m3u8 和 ts。默认为 0，即不清理 */
/* update the hls time, for hls_dispose */
last_update_time = srs_get_system_time_ms();
/* 将传入的音频消息拷贝一个副本 */
SrsSharedPtrMessage* audio = shared_audio->copy();
SrsAutoFree(SrsSharedPtrMessage, audio);
/* clear all samples.
* the sample units never copy the bytes, it directly use the ptr,
* so when video/audio packet is destroyed, the sample must be clear.
* in a word, user must clear sample before demux it.
* @remark demux sample use SrsAvcAacCodec.audio_aac_demux or video_avc_demux.*/
sample->clear();
/* 解析音频数据
* 对于 aac sequence header，会将该消息的负载拷贝到 aac_extra_data 中，
* 并解析其中相关字段；
* 对于 aac raw，则直接将负载数据的首地址赋给 sample_units[i]->bytes */
if ((ret = codec->audio_aac_demux(audio->payload, audio->size, sample))
!= ERROR_SUCCESS) {
if (ret != ERROR_HLS_TRY_MP3) {
srs_error("hls aac demux audio failed. ret=%d", ret);
return ret;
}
if ((ret = codec->audio_mp3_demux(audio->payload, audio->size, sample))
!= ERROR_SUCCESS) {
srs_error("hls mp3 demux audio failed. ret=%d", ret);
return ret;
}
}
SrsCodecAudio acodec = (SrsCodecAudio)codec->audio_codec_id;
/* ts support audio codec: aac/mp3 */
if (acodec != SrsCodecAudioAAC && acodec != SrsCodecAudioMP3) {
return ret;
}
/* update_acodec:
* when open ts, we donot write the header (PSI),
* for user may need to update the acodec to mp3 or others,
* so we use delay write PSI, when write audio or video.
* @remark for audio aac codec, for example, SRS1,
* it‘s ok to write PSI when open ts.
* @see https://github.com/ossrs/srs/issues/301
*/
/* when codec changed, write new header. */
if ((ret = muxer->update_acodec(acodec)) != ERROR_SUCCESS) {
srs_error("http: ts audio write header failed. ret=%d", ret);
return ret;
}
/* 忽略该 aac sequence header，即暂时不将该消息写入到 ts 中 */
/* ignore sequence header */
if (acodec == SrsCodecAudioAAC &&
sample->aac_packet_type == SrsCodecAudioTypeSequenceHeader) {
return hls_cache->on_sequence_header(muxer);
}
/* 第二个参数表示禁止 jitter correct */
/* TODO: FIXME: config the jitter of HLS. */
if ((ret = jitter->correct(audio, SrsRtmpJitterAlgorithmOFF))
!= ERROR_SUCCESS) {
srs_error("rtmp jitter correct audio failed. ret=%d", ret);
return ret;
}
/* 时间戳将每一秒分成 90000 份，即将每一毫秒分成 90 份，
* 在 flv 中直接存储的都是毫秒级，在 ts 存储的是时间戳级 */
/* the dts calc from rtmp/flv header. */
int64_t dts = audio->timestamp * 90;
/* for pure audio, we need to update the stream dts also. */
stream_dts = dts;
/* write audio to cache, if need to flush, flush to muxer. */
if ((ret = hls_cache->write_audio(codec, muxer, dts, sample))
!= ERROR_SUCCESS) {
srs_error("hls cache write audio failed. ret=%d", ret);
return ret;
}
return ret;
}/*
* demux the audio packet in aac codec.
* the packet mux in FLV/RTMP format defined in flv specification.
* demux the audio specified data(sound_format, sound_size, ...) to sample.
* demux the aac specified data(aac_profile, ...) to codec from sequence header
* demux the aac raw to sample units.
*/
int SrsAvcAacCodec::audio_aac_demux(char* data, int size,
SrsCodecSample* sample)
{
int ret = ERROR_SUCCESS;
sample->is_video = false;
if (!data || size <= 0) {
srs_trace("no audio present, ignore it.");
return ret;
}
if ((ret = stream->initialize(data, size)) != ERROR_SUCCESS) {
return ret;
}
/* audio decode */
if (!stream->require(1)) {
ret = ERROR_HLS_DECODE_ERROR;
srs_error("aac decode sound_format failed. ret=%d", ret);
return ret;
}
/* @see: E.4.2 Audio Tags, video_file_format_spec_v10_1.pdf, page 76 */
int8_t sound_format = stream->read_1bytes();
/* 声道：单声道 or 双声道，对于 AAC 永远是双声道 */
int8_t sound_type = sound_format & 0x01;
/* 采样精度: 8bit/16bit, 压缩过的音频都是 16bit */
int8_t sound_size = (sound_format >> 1) & 0x01;
/* 采样率: AAC 为 44KHz */
int8_t sound_rate = (sound_format >> 2) & 0x03;
/* 音频格式: 为 10，即 AAC */
sound_format = (sound_format >> 4) & 0x0f;
audio_codec_id = sound_format;
sample->acodec = (SrsCodecAudio)audio_codec_id;
sample->sound_type = (SrsCodecAudioSoundType)sound_type;
sample->sound_rate = (SrsCodecAudioSampleRate)sound_rate;
sample->sound_size = (SrsCodecAudioSampleSize)sound_size;
/* we support h.264+mp3 for hls. */
if (audio_codec_id == SrsCodecAudioMP3) {
return ERROR_HLS_TRY_MP3;
}
/* only support aac */
if (audio_codec_id != SrsCodecAudioAAC) {
ret = ERROR_HLS_DECODE_ERROR;
srs_error("aac only support mp3/aac codec. actual=%d, ret=%d",
audio_codec_id, ret);
return ret;
}
if (!stream->require(1)) {
ret = ERROR_HLS_DECODE_ERROR;
srs_error("aac decode aac_packet_type failed. ret=%d", ret);
return ret;
}
/* 0: AAC sequence header, 1: AAC raw */
int8_t aac_packet_type = stream->read_1bytes();
sample->aac_packet_type = (SrsCodecAudioType)aac_packet_type;
if (aac_packet_type == SrsCodecAudioTypeSequenceHeader) {
/* AudioSpecificConfig
* 1.6.2.1 AudioSpecificConfig,
* in aac-mp4a-format-ISO_IEC_14496-3+2001.pdf, page 33. */
aac_extra_size = stream->size() - stream->pos();
if (aac_extra_size > 0) {
srs_freepa(aac_extra_data);
aac_extra_data = new char[aac_extra_size];
memcpy(aac_extra_data, stream->data() + stream->pos(),
aac_extra_size);
/* demux the sequence header. */
if ((ret = audio_aac_sequence_header_demux(aac_extra_data, aac_extra_size))
!= ERROR_SUCCESS) {
return ret;
}
}
} else if (aac_packet_type == SrsCodecAudioTypeRawData) {
if (!is_aac_codec_ok()) {
srs_warn("aac ignore type=%d for no sequence header. ret=%d",
aac_packet_type, ret);
return ret;
}
if ((ret = sample->add_sample_unit(stream->data() + stream->pos(),
stream->size() - stream->pos())) != ERROR_SUCCESS) {
srs_error("aac add sample failed. ret=%d", ret);
return ret;
}
} else {
/* ignored */
}
/* reset the sample rate by sequence header */
if (aac_sample_rate != SRS_AAC_SAMPLE_RATE_UNSET) {
static int aac_sample_rates[] = {
96000, 88200, 64000, 48000,
44100, 32000, 24000, 22050,
16000, 12000, 11025, 8000,
7350, 0, 0, 0
};
/* 根据采样率索引值在采样率表中找到对应的采样率 */
switch (aac_sample_rates[aac_sample_rate]) {
case 11025:
sample->sound_rate = SrsCodecAudioSampleRate11025;
break;
case 22050:
sample->sound_rate = SrsCodecAudioSampleRate22050;
break;
case 44100:
sample->sound_rate = SrsCodecAudioSampleRate44100;
break;
default:
break;
};
}
return ret;
}int SrsAvcAacCodec::audio_aac_sequence_header_demux(char* data, int size)
{
int ret = ERROR_SUCCESS;
if ((ret = stream->initialize(data, size)) != ERROR_SUCCESS) {
return ret;
}
/*
* only need to decode the first 2bytes:
* audioObjectType, aac_profile, 5bits.
* samplingFrequencyIndex, aac_sample_rate, 4bits.
* channelConfiguration, aac_channels, 4bits
*/
if (!stream->require(2)) {
ret = ERROR_HLS_DECODE_ERROR;
srs_error("audio codec decode aac sequence header failed. ret=%d", ret);
return ret;
}
u_int8_t profile_ObjectType = stream->read_1bytes();
u_int8_t samplingFrequencyIndex = stream->read_1bytes();
/* AAC profile(5bits) */
aac_channels = (samplingFrequencyIndex >> 3) & 0x0f;
/* 采样率表中的索引值 */
samplingFrequencyIndex = ((profile_ObjectType << 1) & 0x0e) |
((samplingFrequencyIndex >> 7) & 0x01);
profile_ObjectType = (profile_ObjectType >> 3) & 0x1f;
/* set the aac sample rate.*/
aac_sample_rate = samplingFrequencyIndex;
/* convert the object type in sequence header to aac profile of ADTS. */
aac_object = (SrsAacObjectType)profile_ObjectType;
if (aac_object == SrsAacObjectTypeReserved) {
ret = ERROR_HLS_DECODE_ERROR;
srs_error("audio codec decode aac sequence header failed, "
"adts object=%d invalid. ret=%d", profile_ObjectType, ret);
return ret;
}
return ret;
}若该音频包为 raw data，则调用该函数进行处理.
/*
* add the a sample unit, it‘s a h.264 NALU or aac raw data.
* the sample unit directly use the ptr of packet bytes,
* so user must never use sample unit when packet is destroyed.
* in a word, user must clear sample before demux it.
*/
int SrsCodecSample::add_sample_unit(char* bytes, int size)
{
int ret = ERROR_SUCCESS;
/*
* nb_sample_units:
* each audio/video raw data packet will dumps to one or multiple buffers,
* the buffers will write to hls and clear to reset.
* generally, aac audio packet corresponding to one buffer,
* where avc/h264 video packet may contains multiple buffer.
*/
if (nb_sample_units >= SRS_SRS_MAX_CODEC_SAMPLE) {
ret = ERROR_HLS_DECODE_ERROR;
srs_error("hls decode samples error, "
"exceed the max count: %d, ret=%d", SRS_SRS_MAX_CODEC_SAMPLE, ret);
return ret;
}
SrsCodecSampleUnit* sample_unit = &sample_units[nb_sample_units++];
sample_unit->bytes = bytes;
sample_unit->size = size;
/* for video, parse the nalu type, set the IDR flag. */
if (is_video) {
SrsAvcNaluType nal_unit_type = (SrsAvcNaluType)(bytes[0] & 0x1f);
if (nal_unit_type == SrsAvcNaluTypeIDR) {
/* whether sample_units contains IDR frame. */
has_idr = true;
} else if (nal_unit_type == SrsAvcNaluTypeSPS ||
nal_unit_type == SrsAvcNaluTypePPS) {
has_sps_pps = true;
} else if (nal_unit_type == SrsAvcNaluTypeAccessUnitDelimiter) {
has_aud = true;
}
if (first_nalu_type == SrsAvcNaluTypeReserved) {
/* The first nalu type. */
first_nalu_type = nal_unit_type;
}
}
return ret;
}/*
* when get sequence header,
* must write a #EXT-X-DISCONTINUITY to m3u8.
* @see: hls-m3u8-draft-pantos-http-live-streaming-12.txt
* @see: 3.4.11. EXT-X-DISCONTINUITY
*/
int SrsHlsCache::on_sequence_header(SrsHlsMuxer* muxer)
{
/* TODO: support discontinuity for the same stream
* currently we reap and insert discontinity when encoder republish,
* but actually, event when stream is not republish, the
* sequence header may change, for example,
* ffmpeg ingest a external rtmp stream and push to srs,
* when the sequence header changed, the stream is not republish.
*/
return muxer->on_sequence_header();
}int SrsHlsMuxer::on_sequence_header()
{
int ret = ERROR_SUCCESS;
srs_assert(current);
/* set the current segment to sequence header,
* when close the segement, it will write a discontinuity to m3u8 file. */
current->is_sequence_header = true;
return ret;
}将 audio data 写入到缓存中，并将其 flush 到 ts 封装中。
/*
* write audio to cache, if need to flush, flush to muxer.
*/
int SrsHlsCache::write_audio(SrsAvcAacCodec* codec, SrsHlsMuxer* muxer,
int64_t pts, SrsCodecSample* sample)
{
int ret = ERROR_SUCCESS;
/* write audio to cache. */
if ((ret = cache->cache_audio(codec, pts, sample)) != ERROR_SUCCESS) {
return ret;
}
/*
* reap when current source is pure audio.
* it maybe changed when stream info changed,
* for example, pure audio when start, audio/video when publishing,
* pure audio again for audio disabled.
* so we reap event when the audio incoming when segment overflow.
* @see https://github.com/ossrs/srs/issues/151
* we use absolutely overflow of segment to make jwplayer/ffplay happy
* @see https://github.com/ossrs/srs/issues/151#issuecomment-71155184 */
if (cache->audio && muxer->is_segment_absolutely_overflow()) {
srs_info("hls: absolute audio reap segment.");
/* 若为纯音频时，当 ts 时长超过 hls_fragment*hls_aof_ratio，
* 这里即为 10*2.0=20s 时，就调用 reap_segment 切割 ts 文件，
* 这里暂不分析该函数，当纯音频时再分析 */
if ((ret = reap_segment("audio", muxer, cache->audio->pts)) != ERROR_SUCCESS) {
return ret;
}
}
/* for pure audio, aggregate some frame to one. */
if (muxer->pure_audio() && cache->audio) {
if (pts - cache->audio->start_pts < SRS_CONSTS_HLS_PURE_AUDIO_AGGREGATE) {
return ret;
}
}
/*
* directly write the audio frame by frame to ts,
* it‘s ok for the hls overload, or maye cause the audio corrupt,
* which introduced by aggregate the audios to a big one.
* @see https://github.com/ossrs/srs/issues/512
*/
if ((ret = muxer->flush_audio(cache)) != ERROR_SUCCESS) {
return ret;
}
return ret;
}/* write audio to cache */
int SrsTsCache::cache_audio(SrsAvcAacCodec* codec, int64_t dts, SrsCodecSample* sample)
{
int ret = ERROR_SUCCESS;
/* 若还没有创建 SrsTsMessage 类的 audio 对象，则新建一个，
* 该 SrsTsMessage* audio 表征当前的 ts message */
if (!audio) {
audio = new SrsTsMessage();
/*
* whether this message with pcr info,
* generally, the video IDR(I frame, the keyframe of h.264) carray the pcr info. */
audio->write_pcr = false;
/* the timestamp in 90khz */
audio->dts = audio->pts = audio->start_pts = dts;
}
/* sid 为 pes 层的 stream id，通常为 0xc0，即 SrsTsPESStreamIdAudioCommon */
/* the id of pes stream to indicates the paylaod codec.
* @remark use is_audio() and is_video() to check it,
* and stream_number() to finger it out. */
audio->sid = SrsTsPESStreamIdAudioCommon;
/* must be aac or mp3 */
SrsCodecAudio acodec = (SrsCodecAudio)codec->audio_codec_id;
srs_assert(acodec == SrsCodecAudioAAC || acodec == SrsCodecAudioMP3);
/* write audio to cache. */
if (codec->audio_codec_id == SrsCodecAudioAAC) {
/* 将音频数据写入到 cache 中 */
if ((ret = do_cache_aac(codec, sample)) != ERROR_SUCCESS) {
return ret;
}
} else {
if ((ret = do_cache_mp3(codec, sample)) != ERROR_SUCCESS) {
return ret;
}
}
return ret;
}/*
* the media audio/video message parsed from PES packet.
*/
SrsTsMessage::SrsTsMessage(SrsTsChannel* c, SrsTsPacket* p)
{
/* decoder only,
* the ts message does not use them,
* for user to get the channel and packet. */
channel = c;
packet = p;
/* the timestamp in 90khz */
dts = pts = 0;
/* the id of pes stream to indicates the payload codec.
* @remark, use is_audio() and is_video() to check it,
* and stream_number() to finger it out. */
sid = (SrsTsPESStreamId)0x00;
continuity_counter = 0;
/* the size of payload, 0 indicates the length() of payload. */
PES_packet_length = 0;
/* the payload bytes */
payload = new SrsSimpleBuffer();
/* whether got discontinuity ts, for example, sequence header changed. */
is_discontinuity = false;
/* the audio cache buffer start pts, to flush audio if full.
* @remark, the pts is not the adjust one, it‘s the orignal pts. */
start_pts = 0;
/* whether this message with pcr info,
* generally, the video IDR(I frame, the keyframe of h.264)
* carray the pcr info. */
write_pcr = false;
}int SrsTsCache::do_cache_aac(SrsAvcAacCodec* codec, SrsCodecSample* sample)
{
int ret = ERROR_SUCCESS;
/*
* nb_sample_units: s
* each audio/video raw data packet will dumps to one or multiple buffers,
* the buffers will write to hls and clear to reset.
* generally, aac audio packet corresponding to one buffer,
* where avc/h264 video packet may contains multiple buffer.
*/
for (int i = 0; i < sample->nb_sample_units; i++) {
SrsCodecSampleUnit* sample_unit = &sample->sample_units[i];
int32_t size = sample_unit->size;
if (!sample_unit->bytes || size <= 0 || size > 0x1fff) {
ret = ERROR_HLS_AAC_FRAME_LENGTH;
srs_error("invalid aac frame length=%d, ret=%d", size, ret);
return ret;
}
/* the frame length is the AAC raw data plus the adts header size. */
int32_t frame_length = size + 7;
/*
* AAC-ADTS
* 6.2 Audio Data Transport Stream, ADTS
* in aac-iso-13818-7.pdf, page 26.
* fixed 7bytes header
*/
u_int8_t adts_header[7] = {0xff, 0xf9, 0x00, 0x00, 0x00, 0x0f, 0xfc};
/*
* adts_fixed_header
* 2B, 16bits
* int16_t syncword; // 12bits, ‘1111 1111 1111‘
* int8_t ID; // 1bit, ‘1‘
* int8_t layer; // 2bits, ‘00‘
* int8_t protection_absent; // 1bit, can be ‘1‘
*
* 12bits
* int8_t profile; // 2bit, 7.1 Profiles, page 40
* TSAacSampleFrequency sampling_frequency_index; // 4bits, Table 35, page 46
* int8_t private_bit; // 1bit, can be ‘0‘
* int8_t channel_configuration; // 3bits, Table 8
* int8_t original_or_copy; // 1bit, can be ‘0‘
* int8_t home; // 1bit, can be ‘0‘
*
* adts_variable_header
* 28bits
* int8_t copyright_identification_bit; // 1bit, can be ‘0‘
* int8_t copyright_identification_start; // 1bit, can be ‘0‘
* int16_t frame_length; // 13bits
* int16_t adts_buffer_fullness; // 11bits, 7FF signals that the bitstream
* is a variable rate bitstream.
* int8_t number_of_raw_data_blocks_in_frame; // 2bits,
* // 0 indicating 1 raw_data_block()
*/
/* profile, 2bits */
SrsAacProfile aac_profile = srs_codec_aac_rtmp2ts(codec->aac_object);
adts_header[2] = (aac_profile << 6) & 0xc0;
/* sampling_frequency_index 4bits */
adts_header[2] |= (codec->aac_sample_rate << 2) & 0x3c;
/* channel_configuration 3bits */
adts_header[2] |= (codec->aac_channels >> 2) & 0x01;
adts_header[3] = (codec->aac_channels << 6) & 0xc0;
/* frame_length 13bits */
adts_header[3] |= (frame_length >> 11) & 0x03;
adts_header[4] = (frame_length >> 3) & 0xff;
adts_header[5] = ((frame_length << 5) & 0xe0);
/* adts_buffer_fullness; 11bits */
adts_header[5] |= 0x1f;
/* copy to audio buffer */
audio->payload->append((const char*)adts_header, sizeof(adts_header));
audio->payload->append(sample_unit->bytes, sample_unit->size);
}
return ret;
}/*
* append specified bytes to buffer.
* @param size, the size of bytes
* @remark, assert size is positive
*/
void SrsSimpleBuffer::append(const char* bytes, int size)
{
srs_assert(size > 0);
data.insert(data.end(), bytes, bytes + size);
}/* drop the segment when duration of ts too small. */
#define SRS_AUTO_HLS_SEGMENT_MIN_DURATION_MS 100
/*
* whether segment absolutely overflow, for pure audio to reap segment,
* that is whether the current segment duration>=2*(the segment in config)
* @see https://github.com/ossrs/srs/issues/151#issuecomment-71155184
*/
bool SrsHlsMuxer::is_segment_absolutely_overflow()
{
/* @see https://github.com/ossrs/srs/issues/151#issuecomment-83553950 */
srs_assert(current);
/* to prevent very small segment */
if (current->duration * 1000 < 2 * SRS_AUTO_HLS_SEGMENT_MIN_DURATION_MS) {
return false;
}
/* use N% deviation, to smoother. */
double deviation = hls_ts_floor? SRS_HLS_FLOOR_REAP_PERCENT * deviation_ts * hls_fragment : 0.0;
srs_info("hls: dur=%.2f, tar=%.2f, dev=%.2fms/%dp, frag=%.2f",
current->duration, hls_fragment + deviation,
deviation, deviation_ts, hls_fragment);
/* hls_aof_ratio: 倍数，纯音频时，当 ts 时长超过配置的 hls_fragment
* 乘以这个系数时就切割文件。例如，当 hls_fragment 是 10 秒，
* hls_aof_ratio 是 2.0 时，对于纯音频，10s * 2.0 = 20 秒就切割 ts 文件 */
return current->duration >= hls_aof_ratio * hls_fragment + deviation;
}/*
* reopen the muxer for a new hls segment,
* close current segment, open a new segment,
* then write the key frame to the new segment.
* so, user must reap_segment then flush_video to hls muxer.
*/
int SrsHlsCache::reap_segment(string log_desc, SrsHlsMuxer* muxer,
int64_t segment_start_dts)
{
int ret = ERROR_SUCCESS;
/* TODO: flush audio before or after segment?
* TODO: fresh segment begin with audio or video? */
/* close current ts. */
if ((ret = muxer->segment_close(log_desc)) != ERROR_SUCCESS) {
srs_error("m3u8 muxer close segment failed. ret=%d", ret);
return ret;
}
/* open new ts. */
if ((ret = muxer->segment_open(segment_start_dts)) != ERROR_SUCCES) {
srs_error("m3u8 muxer open segment failed. ret=%d", ret);
return ret;
}
/* segment open, flush video first. */
if ((ret = muxer->flush_video(cache)) != ERROR_SUCCESS) {
srs_error("m3u8 muxer flush video failed. ret=%d", ret);
return ret;
}
/* segment open, flush the audio.
* @see: ngx_rtmp_hls_open_fragment
* start fragment with audio to make iPhone happy */
if ((ret = muxer->flush_audio(cache)) != ERROR_SUCCESS) {
srs_error("m3u8 muxer flush audio failed. ret=%d", ret);
return ret;
}
return ret;
}/* whether current hls muxer is pure audio mode. */
bool SrsHlsMuxer::pure_audio()
{
return current && current->muxer && current->muxer->video_codec() == SrsCodecVideoDisabled;
}检测当前 hls muxer 是否是纯音频。
直接将音频帧逐帧写入到 ts 文件中。
int SrsHlsMuxer::flush_audio(SrsTsCache* cache)
{
int ret = ERROR_SUCCESS;
/* 检测是否已经打开当前要写入的片 */
/* if current is NULL, segment is not open, ignore the flush event. */
if (!current) {
srs_warn("flush audio ignored, for segment is not open.");
return ret;
}
/* cacha 缓冲必须有数据 */
if (!cache->audio || cache->audio->payload->length() <= 0) {
return ret;
}
/* 更新当前片的时长 */
current->update_duration(cache->audio->pts);
/* 将一个音频帧写入到 ts 文件中 */
if ((ret = current->muxer->write_audio(cache->audio)) != ERROR_SUCCESS)
{
return ret;
}
/* write success, clear and free the msg */
srs_freep(cache->audio);
return ret;
}该函数用于更新切片的时长。
/*
* update the segment duration.
* @current_frame_dts, the dts of frame, in tbn of ts.
*/
void SrsHlsSegment::update_duration(int64_t current_frame_dts)
{
/* we use video/audio to update segment duration,
* so when reap segment, some previous audio frame will
* update the segment duration, which is nagetive,
* just ignore it. */
if (current_frame_dts < segment_start_dts) {
/* for atc and timestamp jump, reset the start dts. */
if (current_frame_dts <
segment_start_dts - SRS_AUTO_HLS_SEGMENT_TIMESTAMP_JUMP_MS * 90)
segment_start_dts, current_frame_dts);
segment_start_dts = current_frame_dts;
}
return ;
}
/* duration: duration in seconds in m3u8. */
duration = (current_frame_dts - segment_start_dts) / 90000.0;
srs_assert(duration >= 0);
return;
}/* write an audio frame to ts */
int SrsTSMuxer::write_audio(SrsTsMessage* audio)
{
int ret = ERROR_SUCCESS;
/* ts 文件分三层：
* 1. ts 层: 是在 pes 层上加入数据流的识别和传输必须的信息
* 2. pes 层：是在音视频数据上加入了时间戳等对数据帧的说明信息
* 3. es 层：即音视频数据 */
/* 将音频帧写入到 PES packet 中 */
if ((ret = context->encode(writer, audio, vcodec, acodec))
!= ERROR_SUCCESS) {
srs_error("hls encode audio failed. ret=%d", ret);
return ret;
}
return ret;
}/*
* write the PES packet, the video/audio stream.
* @param msg, the video/audio msg to write to ts.
* @param vc, the video codec, write the PAT/PMT table when changed.
* @param ac, the audio codec, write the PAT/PMT table when changed.
*/
int SrsTsContext::encode(SrsFileWriter* writer, SrsTsMessage* msg,
SrsCodecVideo vc, SrsCodecAudio ac)
{
int ret = ERROR_SUCCESS;
SrsTsStream vs, as;
int16_t video_pid = 0, audio_pid = 0;
switch (vc) {
case SrsCodecVideoAVC:
vs = SrsTsStreamVideoH264;
video_pid = TS_VIDEO_AVC_PID;
break;
case SrsCodecVideoDisabled:
vs = SrsTsStreamReserved;
break;
case SrsCodecVideoReserved:
case SrsCodecVideoReserved1:
case SrsCodecVideoReserved2:
case SrsCodecVideoSorensonH263:
case SrsCodecVideoScreenVideo:
case SrsCodecVideoOn2VP6:
case SrsCodecVideoOn2VP6WithAlphaChannel:
case SrsCodecVideoScreenVideoVersion2:
vs = SrsTsStreamReserved;
break;
}
switch (ac) {
case SrsCodecAudioAAC:
as = SrsTsStreamAudioAAC;
audio_pid = TS_AUDIO_AAC_PID;
break;
case SrsCodecAudioMP3:
as = SrsTsStreamAudioMp3;
audio_pid = TS_AUDIO_MP3_PID;
break;
case SrsCodecAudioDisabled:
as = SrsTsStreamReserved;
break;
case SrsCodecAudioReserved1:
case SrsCodecAudioLinearPCMPlatformEndian:
case SrsCodecAudioADPCM:
case SrsCodecAudioLinearPCMLittleEndian:
case SrsCodecAudioNellymoser16kHzMono:
case SrsCodecAudioNellymoser8kHzMono:
case SrsCodecAudioNellymoser:
case SrsCodecAudioReservedG711AlawLogarithmicPCM:
case SrsCodecAudioReservedG711MuLawLogarithmicPCM:
case SrsCodecAudioReserved:
case SrsCodecAudioSpeex:
case SrsCodecAudioReservedMP3_8kHz:
case SrsCodecAudioReservedDeviceSpecificSound:
as = SrsTsStreamReserved;
break;
}
if (as == SrsTsStreamReserved && vs == SrsTsStreamReserved) {
ret = ERROR_HLS_NO_STREAM;
srs_error("hls: no video or audio stream, vcodec=%d, acodec=%d. ret=%d",
vc, ac, ret);
return ret;
}
/* when any codec changed, write PAT/PMT table. */
if (vcodec != vc || acodec != ac) {
vcodec = vc;
acodec = ac;
if ((ret = encode_pat_pmt(writer, video_pid, vs, audio_pid, as))
!= ERROR_SUCCESS) {
return ret;
}
}
/* encode the media frame to PES packets over TS. */
if (msg->is_audio()) {
/* 将音频数据封装成 pes 包 */
return encode_pes(writer, msg, audio_pid, as, vs == SrsTsStreamReserved);
} else {
return encode_pes(writer, msg, video_pid, vs, vs == SrsTsStreamReserved);
}
}该函数的具体分析可参考： SRS之SrsTsContext::encode_pes详解
标签：rsa sed mod exce bit after imp 视频 encoder
原文地址：https://www.cnblogs.com/jimodetiantang/p/9133348.html
