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*
hds_write_afra_atom_entry(u_char* p, uint64_t time, uint64_t offset)
{
write_be64(p, time);
write_be64(p, 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 vod_status_t
mp4_encrypt_init_state(
mp4_encrypt_state_t* state,
request_context_t* request_context,
media_set_t* media_set,
uint32_t segment_index,
segment_writer_t* segment_writer,
const u_char* iv)
{
media_sequence_t* sequence = &media_set->sequences[0];
drm_info_t* drm_info = (drm_info_t*)sequence->drm_info;
vod_status_t rc;
uint64_t iv_int;
u_char* p;
// fixed fields
state->request_context = request_context;
state->media_set = media_set;
state->sequence = sequence;
state->segment_index = segment_index;
state->segment_writer = *segment_writer;
// init the aes ctr
rc = mp4_aes_ctr_init(&state->cipher, request_context, drm_info->key);
if (rc != VOD_OK)
{
return rc;
}
// init the output buffer
write_buffer_init(
&state->write_buffer,
request_context,
segment_writer->write_tail,
segment_writer->context,
FALSE);
// increment the iv by the index of the first frame
iv_int = parse_be64(iv);
iv_int += sequence->filtered_clips[0].first_track->first_frame_index;
// Note: we don't know how many frames were in previous clips (were not parsed), assuming there won't be more than 60 fps
iv_int += (sequence->filtered_clips[0].first_track->clip_start_time * MAX_FRAME_RATE) / 1000;
p = state->iv;
write_be64(p, iv_int);
// init the first clip
state->cur_clip = sequence->filtered_clips;
mp4_encrypt_init_track(state, state->cur_clip->first_track);
// saiz / saio
state->saiz_atom_size = ATOM_HEADER_SIZE + sizeof(saiz_atom_t);
state->saio_atom_size = ATOM_HEADER_SIZE + sizeof(saio_atom_t);
return VOD_OK;
}
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_be32(p, 0x01000000); // version + flags
write_be32(p, 1); // reference id
write_be32(p, sidx_params->timescale); // timescale
write_be64(p, sidx_params->earliest_pres_time); // earliest presentation time
write_be64(p, 0LL); // first offset
write_be32(p, 1); // reserved + reference count
write_be32(p, reference_size); // referenced size
write_be32(p, sidx_params->total_frames_duration); // subsegment duration
write_be32(p, 0x90000000); // starts with SAP / SAP type
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;
}
static void
sparc64_fixup_plt (DSO *dso, GElf_Rela *rela, GElf_Addr value)
{
Elf64_Sxword disp = value - rela->r_offset;
if (rela->r_addend)
{
/* .plt[32768+] */
write_be64 (dso, rela->r_offset, value);
}
else if (disp >= -0x800000 && disp < 0x800000)
{
/* b,a value
nop
nop */
write_be32 (dso, rela->r_offset, 0x30800000 | ((disp >> 2) & 0x3fffff));
write_be32 (dso, rela->r_offset + 4, 0x01000000);
write_be32 (dso, rela->r_offset + 8, 0x01000000);
}
static int
sparc64_adjust_dyn (DSO *dso, int n, GElf_Dyn *dyn, GElf_Addr start,
GElf_Addr adjust)
{
if (dyn->d_tag == DT_PLTGOT)
{
int i;
for (i = 1; i < dso->ehdr.e_shnum; ++i)
if (! strcmp (strptr (dso, dso->ehdr.e_shstrndx,
dso->shdr[i].sh_name), ".got"))
{
Elf64_Addr data;
data = read_ube64 (dso, dso->shdr[i].sh_addr);
/* .got[0] points to _DYNAMIC, it needs to be adjusted. */
if (data == dso->shdr[n].sh_addr && data >= start)
write_be64 (dso, dso->shdr[i].sh_addr, data + adjust);
break;
}
}
return 0;
}
static u_char*
hds_write_abst_atom(
u_char* p,
media_set_t* media_set,
hds_segment_durations_t* segments)
{
segment_durations_t* segment_durations = &segments->durations;
segment_duration_item_t* cur_item;
segment_duration_item_t* last_item = segment_durations->items + segment_durations->item_count;
uint64_t timestamp;
uint32_t fragment_run_entries;
uint32_t segment_index;
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;
size_t extra_afrt_size = 0;
fragment_run_entries = segment_durations->item_count;
if (media_set->presentation_end)
{
fragment_run_entries++; // zero entry
extra_afrt_size += sizeof(u_char); // discontinuity indicator
}
fragment_run_entries += segment_durations->discontinuities; // zero entry
extra_afrt_size += fragment_run_entries * sizeof(afrt_entry_t) +
sizeof(u_char) * (segment_durations->discontinuities + segments->zero_segments); // discontinuity indicator
afrt_atom_size += extra_afrt_size;
abst_atom_size += extra_afrt_size;
// abst
write_atom_header(p, abst_atom_size, 'a', 'b', 's', 't');
write_be32(p, 0); // version + flags
write_be32(p, 1); // bootstrap info version
*p++ = (media_set->type == MEDIA_SET_LIVE ? 0x20 : 0); // profile, live, update
write_be32(p, HDS_TIMESCALE); // timescale
write_be64(p, segment_durations->end_time); // current media time
write_be64(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_be32(p, 0); // version + flags
*p++ = 0; // quality entries
write_be32(p, 1); // segment run entries
// entry #1
write_be32(p, 1); // first segment
write_be32(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_be32(p, 0); // version + flags
write_be32(p, HDS_TIMESCALE); // timescale
*p++ = 0; // quality entries
write_be32(p, fragment_run_entries); // fragment run entries
// write the afrt entries
for (cur_item = segment_durations->items; cur_item < last_item; cur_item++)
{
segment_index = cur_item->segment_index + 1;
timestamp = cur_item->time;
duration = cur_item->duration;
write_be32(p, segment_index); // first fragment
write_be64(p, timestamp); // first fragment timestamp
write_be32(p, duration); // fragment duration
if (duration == 0)
{
*p++ = 1; // discontinuity indicator (1 = discontinuity in fragment numbering)
}
if (cur_item + 1 < last_item && cur_item[1].discontinuity)
{
segment_index += cur_item->repeat_count;
timestamp += duration * cur_item->repeat_count;
write_be32(p, segment_index); // first fragment
write_be64(p, timestamp); // first fragment timestamp
write_be32(p, 0); // fragment duration
*p++ = 3; // discontinuity indicator (3 = discontinuity in both timestamps and fragment numbering)
}
}
if (media_set->presentation_end)
{
// last entry
write_be32(p, 0); // first fragment
write_be64(p, 0LL); // first fragment timestamp
write_be32(p, 0); // fragment duration
*p++ = 0; // discontinuity indicator (0 = end of presentation)
}
return p;
}
