自学教程：C++ write_atom_header函数代码示例

static u_char*mss_write_uuid_tfrf_atom(u_char* p, segment_timing_info_t* timing_info){	size_t atom_size = TFRF_ATOM_SIZE;	uint64_t timestamp;	uint64_t duration;	int i;	timestamp = timing_info->timestamp;	duration = timing_info->duration;	write_atom_header(p, atom_size, 'u', 'u', 'i', 'd');	p = vod_copy(p, tfrf_uuid, sizeof(tfrf_uuid));	write_be32(p, 0x01000000);		// version / flags	*p++ = MSS_LOOK_AHEAD_COUNT;	for (i = 0; i < MSS_LOOK_AHEAD_COUNT; i++)	{		timestamp += duration;		write_be64(p, timestamp);		write_be64(p, duration);	}	return p;}

static u_char*edash_packager_passthrough_write_encryption_atoms(void* ctx, u_char* p, size_t mdat_atom_start){	mp4_encrypt_passthrough_context_t* context = ctx;	media_clip_filtered_t* cur_clip;	media_sequence_t* sequence = context->sequence;	media_track_t* cur_track;	size_t senc_atom_size;	uint32_t flags;	// saiz / saio	p = mp4_encrypt_passthrough_write_saiz_saio(ctx, p, mdat_atom_start - context->auxiliary_info_size);	// senc	senc_atom_size = ATOM_HEADER_SIZE + sizeof(senc_atom_t) + context->auxiliary_info_size;	write_atom_header(p, senc_atom_size, 's', 'e', 'n', 'c');	flags = context->use_subsamples ? 0x2 : 0x0;	write_be32(p, flags);		// flags	write_be32(p, sequence->total_frame_count);	for (cur_clip = sequence->filtered_clips; cur_clip < sequence->filtered_clips_end; cur_clip++)	{		cur_track = cur_clip->first_track;		p = vod_copy(p, 			cur_track->encryption_info.auxiliary_info, 			cur_track->encryption_info.auxiliary_info_end - cur_track->encryption_info.auxiliary_info);	}	return p;}

static u_char* mp4_builder_write_audio_trun_atom(u_char* p, media_sequence_t* sequence, uint32_t first_frame_offset){	media_clip_filtered_t* cur_clip;	input_frame_t* cur_frame;	input_frame_t* last_frame;	size_t atom_size;	atom_size = ATOM_HEADER_SIZE + sizeof(trun_atom_t) + sequence->total_frame_count * 2 * sizeof(uint32_t);	write_atom_header(p, atom_size, 't', 'r', 'u', 'n');	write_be32(p, 0x301);								// flags = data offset, duration, size	write_be32(p, sequence->total_frame_count);	write_be32(p, first_frame_offset);	// first frame offset relative to moof start offset	for (cur_clip = sequence->filtered_clips; cur_clip < sequence->filtered_clips_end; cur_clip++)	{		cur_frame = cur_clip->first_track->first_frame;		last_frame = cur_clip->first_track->last_frame;		for (; cur_frame < last_frame; cur_frame++)		{			write_be32(p, cur_frame->duration);			write_be32(p, cur_frame->size);		}	}	return p;}

static u_char*hds_write_afra_atom_header(u_char* p, size_t atom_size, uint32_t video_key_frame_count){	write_atom_header(p, atom_size, 'a', 'f', 'r', 'a');	write_be32(p, 0);	*p++ = 0xC0;								// LongIDs | LongOffsets	write_be32(p, HDS_TIMESCALE);				// timescale	write_be32(p, video_key_frame_count);		// entries	return p;}

u_char*mp4_builder_write_mfhd_atom(u_char* p, uint32_t segment_index){	size_t atom_size = ATOM_HEADER_SIZE + sizeof(mfhd_atom_t);	write_atom_header(p, atom_size, 'm', 'f', 'h', 'd');	write_be32(p, 0);	write_be32(p, segment_index);	return p;}

static u_char*dash_packager_write_tfdt64_atom(u_char* p, uint64_t earliest_pres_time){	size_t atom_size = ATOM_HEADER_SIZE + sizeof(tfdt64_atom_t);	write_atom_header(p, atom_size, 't', 'f', 'd', 't');	write_dword(p, 0x01000000);			// version = 1	write_qword(p, earliest_pres_time);	return p;}

static u_char*mss_playready_audio_write_uuid_piff_atom(u_char* p, mp4_encrypt_state_t* state, media_sequence_t* sequence, size_t atom_size){	write_atom_header(p, atom_size, 'u', 'u', 'i', 'd');	p = vod_copy(p, piff_uuid, sizeof(piff_uuid));	write_dword(p, 0);	write_dword(p, sequence->total_frame_count);	p = mp4_encrypt_audio_write_auxiliary_data(state, p);	return p;}

static u_char*mss_write_tfhd_atom(u_char* p, uint32_t track_id, uint32_t flags){	size_t atom_size = ATOM_HEADER_SIZE + sizeof(tfhd_atom_t);	write_atom_header(p, atom_size, 't', 'f', 'h', 'd');	write_dword(p, 0x20);		// default sample flags	write_dword(p, track_id);	write_dword(p, flags);	return p;}

static u_char*mss_playready_video_write_uuid_piff_atom(u_char* p, mp4_encrypt_video_state_t* state, media_sequence_t* sequence, size_t atom_size){	write_atom_header(p, atom_size, 'u', 'u', 'i', 'd');	p = vod_copy(p, piff_uuid, sizeof(piff_uuid));	write_be32(p, 2);	write_be32(p, sequence->total_frame_count);	p = vod_copy(p, state->auxiliary_data.start, state->auxiliary_data.pos - state->auxiliary_data.start);	return p;}

u_char*mp4_encrypt_audio_write_saiz_saio(mp4_encrypt_state_t* state, u_char* p, size_t auxiliary_data_offset){	size_t saiz_atom_size = ATOM_HEADER_SIZE + sizeof(saiz_atom_t);	size_t saio_atom_size = ATOM_HEADER_SIZE + sizeof(saio_atom_t);	// moof.traf.saiz	write_atom_header(p, saiz_atom_size, 's', 'a', 'i', 'z');	write_be32(p, 0);			// version, flags	*p++ = MP4_AES_CTR_IV_SIZE;				// default auxiliary sample size	write_be32(p, state->sequence->total_frame_count);	// moof.traf.saio	write_atom_header(p, saio_atom_size, 's', 'a', 'i', 'o');	write_be32(p, 0);			// version, flags	write_be32(p, 1);			// entry count	write_be32(p, auxiliary_data_offset);	return p;}

static u_char*mss_write_uuid_tfxd_atom(u_char* p, segment_timing_info_t* timing_info){	size_t atom_size = ATOM_HEADER_SIZE + sizeof(uuid_tfxd_atom_t);	write_atom_header(p, atom_size, 'u', 'u', 'i', 'd');	p = vod_copy(p, tfxd_uuid, sizeof(tfxd_uuid));	write_be32(p, 0x01000000);		// version / flags	write_be64(p, timing_info->timestamp);	write_be64(p, timing_info->duration);	return p;}

static u_char*hds_write_tfhd_atom(u_char* p, uint32_t track_id, uint64_t base_data_offset){	size_t atom_size = ATOM_HEADER_SIZE + sizeof(tfhd_atom_t);	write_atom_header(p, atom_size, 't', 'f', 'h', 'd');	write_be32(p, 3);							// flags - base data offset | sample description	write_be32(p, track_id);	write_be64(p, base_data_offset);	write_be32(p, 1);							// sample_desc_index	return p;}

u_char*mp4_encrypt_video_write_saiz_saio(mp4_encrypt_video_state_t* state, u_char* p, size_t auxiliary_data_offset){	// moof.traf.saiz	write_atom_header(p, state->base.saiz_atom_size, 's', 'a', 'i', 'z');	write_be32(p, 0);			// version, flags	*p++ = state->default_auxiliary_sample_size;	write_be32(p, state->saiz_sample_count);	if (state->default_auxiliary_sample_size == 0)	{		p = vod_copy(p, state->auxiliary_sample_sizes, state->saiz_sample_count);	}	// moof.traf.saio	write_atom_header(p, state->base.saio_atom_size, 's', 'a', 'i', 'o');	write_be32(p, 0);			// version, flags	write_be32(p, 1);			// entry count	write_be32(p, auxiliary_data_offset);	return p;}

static u_char*edash_packager_write_pssh(u_char* p, drm_system_info_t* cur_info){	size_t pssh_atom_size;	pssh_atom_size = ATOM_HEADER_SIZE + sizeof(pssh_atom_t) + cur_info->data.len;	write_atom_header(p, pssh_atom_size, 'p', 's', 's', 'h');	write_be32(p, 0);						// version + flags	p = vod_copy(p, cur_info->system_id, DRM_SYSTEM_ID_SIZE);	// system id	write_be32(p, cur_info->data.len);		// data size	p = vod_copy(p, cur_info->data.data, cur_info->data.len);	return p;}

static u_char*mss_write_uuid_tfxd_atom(u_char* p, mpeg_stream_metadata_t* stream_metadata){	size_t atom_size = ATOM_HEADER_SIZE + sizeof(uuid_tfxd_atom_t);	uint64_t timestamp = rescale_time(stream_metadata->first_frame_time_offset, stream_metadata->media_info.timescale, MSS_TIMESCALE);	uint64_t duration = rescale_time(stream_metadata->total_frames_duration, stream_metadata->media_info.timescale, MSS_TIMESCALE);	write_atom_header(p, atom_size, 'u', 'u', 'i', 'd');	p = vod_copy(p, tfxd_uuid, sizeof(tfxd_uuid));	write_dword(p, 0x01000000);		// version / flags	write_qword(p, timestamp);	write_qword(p, duration);	return p;}

static u_char*dash_packager_write_trex_atom(u_char* p, uint32_t track_id){	size_t atom_size = ATOM_HEADER_SIZE + sizeof(trex_atom_t);	write_atom_header(p, atom_size, 't', 'r', 'e', 'x');	write_dword(p, 0);			// version + flags	write_dword(p, track_id);	// track id	write_dword(p, 1);			// default sample description index	write_dword(p, 0);			// default sample duration	write_dword(p, 0);			// default sample size	write_dword(p, 0);			// default sample size	return p;}

static u_char*hds_write_single_audio_frame_trun_atom(u_char* p, input_frame_t* frame, uint32_t offset){	size_t atom_size;	atom_size = TRUN_SIZE_SINGLE_AUDIO_FRAME;	write_atom_header(p, atom_size, 't', 'r', 'u', 'n');	write_be32(p, 0x301);				// flags = data offset, duration, size	write_be32(p, 1);					// frame count	write_be32(p, offset);				// offset from mdat start to frame raw data (excluding the tag)	write_be32(p, frame->duration);	write_be32(p, frame->size);	return p;}

static u_char*dash_packager_write_mvhd64_atom(u_char* p, uint32_t timescale, uint64_t duration){	size_t atom_size = ATOM_HEADER_SIZE + sizeof(mvhd64_atom_t);	write_atom_header(p, atom_size, 'm', 'v', 'h', 'd');	write_dword(p, 0x01000000);	// version + flags	write_qword(p, 0LL);		// creation time	write_qword(p, 0LL);		// modification time	write_dword(p, timescale);	// timescale	write_qword(p, duration);	// duration	p = dash_packager_write_mvhd_constants(p);	write_dword(p, 0xffffffff); // next track id	return p;}

static u_char* mp4_builder_write_video_trun_atom(u_char* p, media_sequence_t* sequence, uint32_t first_frame_offset){	media_clip_filtered_t* cur_clip;	frame_list_part_t* part;	input_frame_t* cur_frame;	input_frame_t* last_frame;	size_t atom_size;	atom_size = ATOM_HEADER_SIZE + sizeof(trun_atom_t) + sequence->total_frame_count * 4 * sizeof(uint32_t);	write_atom_header(p, atom_size, 't', 'r', 'u', 'n');	write_be32(p, 0xF01);								// flags = data offset, duration, size, key, delay	write_be32(p, sequence->total_frame_count);	write_be32(p, first_frame_offset);	// first frame offset relative to moof start offset	for (cur_clip = sequence->filtered_clips; cur_clip < sequence->filtered_clips_end; cur_clip++)	{		part = &cur_clip->first_track->frames;		last_frame = part->last_frame;		for (cur_frame = part->first_frame;; cur_frame++)		{			if (cur_frame >= last_frame)			{				if (part->next == NULL)				{					break;				}				part = part->next;				cur_frame = part->first_frame;				last_frame = part->last_frame;			}			write_be32(p, cur_frame->duration);			write_be32(p, cur_frame->size);			if (cur_frame->key_frame)			{				write_be32(p, 0x00000000);			}			else			{				write_be32(p, 0x00010000);			}			write_be32(p, cur_frame->pts_delay);		}	}	return p;}

static u_char*edash_packager_audio_write_encryption_atoms(void* context, u_char* p, size_t mdat_atom_start){	mp4_encrypt_state_t* state = (mp4_encrypt_state_t*)context;	size_t senc_data_size = MP4_AES_CTR_IV_SIZE * state->sequence->total_frame_count;	size_t senc_atom_size = ATOM_HEADER_SIZE + sizeof(senc_atom_t) + senc_data_size;	// saiz / saio	p = mp4_encrypt_audio_write_saiz_saio(state, p, mdat_atom_start - senc_data_size);	// senc	write_atom_header(p, senc_atom_size, 's', 'e', 'n', 'c');	write_be32(p, 0x0);		// flags	write_be32(p, state->sequence->total_frame_count);	p = mp4_encrypt_audio_write_auxiliary_data(state, p);	return p;}

static u_char*edash_packager_video_write_encryption_atoms(void* context, u_char* p, size_t mdat_atom_start){	mp4_encrypt_video_state_t* state = (mp4_encrypt_video_state_t*)context;	size_t senc_data_size = state->auxiliary_data.pos - state->auxiliary_data.start;	size_t senc_atom_size = ATOM_HEADER_SIZE + sizeof(senc_atom_t) + senc_data_size;	// saiz / saio	p = mp4_encrypt_video_write_saiz_saio(state, p, mdat_atom_start - senc_data_size);	// senc	write_atom_header(p, senc_atom_size, 's', 'e', 'n', 'c');	write_be32(p, 0x2);		// flags	write_be32(p, state->base.sequence->total_frame_count);	p = vod_copy(p, state->auxiliary_data.start, senc_data_size);	return p;}

static u_char*dash_packager_write_sidx64_atom(	u_char* p,	sidx_params_t* sidx_params,	uint32_t reference_size){	size_t atom_size = ATOM_HEADER_SIZE + sizeof(sidx64_atom_t);	write_atom_header(p, atom_size, 's', 'i', 'd', 'x');	write_dword(p, 0x01000000);			// version + flags	write_dword(p, 1);					// reference id	write_dword(p, sidx_params->timescale);			// timescale	write_qword(p, sidx_params->earliest_pres_time);	// earliest presentation time	write_qword(p, 0LL);					// first offset	write_dword(p, 1);					// reserved + reference count	write_dword(p, reference_size);		// referenced size	write_dword(p, sidx_params->total_frames_duration);		// subsegment duration	write_dword(p, 0x90000000);			// starts with SAP / SAP type	return p;}

static u_char*edash_packager_write_pssh(void* context, u_char* p){	mp4_encrypt_system_info_array_t* pssh_array = (mp4_encrypt_system_info_array_t*)context;	mp4_encrypt_system_info_t* cur_info;	size_t pssh_atom_size;	for (cur_info = pssh_array->first; cur_info < pssh_array->last; cur_info++)	{		pssh_atom_size = ATOM_HEADER_SIZE + sizeof(pssh_atom_t) + cur_info->data.len;		write_atom_header(p, pssh_atom_size, 'p', 's', 's', 'h');		write_dword(p, 0);						// version + flags		p = vod_copy(p, cur_info->system_id, MP4_ENCRYPT_SYSTEM_ID_SIZE);	// system id		write_dword(p, cur_info->data.len);		// data size		p = vod_copy(p, cur_info->data.data, cur_info->data.len);	}	return p;}

static u_char*dash_packager_write_sidx_atom(	u_char* p,	mpeg_stream_metadata_t* stream_metadata,	uint32_t earliest_pres_time,	uint32_t reference_size){	size_t atom_size = ATOM_HEADER_SIZE + sizeof(sidx_atom_t);	write_atom_header(p, atom_size, 's', 'i', 'd', 'x');	write_dword(p, 0);					// version + flags	write_dword(p, 1);					// reference id	write_dword(p, stream_metadata->media_info.timescale);				// timescale	write_dword(p, earliest_pres_time);	// earliest presentation time	write_dword(p, 0);					// first offset	write_dword(p, 1);					// reserved + reference count	write_dword(p, reference_size);		// referenced size	write_dword(p, stream_metadata->total_frames_duration);		// subsegment duration	write_dword(p, 0x90000000);			// starts with SAP / SAP type	return p;}

static u_char*edash_packager_write_stsd(void* ctx, u_char* p){	stsd_writer_context_t* context = (stsd_writer_context_t*)ctx;	u_char format_by_media_type[MEDIA_TYPE_COUNT] = { 'v', 'a' };	// stsd	write_atom_header(p, context->stsd_atom_size, 's', 't', 's', 'd');	write_dword(p, 0);		// version + flags	write_dword(p, context->has_clear_lead ? 2 : 1);		// entries	// stsd encrypted entry	write_dword(p, context->encrypted_stsd_entry_size);		// size	write_atom_name(p, 'e', 'n', 'c', format_by_media_type[context->media_type]);	// format	p = vod_copy(p, context->original_stsd_entry + 1, context->original_stsd_entry_size - sizeof(stsd_entry_header_t));	// sinf	write_atom_header(p, context->sinf_atom_size, 's', 'i', 'n', 'f');		// sinf.frma	write_atom_header(p, context->frma_atom_size, 'f', 'r', 'm', 'a');	write_dword(p, context->original_stsd_entry_format);	// sinf.schm	write_atom_header(p, context->schm_atom_size, 's', 'c', 'h', 'm');	write_dword(p, 0);							// version + flags	write_atom_name(p, 'c', 'e', 'n', 'c');		// scheme type	write_dword(p, 0x10000);					// scheme version	// sinf.schi	write_atom_header(p, context->schi_atom_size, 's', 'c', 'h', 'i');	// sinf.schi.tenc	write_atom_header(p, context->tenc_atom_size, 't', 'e', 'n', 'c');	write_dword(p, 0);							// version + flags	write_dword(p, 0x108);						// default is encrypted (1) + iv size (8)	p = vod_copy(p, context->default_kid, MP4_ENCRYPT_KID_SIZE);			// default key id	// clear entry	if (context->has_clear_lead)	{		p = vod_copy(p, context->original_stsd_entry, context->original_stsd_entry_size);	}	return p;}

static u_char*dash_packager_write_tfhd_atom(u_char* p, uint32_t track_id, uint32_t sample_description_index){	size_t atom_size;	uint32_t flags;	flags = 0x020000;				// default-base-is-moof	atom_size = ATOM_HEADER_SIZE + sizeof(tfhd_atom_t);	if (sample_description_index > 0)	{		flags |= 0x02;				// sample-description-index-present		atom_size += sizeof(uint32_t);	}	write_atom_header(p, atom_size, 't', 'f', 'h', 'd');	write_dword(p, flags);			// flags	write_dword(p, track_id);		// track id	if (sample_description_index > 0)	{		write_dword(p, sample_description_index);	}	return p;}

static u_char*mss_playready_passthrough_write_encryption_atoms(void* ctx, u_char* p, size_t mdat_atom_start){	mp4_encrypt_passthrough_context_t* context = ctx;	media_clip_filtered_t* cur_clip;	media_sequence_t* sequence = context->sequence;	media_track_t* cur_track;	size_t auxiliary_data_offset;	size_t uuid_atom_size;	uint32_t flags;	// uuid piff	uuid_atom_size = ATOM_HEADER_SIZE + sizeof(uuid_piff_atom_t) + context->auxiliary_info_size;	write_atom_header(p, uuid_atom_size, 'u', 'u', 'i', 'd');	p = vod_copy(p, piff_uuid, sizeof(piff_uuid));	flags = context->use_subsamples ? 0x2 : 0x0;	write_be32(p, flags);		// flags	write_be32(p, sequence->total_frame_count);	for (cur_clip = sequence->filtered_clips; cur_clip < sequence->filtered_clips_end; cur_clip++)	{		cur_track = cur_clip->first_track;		p = vod_copy(p,			cur_track->encryption_info.auxiliary_info,			cur_track->encryption_info.auxiliary_info_end - cur_track->encryption_info.auxiliary_info);	}	// saiz / saio	auxiliary_data_offset = mdat_atom_start -		(context->auxiliary_info_size +		context->saiz_atom_size +		context->saio_atom_size);	p = mp4_encrypt_passthrough_write_saiz_saio(ctx, p, auxiliary_data_offset);	return p;}

static u_char*hds_write_single_video_frame_trun_atom(u_char* p, input_frame_t* frame, uint32_t offset){	size_t atom_size;	atom_size = TRUN_SIZE_SINGLE_VIDEO_FRAME;	write_atom_header(p, atom_size, 't', 'r', 'u', 'n');	write_be32(p, 0xF01);				// flags = data offset, duration, size, key, delay	write_be32(p, 1);					// frame count	write_be32(p, offset);				// offset from mdat start to frame raw data (excluding the tag)	write_be32(p, frame->duration);	write_be32(p, frame->size);	if (frame->key_frame)	{		write_be32(p, 0x02000000);		// I-frame	}	else	{		write_be32(p, 0x01010000);		// not I-frame + non key sample	}	write_be32(p, frame->pts_delay);	return p;}

static u_char*hds_write_abst_atom(	u_char* p, 	segment_durations_t* segment_durations){	segment_duration_item_t* cur_item;	segment_duration_item_t* last_item = segment_durations->items + segment_durations->item_count;	uint64_t start_offset = 0;	uint64_t timestamp;	uint32_t duration;	size_t afrt_atom_size = AFRT_BASE_ATOM_SIZE;	size_t asrt_atom_size = ASRT_ATOM_SIZE;	size_t abst_atom_size = ABST_BASE_ATOM_SIZE;	afrt_atom_size += (segment_durations->item_count + 1) * sizeof(afrt_entry_t);	abst_atom_size += (segment_durations->item_count + 1) * sizeof(afrt_entry_t);	// abst	write_atom_header(p, abst_atom_size, 'a', 'b', 's', 't');	write_dword(p, 0);					// version + flags	write_dword(p, 1);					// bootstrap info version	*p++ = 0;							// profile, live, update	write_dword(p, HDS_TIMESCALE);		// timescale	write_dword(p, 0);					// current media time - high	write_dword(p, segment_durations->duration_millis);	// current media time - low	write_qword(p, 0LL);				// smpte offset	*p++ = 0;							// movie identifier	*p++ = 0;							// server entries	*p++ = 0;							// quality entries	*p++ = 0;							// drm data	*p++ = 0;							// metadata	*p++ = 1;							// segment run table count	// abst.asrt	write_atom_header(p, asrt_atom_size, 'a', 's', 'r', 't');	write_dword(p, 0);					// version + flags	*p++ = 0;							// quality entries	write_dword(p, 1);					// segment run entries	// entry #1	write_dword(p, 1);					// first segment	write_dword(p, segment_durations->segment_count);		// fragments per segment	// abst	*p++ = 1;							// fragment run table count	// abst.afrt	write_atom_header(p, afrt_atom_size, 'a', 'f', 'r', 't');	write_dword(p, 0);					// version + flags	write_dword(p, HDS_TIMESCALE);		// timescale	*p++ = 0;							// quality entries	write_dword(p, segment_durations->item_count + 1);	// fragment run entries	// write the afrt entries	for (cur_item = segment_durations->items; cur_item < last_item; cur_item++)	{		timestamp = rescale_time(start_offset, segment_durations->timescale, HDS_TIMESCALE);		duration = rescale_time(cur_item->duration, segment_durations->timescale, HDS_TIMESCALE);		write_dword(p, cur_item->segment_index + 1);		// first fragment		write_qword(p, timestamp);	// first fragment timestamp		write_dword(p, duration);			// fragment duration		start_offset += cur_item->duration * cur_item->repeat_count;	}	// last entry	write_dword(p, 0);					// first fragment	write_qword(p, 0LL);				// first fragment timestamp	write_dword(p, 0);					// fragment duration	*p++ = 0;							// discontinuity indicator (0 = end of presentation)	return p;}