void gf_ipmpx_write_array(GF_BitStream *bs, char *data, u32 data_len)
{
u32 length;
unsigned char vals[4];
if (!data || !data_len) return;
length = data_len;
vals[3] = (unsigned char) (length & 0x7f); length >>= 7;
vals[2] = (unsigned char) ((length & 0x7f) | 0x80); length >>= 7;
vals[1] = (unsigned char) ((length & 0x7f) | 0x80); length >>= 7;
vals[0] = (unsigned char) ((length & 0x7f) | 0x80);
if (data_len < 0x00000080) {
gf_bs_write_int(bs, vals[3], 8);
} else if (data_len < 0x00004000) {
gf_bs_write_int(bs, vals[2], 8);
gf_bs_write_int(bs, vals[3], 8);
} else if (data_len < 0x00200000) {
gf_bs_write_int(bs, vals[1], 8);
gf_bs_write_int(bs, vals[2], 8);
gf_bs_write_int(bs, vals[3], 8);
} else if (data_len < 0x10000000) {
gf_bs_write_int(bs, vals[0], 8);
gf_bs_write_int(bs, vals[1], 8);
gf_bs_write_int(bs, vals[2], 8);
gf_bs_write_int(bs, vals[3], 8);
} else {
return;
}
gf_bs_write_data(bs, data, data_len);
}
GF_EXPORT
GF_Err gf_odf_encode_ui_config(GF_UIConfig *cfg, GF_DefaultDescriptor **out_dsi)
{
u32 i, len;
GF_BitStream *bs;
GF_DefaultDescriptor *dsi;
if (!out_dsi || (cfg->tag != GF_ODF_UI_CFG_TAG)) return GF_BAD_PARAM;
*out_dsi = NULL;
if (!cfg->deviceName) return GF_OK;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
len = strlen(cfg->deviceName);
gf_bs_write_int(bs, len, 8);
for (i=0; i<len; i++) gf_bs_write_int(bs, cfg->deviceName[i], 8);
if (!stricmp(cfg->deviceName, "StringSensor")) {
/*fixme - this should be UTF-8 chars*/
if (cfg->delChar || cfg->termChar) {
gf_bs_write_int(bs, cfg->termChar, 8);
gf_bs_write_int(bs, cfg->delChar, 8);
}
}
if (cfg->ui_data) gf_bs_write_data(bs, cfg->ui_data, cfg->ui_data_length);
dsi = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
gf_bs_get_content(bs, &dsi->data, &dsi->dataLength);
gf_bs_del(bs);
*out_dsi = dsi;
return GF_OK;
}
GF_Err avcc_Write(GF_Box *s, GF_BitStream *bs)
{
u32 i, count;
GF_Err e;
GF_AVCConfigurationBox *ptr = (GF_AVCConfigurationBox *) s;
if (!s) return GF_BAD_PARAM;
if (!ptr->config) return GF_OK;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_u8(bs, ptr->config->configurationVersion);
gf_bs_write_u8(bs, ptr->config->AVCProfileIndication);
gf_bs_write_u8(bs, ptr->config->profile_compatibility);
gf_bs_write_u8(bs, ptr->config->AVCLevelIndication);
gf_bs_write_int(bs, 0x3F, 6);
gf_bs_write_int(bs, ptr->config->nal_unit_size - 1, 2);
gf_bs_write_int(bs, 0x7, 3);
count = gf_list_count(ptr->config->sequenceParameterSets);
gf_bs_write_int(bs, count, 5);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *) gf_list_get(ptr->config->sequenceParameterSets, i);
gf_bs_write_u16(bs, sl->size);
gf_bs_write_data(bs, sl->data, sl->size);
}
count = gf_list_count(ptr->config->pictureParameterSets);
gf_bs_write_u8(bs, count);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot *) gf_list_get(ptr->config->pictureParameterSets, i);
gf_bs_write_u16(bs, sl->size);
gf_bs_write_data(bs, sl->data, sl->size);
}
return GF_OK;
}
GF_Err WriteSevenBitLength(GF_BitStream *bs, u32 size)
{
u32 length;
unsigned char vals[4];
if (!bs || !size) return GF_BAD_PARAM;
length = size;
vals[3] = (unsigned char) (length & 0x7f);
length >>= 7;
vals[2] = (unsigned char) ((length & 0x7f) | 0x80);
length >>= 7;
vals[1] = (unsigned char) ((length & 0x7f) | 0x80);
length >>= 7;
vals[0] = (unsigned char) ((length & 0x7f) | 0x80);
if (size < 0x00000080) {
gf_bs_write_int(bs, vals[3], 8);
} else if (size < 0x00004000) {
gf_bs_write_int(bs, vals[2], 8);
gf_bs_write_int(bs, vals[3], 8);
} else if (size < 0x00200000) {
gf_bs_write_int(bs, vals[1], 8);
gf_bs_write_int(bs, vals[2], 8);
gf_bs_write_int(bs, vals[3], 8);
} else if (size < 0x10000000) {
gf_bs_write_int(bs, vals[0], 8);
gf_bs_write_int(bs, vals[1], 8);
gf_bs_write_int(bs, vals[2], 8);
gf_bs_write_int(bs, vals[3], 8);
} else {
return GF_ODF_INVALID_DESCRIPTOR;
}
return GF_OK;
}
GF_EXPORT
GF_Err gf_oci_codec_encode(OCICodec *codec, char **outAU, u32 *au_length)
{
GF_BitStream *bs;
u32 i, size, desc_size;
GF_Err e;
OCIEvent *ev;
if (!codec || !codec->Mode || *outAU) return GF_BAD_PARAM;
bs = NULL;
size = 0;
//get the size of each event
i=0;
while ((ev = (OCIEvent *)gf_list_enum(codec->OCIEvents, &i))) {
//fixed size header
size += 10;
e = gf_odf_size_descriptor_list(codec->OCIEvents, &desc_size);
if (e) goto err_exit;
size += desc_size;
}
//encode
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
e = WriteSevenBitLength(bs, size);
if (e) goto err_exit;
//get one event, write it and delete it
while (gf_list_count(codec->OCIEvents)) {
ev = (OCIEvent *)gf_list_get(codec->OCIEvents, 0);
gf_list_rem(codec->OCIEvents, 0);
gf_bs_write_int(bs, ev->EventID, 15);
gf_bs_write_int(bs, ev->AbsoluteTimeFlag, 1);
gf_bs_write_data(bs, ev->StartingTime, 4);
gf_bs_write_data(bs, ev->duration, 4);
e = gf_odf_write_descriptor_list(bs, ev->OCIDescriptors);
gf_oci_event_del(ev);
if (e) goto err_exit;
//OCI Event is aligned
gf_bs_align(bs);
}
gf_bs_get_content(bs, outAU, au_length);
gf_bs_del(bs);
return GF_OK;
err_exit:
if (bs) gf_bs_del(bs);
//delete everything
while (gf_list_count(codec->OCIEvents)) {
ev = (OCIEvent *)gf_list_get(codec->OCIEvents, 0);
gf_list_rem(codec->OCIEvents, 0);
gf_oci_event_del(ev);
}
return e;
}
GF_Err tenc_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_TrackEncryptionBox *ptr = (GF_TrackEncryptionBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_u8(bs, 0x0); //reserved
if (!ptr->version) {
gf_bs_write_u8(bs, 0x0); //reserved
}
else {
gf_bs_write_int(bs, ptr->crypt_byte_block, 4);
gf_bs_write_int(bs, ptr->skip_byte_block, 4);
}
gf_bs_write_u8(bs, ptr->isProtected);
gf_bs_write_u8(bs, ptr->Per_Sample_IV_Size);
gf_bs_write_data(bs, (char *)ptr->KID, 16);
if ((ptr->isProtected == 1) && !ptr->Per_Sample_IV_Size) {
gf_bs_write_u8(bs, ptr->constant_IV_size);
gf_bs_write_data(bs, (char *)ptr->constant_IV, ptr->constant_IV_size);
}
return GF_OK;
}
GF_Err iloc_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
u32 i, j, item_count, extent_count;
GF_ItemLocationBox *ptr = (GF_ItemLocationBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_int(bs, ptr->offset_size, 4);
gf_bs_write_int(bs, ptr->length_size, 4);
gf_bs_write_int(bs, ptr->base_offset_size, 4);
gf_bs_write_int(bs, 0, 4);
item_count = gf_list_count(ptr->location_entries);
gf_bs_write_u16(bs, item_count);
for (i = 0; i < item_count; i++) {
GF_ItemLocationEntry *location = (GF_ItemLocationEntry *)gf_list_get(ptr->location_entries, i);
gf_bs_write_u16(bs, location->item_ID);
gf_bs_write_u16(bs, location->data_reference_index);
gf_bs_write_long_int(bs, location->base_offset, 8*ptr->base_offset_size);
extent_count = gf_list_count(location->extent_entries);
gf_bs_write_u16(bs, extent_count);
for (j=0; j<extent_count; j++) {
GF_ItemExtentEntry *extent = (GF_ItemExtentEntry *)gf_list_get(location->extent_entries, j);
gf_bs_write_long_int(bs, extent->extent_offset, 8*ptr->offset_size);
gf_bs_write_long_int(bs, extent->extent_length, 8*ptr->length_size);
}
}
return GF_OK;
}
GF_Err gp_rtp_builder_do_h263(GP_RTPPacketizer *builder, char *data, u32 data_size, u8 IsAUEnd, u32 FullAUSize)
{
GF_BitStream *bs;
char hdr[2];
Bool Pbit;
u32 offset, size, max_size;
builder->rtp_header.TimeStamp = (u32) builder->sl_header.compositionTimeStamp;
/*the H263 hinter doesn't perform inter-sample concatenation*/
if (!data) return GF_OK;
Pbit = 1;
/*skip 16 0'ed bits of start code*/
offset = 2;
data_size -= 2;
max_size = builder->Path_MTU - 2;
while(data_size > 0) {
if(data_size > max_size){
size = max_size;
builder->rtp_header.Marker = 0;
}else{
size = data_size;
builder->rtp_header.Marker = 1;
}
data_size -= size;
/*create new RTP Packet */
builder->rtp_header.SequenceNumber += 1;
builder->OnNewPacket(builder->cbk_obj, &builder->rtp_header);
bs = gf_bs_new(hdr, 2, GF_BITSTREAM_WRITE);
gf_bs_write_int(bs, 0, 5);
gf_bs_write_int(bs, Pbit, 1);
gf_bs_write_int(bs, 0, 10);
gf_bs_del(bs);
/*add header*/
builder->OnData(builder->cbk_obj, (char*) hdr, 2, 1);
/*add payload*/
if (builder->OnDataReference)
builder->OnDataReference(builder->cbk_obj, size, offset);
else
builder->OnData(builder->cbk_obj, data + offset, size, 0);
builder->OnPacketDone(builder->cbk_obj, &builder->rtp_header);
offset += size;
Pbit = 0;
}
return GF_OK;
}
GF_Err gf_isom_hint_rtcp_write(GF_RTCPPacket *ptr, GF_BitStream *bs)
{
//RTP Header
gf_bs_write_int(bs, ptr->Version, 2);
gf_bs_write_int(bs, ptr->Padding, 1);
gf_bs_write_int(bs, ptr->Count, 5);
gf_bs_write_u8(bs, ptr->PayloadType);
gf_bs_write_u16(bs, 4*ptr->length);
gf_bs_write_data(bs, ptr->data, ptr->length);
return GF_OK;
}
GF_Err iSFM_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_ISMASampleFormatBox *ptr = (GF_ISMASampleFormatBox *)s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_int(bs, ptr->selective_encryption, 1);
gf_bs_write_int(bs, 0, 7);
gf_bs_write_u8(bs, ptr->key_indicator_length);
gf_bs_write_u8(bs, ptr->IV_length);
return GF_OK;
}
void gf_bifs_enc_name(GF_BifsEncoder *codec, GF_BitStream *bs, char *name)
{
u32 i = 0;
if (!name) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CODING, ("[BIFS] Coding IDs using names but no name is specified\n"));
i = 1;
} else {
while (name[i]) {
gf_bs_write_int(bs, name[i], 8);
i++;
}
}
gf_bs_write_int(bs, 0, 8);
GF_LOG(GF_LOG_DEBUG, GF_LOG_CODING, ("[BIFS] DEF\t\t%d\t\t%s\n", 8*i, name));
}
u32 MPEGVS_OnData(struct __input_device * dr, const char* data)
{
GF_BitStream *bs;
char *buf;
u32 buf_size;
float x, y, z;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
sscanf(data, "%f;%f;%f;", &x, &y, &z);
gf_bs_write_int(bs, 1, 1);
gf_bs_write_float(bs, x);
gf_bs_write_float(bs, y);
gf_bs_write_float(bs, z);
gf_bs_align(bs);
gf_bs_get_content(bs, &buf, &buf_size);
gf_bs_del(bs);
dr->DispatchFrame(dr, (u8*)buf, buf_size);
gf_free(buf);
return GF_OK;
}
GF_Err gf_isom_hint_rtp_write(GF_RTPPacket *ptr, GF_BitStream *bs)
{
GF_Err e;
u32 TLVcount, DTEcount, i;
GF_Box none;
GF_GenericDTE *dte;
gf_bs_write_u32(bs, ptr->relativeTransTime);
//RTP Header
// gf_bs_write_int(bs, 2, 2);
//version is 2
gf_bs_write_int(bs, 2, 2);
gf_bs_write_int(bs, ptr->P_bit, 1);
gf_bs_write_int(bs, ptr->X_bit, 1);
gf_bs_write_int(bs, 0, 4);
gf_bs_write_int(bs, ptr->M_bit, 1);
gf_bs_write_int(bs, ptr->payloadType, 7);
gf_bs_write_u16(bs, ptr->SequenceNumber);
gf_bs_write_int(bs, 0, 13);
TLVcount = gf_list_count(ptr->TLV);
DTEcount = gf_list_count(ptr->DataTable);
gf_bs_write_int(bs, TLVcount ? 1 : 0, 1);
gf_bs_write_int(bs, ptr->B_bit, 1);
gf_bs_write_int(bs, ptr->R_bit, 1);
gf_bs_write_u16(bs, DTEcount);
if (TLVcount) {
//first write the size of the table ...
none.size = 4; //WE INCLUDE THE SIZE FIELD LENGTH
none.type = 0;
gf_isom_box_array_size(&none, ptr->TLV);
gf_bs_write_u32(bs, (u32) none.size);
e = gf_isom_box_array_write(&none, ptr->TLV, bs);
if (e) return e;
}
//write the DTE...
for (i = 0; i < DTEcount; i++) {
dte = (GF_GenericDTE *)gf_list_get(ptr->DataTable, i);
e = WriteDTE(dte, bs);
if (e) return e;
}
return GF_OK;
}
u32 RunHTKDec(void *par)
{
GF_BitStream *bs;
char *szWord;
s32 word_index;
u32 len, val, i;
Float word_score;
GF_SLHeader slh;
GF_Codec *cod;
unsigned char *buf;
u32 buf_size;
ISPriv *is_dec = (ISPriv *)par;
// while (is_dec->htk_running)
HTK_DoDetection();
szWord = HTK_GetWord();
word_index = HTK_GetWordIndex();
word_score = HTK_GetWordScore();
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
/*HTK sensor buffer format: SFString - SFInt32 - SFFloat*/
gf_bs_write_int(bs, 1, 1);
len = strlen(szWord);
val = gf_get_bit_size(len);
gf_bs_write_int(bs, val, 5);
gf_bs_write_int(bs, len, val);
for (i=0; i<len; i++) gf_bs_write_int(bs, szWord[i], 8);
gf_bs_write_int(bs, 1, 1);
gf_bs_write_int(bs, word_index, 32);
gf_bs_write_int(bs, 1, 1);
gf_bs_write_float(bs, word_score);
gf_bs_align(bs);
gf_bs_get_content(bs, &buf, &buf_size);
gf_bs_del(bs);
memset(&slh, 0, sizeof(GF_SLHeader));
slh.accessUnitStartFlag = slh.accessUnitEndFlag = 1;
slh.compositionTimeStamp = 0;
/*get all IS keySensor decoders and send frame*/
i=0;
while ((cod = gf_list_enum(is_dec->scene->root_od->term->input_streams, &i))) {
ISPriv *is = cod->decio->privateStack;
if (is != is_dec) continue;
if (is->type==IS_HTKSensor) {
GF_Channel *ch = gf_list_get(cod->inChannels, 0);
gf_es_receive_sl_packet(ch->service, ch, buf, buf_size, &slh, GF_OK);
}
}
free(buf);
is_dec->htk_running = 0;
return 0;
}
static void rewrite_nalus_list(GF_List *nalus, GF_BitStream *bs, Bool rewrite_start_codes, u32 nal_unit_size_field)
{
u32 i, count = gf_list_count(nalus);
for (i=0; i<count; i++) {
GF_AVCConfigSlot *sl = gf_list_get(nalus, i);
if (rewrite_start_codes) gf_bs_write_u32(bs, 1);
else gf_bs_write_int(bs, sl->size, 8*nal_unit_size_field);
gf_bs_write_data(bs, sl->data, sl->size);
}
}
GF_Err gf_odf_write_esd_remove(GF_BitStream *bs, GF_ESDRemove *esdRem)
{
GF_Err e;
u32 size, i;
if (!esdRem) return GF_BAD_PARAM;
e = gf_odf_size_esd_remove(esdRem, &size);
if (e) return e;
e = gf_odf_write_base_descriptor(bs, esdRem->tag, size);
if (e) return e;
gf_bs_write_int(bs, esdRem->ODID, 10);
gf_bs_write_int(bs, 0, 6); //aligned
for (i = 0; i < esdRem->NbESDs; i++) {
gf_bs_write_int(bs, esdRem->ES_ID[i], 16);
}
//OD commands are aligned (but we are already aligned....
gf_bs_align(bs);
return GF_OK;
}
GF_Err gf_isom_rewrite_text_sample(GF_ISOSample *samp, u32 sampleDescriptionIndex, u32 sample_dur)
{
GF_BitStream *bs;
u32 pay_start, txt_size;
Bool is_utf_16 = 0;
if (!samp || !samp->data || !samp->dataLength) return GF_OK;
bs = gf_bs_new(samp->data, samp->dataLength, GF_BITSTREAM_READ);
txt_size = gf_bs_read_u16(bs);
gf_bs_del(bs);
/*remove BOM*/
pay_start = 2;
if (txt_size>2) {
/*seems 3GP only accepts BE UTF-16 (no LE, no UTF32)*/
if (((u8) samp->data[2]==(u8) 0xFE) && ((u8)samp->data[3]==(u8) 0xFF)) {
is_utf_16 = 1;
pay_start = 4;
txt_size -= 2;
}
}
/*rewrite as TTU(1)*/
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_int(bs, is_utf_16, 1);
gf_bs_write_int(bs, 0, 4);
gf_bs_write_int(bs, 1, 3);
gf_bs_write_u16(bs, 8 + samp->dataLength - pay_start);
gf_bs_write_u8(bs, sampleDescriptionIndex + SAMPLE_INDEX_OFFSET);
gf_bs_write_u24(bs, sample_dur);
/*write text size*/
gf_bs_write_u16(bs, txt_size);
if (txt_size) gf_bs_write_data(bs, samp->data + pay_start, samp->dataLength - pay_start);
gf_free(samp->data);
samp->data = NULL;
gf_bs_get_content(bs, &samp->data, &samp->dataLength);
gf_bs_del(bs);
return GF_OK;
}
GF_Err tenc_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_TrackEncryptionBox *ptr = (GF_TrackEncryptionBox *) s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_int(bs, ptr->IsEncrypted, 24);
gf_bs_write_u8(bs, ptr->IV_size);
gf_bs_write_data(bs, (char *) ptr->KID, 16);
return GF_OK;
}
GF_Err data_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_DataBox *ptr = (GF_DataBox *) s;
e = gf_isom_full_box_write(s, bs);
if (e) return e;
gf_bs_write_int(bs, ptr->reserved, 32);
if(ptr->data != NULL && ptr->dataSize > 0) {
gf_bs_write_data(bs, ptr->data, ptr->dataSize);
}
return GF_OK;
}
GF_Err gf_isom_ismacryp_sample_to_sample(GF_ISMASample *s, GF_ISOSample *dest)
{
GF_BitStream *bs;
if (!s || !dest) return GF_BAD_PARAM;
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
if (s->flags & GF_ISOM_ISMA_USE_SEL_ENC) {
gf_bs_write_int(bs, (s->flags & GF_ISOM_ISMA_IS_ENCRYPTED) ? 1 : 0, 1);
gf_bs_write_int(bs, 0, 7);
}
if (s->flags & GF_ISOM_ISMA_IS_ENCRYPTED) {
if (s->IV_length) gf_bs_write_long_int(bs, s->IV, 8*s->IV_length);
if (s->KI_length) gf_bs_write_data(bs, (char*)s->key_indicator, s->KI_length);
}
gf_bs_write_data(bs, s->data, s->dataLength);
if (dest->data) free(dest->data);
dest->data = NULL;
dest->dataLength = 0;
gf_bs_get_content(bs, &dest->data, &dest->dataLength);
gf_bs_del(bs);
return GF_OK;
}
static void DEV_Start(struct __input_device *ifce)
{
GF_BitStream *bs;
char *buf, *szWord;
u32 len, val, i, buf_size;
szWord = "Hello InputSensor!";
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
/*HTK sensor buffer format: SFString - SFInt32 - SFFloat*/
gf_bs_write_int(bs, 1, 1);
len = strlen(szWord);
val = gf_get_bit_size(len);
gf_bs_write_int(bs, val, 5);
gf_bs_write_int(bs, len, val);
for (i=0; i<len; i++) gf_bs_write_int(bs, szWord[i], 8);
gf_bs_align(bs);
gf_bs_get_content(bs, &buf, &buf_size);
gf_bs_del(bs);
ifce->DispatchFrame(ifce, buf, buf_size);
gf_free(buf);
}
GF_Err piff_tenc_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_PIFFTrackEncryptionBox *ptr = (GF_PIFFTrackEncryptionBox *) s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_u8(bs, ptr->version);
gf_bs_write_u24(bs, ptr->flags);
gf_bs_write_int(bs, ptr->AlgorithmID, 24);
gf_bs_write_u8(bs, ptr->IV_size);
gf_bs_write_data(bs, (char *) ptr->KID, 16);
return GF_OK;
}
static GF_Err BE_MultipleReplace(GF_BifsEncoder * codec, GF_Command *com, GF_BitStream *bs)
{
u32 i, j, nbBits, count, numFields, allField;
Bool use_list;
GF_FieldInfo field;
GF_Err e;
gf_bs_write_int(bs, gf_node_get_id(com->node)-1, codec->info->config.NodeIDBits);
count = gf_list_count(com->command_fields);
use_list = 1;
numFields = gf_node_get_num_fields_in_mode(com->node, GF_SG_FIELD_CODING_DEF);
nbBits = gf_get_bit_size(numFields - 1);
if (count < 1+count*(1+nbBits)) use_list = 0;
GF_BIFS_WRITE_INT(codec, bs, use_list ? 0 : 1, 1, "isMask", NULL);
for (i=0; i<numFields; i++) {
GF_CommandField *inf = NULL;
gf_bifs_get_field_index(com->node, i, GF_SG_FIELD_CODING_DEF, &allField);
for (j=0; j<count; j++) {
inf = (GF_CommandField *)gf_list_get(com->command_fields, j);
if (inf->fieldIndex==allField) break;
inf = NULL;
}
if (!inf) {
if (!use_list) GF_BIFS_WRITE_INT(codec, bs, 0, 1, "Mask", NULL);
continue;
}
/*common case*/
gf_node_get_field(com->node, inf->fieldIndex, &field);
if (use_list) {
/*not end flag*/
GF_BIFS_WRITE_INT(codec, bs, 0, 1, "end", NULL);
} else {
/*mask flag*/
GF_BIFS_WRITE_INT(codec, bs, 1, 1, "Mask", NULL);
}
if (use_list) GF_BIFS_WRITE_INT(codec, bs, i, nbBits, "field", (char*)field.name);
field.far_ptr = inf->field_ptr;
e = gf_bifs_enc_field(codec, bs, com->node, &field);
if (e) return e;
}
/*end flag*/
if (use_list) GF_BIFS_WRITE_INT(codec, bs, 1, 1, "end", NULL);
return GF_OK;
}
GF_Err gf_odf_write_od_remove(GF_BitStream *bs, GF_ODRemove *odRem)
{
GF_Err e;
u32 size, i;
if (!odRem) return GF_BAD_PARAM;
e = gf_odf_size_od_remove(odRem, &size);
if (e) return e;
e = gf_odf_write_base_descriptor(bs, odRem->tag, size);
if (e) return e;
for (i = 0; i < odRem->NbODs; i++) {
gf_bs_write_int(bs, odRem->OD_ID[i], 10);
}
//OD commands are aligned
gf_bs_align(bs);
return GF_OK;
}
GF_Err gf_odf_write_ipmp_remove(GF_BitStream *bs, GF_IPMPRemove *ipmpRem)
{
GF_Err e;
u32 size, i;
if (!ipmpRem) return GF_BAD_PARAM;
e = gf_odf_size_ipmp_remove(ipmpRem, &size);
if (e) return e;
e = gf_odf_write_base_descriptor(bs, ipmpRem->tag, size);
if (e) return e;
for (i = 0; i < ipmpRem->NbIPMPDs; i++) {
gf_bs_write_int(bs, ipmpRem->IPMPDescID[i], 8);
}
//OD commands are aligned
gf_bs_align(bs);
return GF_OK;
}
GF_Err gf_odf_write_qos_qual(GF_BitStream *bs, GF_QoS_Default *qos)
{
GF_Err e;
if (!bs || !qos) return GF_BAD_PARAM;
e = gf_odf_size_qos_qual(qos);
if (e) return e;
e = gf_odf_write_base_descriptor(bs, qos->tag, qos->size);
if (e) return e;
switch (qos->tag) {
case QoSMaxDelayTag:
gf_bs_write_int(bs, ((GF_QoS_MaxDelay *)qos)->MaxDelay, 32);
break;
case QoSPrefMaxDelayTag:
gf_bs_write_int(bs, ((GF_QoS_PrefMaxDelay *)qos)->PrefMaxDelay, 32);
break;
case QoSLossProbTag:
//FLOAT (double on 4 bytes)
gf_bs_write_float(bs, ((GF_QoS_LossProb *)qos)->LossProb);
break;
case QoSMaxGapLossTag:
gf_bs_write_int(bs, ((GF_QoS_MaxGapLoss *)qos)->MaxGapLoss, 32);
break;
case QoSMaxAUSizeTag:
gf_bs_write_int(bs, ((GF_QoS_MaxAUSize *)qos)->MaxAUSize, 32);
break;
case QoSAvgAUSizeTag:
gf_bs_write_int(bs, ((GF_QoS_AvgAUSize *)qos)->AvgAUSize, 32);
break;
case QoSMaxAURateTag:
gf_bs_write_int(bs, ((GF_QoS_MaxAURate *)qos)->MaxAURate, 32);
break;
case 0x00:
case 0xFF:
return GF_ODF_FORBIDDEN_DESCRIPTOR;
default:
//we defined the private qos...
gf_bs_write_data(bs, ((GF_QoS_Private *)qos)->Data, ((GF_QoS_Private *)qos)->DataLength);
break;
}
return GF_OK;
}
static void rtp_evrc_smv_flush(GP_RTPPacketizer *builder)
{
if (!builder->bytesInPacket) return;
if (builder->auh_size>1) {
char *hdr;
u32 hdr_size;
/*padding*/
if (builder->last_au_sn % 2) gf_bs_write_int(builder->pck_hdr, 0, 4);
gf_bs_get_content(builder->pck_hdr, &hdr, &hdr_size);
gf_bs_del(builder->pck_hdr);
builder->pck_hdr = NULL;
/*overwrite count*/
hdr[0] = 0;
hdr[1] = builder->last_au_sn-1;/*MMM + frameCount-1*/
builder->OnData(builder->cbk_obj, hdr, hdr_size, 1);
gf_free(hdr);
}
builder->OnPacketDone(builder->cbk_obj, &builder->rtp_header);
builder->bytesInPacket = 0;
builder->last_au_sn = 0;
}
static GF_Err BE_MultipleIndexedReplace(GF_BifsEncoder * codec, GF_Command *com, GF_BitStream *bs)
{
u32 i,nbBits, count, maxPos, nbBitsPos;
GF_FieldInfo field;
GF_Err e;
GF_CommandField *inf;
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField *)gf_list_get(com->command_fields, 0);
gf_bs_write_int(bs, gf_node_get_id(com->node)-1, codec->info->config.NodeIDBits);
nbBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(com->node, GF_SG_FIELD_CODING_IN)-1);
gf_bifs_field_index_by_mode(com->node, inf->fieldIndex, GF_SG_FIELD_CODING_IN, &i);
GF_BIFS_WRITE_INT(codec, bs, i, nbBits, "field", NULL);
gf_node_get_field(com->node, inf->fieldIndex, &field);
field.fieldType = inf->fieldType;
count = gf_list_count(com->command_fields);
maxPos = 0;
for (i=0; i<count; i++) {
inf = (GF_CommandField *)gf_list_get(com->command_fields, i);
if (maxPos < (u32) inf->pos) maxPos = inf->pos;
}
nbBitsPos = gf_get_bit_size(maxPos);
GF_BIFS_WRITE_INT(codec, bs, nbBitsPos, 5, "nbBitsPos", NULL);
nbBits = gf_get_bit_size(count);
GF_BIFS_WRITE_INT(codec, bs, nbBits, 5, "nbBits", NULL);
GF_BIFS_WRITE_INT(codec, bs, count, nbBits, "count", NULL);
for (i=0; i<count; i++) {
inf = (GF_CommandField *)gf_list_get(com->command_fields, i);
GF_BIFS_WRITE_INT(codec, bs, inf->pos, nbBitsPos, "idx", NULL);
field.far_ptr = inf->field_ptr;
e = gf_bifs_enc_field(codec, bs, com->node, &field);
if (e) return e;
}
return GF_OK;
}
GF_Err piff_psec_Write(GF_Box *s, GF_BitStream *bs)
{
GF_Err e;
GF_PIFFSampleEncryptionBox *ptr = (GF_PIFFSampleEncryptionBox *) s;
if (!s) return GF_BAD_PARAM;
e = gf_isom_box_write_header(s, bs);
if (e) return e;
gf_bs_write_u8(bs, ptr->version);
gf_bs_write_u24(bs, ptr->flags);
if (ptr->flags & 1) {
gf_bs_write_int(bs, ptr->AlgorithmID, 24);
gf_bs_write_u8(bs, ptr->IV_size);
gf_bs_write_data(bs, (char *) ptr->KID, 16);
}
gf_bs_write_u32(bs, ptr->sample_count);
if (ptr->cenc_data && ptr->cenc_data_size) {
gf_bs_write_data(bs, ptr->cenc_data, ptr->cenc_data_size);
}
return GF_OK;
}
GF_Err gf_odf_write_esd_update(GF_BitStream *bs, GF_ESDUpdate *esdUp)
{
GF_Descriptor *tmp;
GF_Err e;
u32 size, i;
if (!esdUp) return GF_BAD_PARAM;
e = gf_odf_size_esd_update(esdUp, &size);
if (e) return e;
e = gf_odf_write_base_descriptor(bs, esdUp->tag, size);
if (e) return e;
gf_bs_write_int(bs, esdUp->ODID, 10);
i = 0;
while ((tmp = (GF_Descriptor *)gf_list_enum(esdUp->ESDescriptors, &i))) {
e = gf_odf_write_descriptor(bs, tmp);
if (e) return e;
}
//OD commands are aligned
gf_bs_align(bs);
return GF_OK;
}
