bool EasyMP4Writer::CreateMP4File(char*filename,int flag)
{
SaveFile();
m_audiostartimestamp=-1;
m_videostartimestamp=-1;
if(filename==NULL)
{
char filename2[256]={0};
sprintf_s(filename2,"%d-gpac%d.mp4",time(NULL),rand());
p_file=gf_isom_open(filename2,GF_ISOM_OPEN_WRITE,NULL);//打开文件
}else
p_file=gf_isom_open(filename,GF_ISOM_OPEN_WRITE,NULL);//打开文件
if (p_file==NULL)
{
return false;
}
gf_isom_set_brand_info(p_file,GF_ISOM_BRAND_MP42,0);
if(flag&ZOUTFILE_FLAG_VIDEO)
{
m_videtrackid=gf_isom_new_track(p_file,0,GF_ISOM_MEDIA_VISUAL,1000);
gf_isom_set_track_enabled(p_file,m_videtrackid,1);
}
if(flag&ZOUTFILE_FLAG_AUDIO)
{
m_audiotrackid=gf_isom_new_track(p_file,0,GF_ISOM_MEDIA_AUDIO,1000);
gf_isom_set_track_enabled(p_file,m_audiotrackid,1);
}
return true;
}
static int set_param( hnd_t handle, x264_param_t *p_param )
{
mp4_hnd_t *p_mp4 = handle;
p_mp4->i_delay_frames = p_param->i_bframe ? (p_param->i_bframe_pyramid ? 2 : 1) : 0;
p_mp4->i_dts_compress_multiplier = p_mp4->b_dts_compress * p_mp4->i_delay_frames + 1;
p_mp4->i_time_res = (uint64_t)p_param->i_timebase_den * p_mp4->i_dts_compress_multiplier;
p_mp4->i_time_inc = (uint64_t)p_param->i_timebase_num * p_mp4->i_dts_compress_multiplier;
FAIL_IF_ERR( p_mp4->i_time_res > UINT32_MAX, "mp4", "MP4 media timescale %"PRIu64" exceeds maximum\n", p_mp4->i_time_res )
p_mp4->i_track = gf_isom_new_track( p_mp4->p_file, 0, GF_ISOM_MEDIA_VISUAL,
p_mp4->i_time_res );
p_mp4->p_config = gf_odf_avc_cfg_new();
gf_isom_avc_config_new( p_mp4->p_file, p_mp4->i_track, p_mp4->p_config,
NULL, NULL, &p_mp4->i_descidx );
gf_isom_set_track_enabled( p_mp4->p_file, p_mp4->i_track, 1 );
gf_isom_set_visual_info( p_mp4->p_file, p_mp4->i_track, p_mp4->i_descidx,
p_param->i_width, p_param->i_height );
if( p_param->vui.i_sar_width && p_param->vui.i_sar_height )
{
uint64_t dw = p_param->i_width << 16;
uint64_t dh = p_param->i_height << 16;
double sar = (double)p_param->vui.i_sar_width / p_param->vui.i_sar_height;
if( sar > 1.0 )
dw *= sar ;
else
dh /= sar;
gf_isom_set_pixel_aspect_ratio( p_mp4->p_file, p_mp4->i_track, p_mp4->i_descidx, p_param->vui.i_sar_width, p_param->vui.i_sar_height );
gf_isom_set_track_layout_info( p_mp4->p_file, p_mp4->i_track, dw, dh, 0, 0, 0 );
}
p_mp4->i_data_size = p_param->i_width * p_param->i_height * 3 / 2;
p_mp4->p_sample->data = malloc( p_mp4->i_data_size );
if( !p_mp4->p_sample->data )
{
p_mp4->i_data_size = 0;
return -1;
}
return 0;
}
GF_EXPORT
GF_RTPHinter *gf_hinter_track_new(GF_ISOFile *file, u32 TrackNum,
u32 Path_MTU, u32 max_ptime, u32 default_rtp_rate, u32 flags, u8 PayloadID,
Bool copy_media, u32 InterleaveGroupID, u8 InterleaveGroupPriority, GF_Err *e)
{
GF_SLConfig my_sl;
u32 descIndex, MinSize, MaxSize, avgTS, streamType, oti, const_dur, nb_ch, maxDTSDelta;
u8 OfficialPayloadID;
u32 TrackMediaSubType, TrackMediaType, hintType, nbEdts, required_rate, force_dts_delta, avc_nalu_size, PL_ID, bandwidth, IV_length, KI_length;
const char *url, *urn;
char *mpeg4mode;
Bool is_crypted, has_mpeg4_mapping;
GF_RTPHinter *tmp;
GF_ESD *esd;
*e = GF_BAD_PARAM;
if (!file || !TrackNum || !gf_isom_get_track_id(file, TrackNum)) return NULL;
if (!gf_isom_get_sample_count(file, TrackNum)) {
*e = GF_OK;
return NULL;
}
*e = GF_NOT_SUPPORTED;
nbEdts = gf_isom_get_edit_segment_count(file, TrackNum);
if (nbEdts>1) {
u64 et, sd, mt;
u8 em;
gf_isom_get_edit_segment(file, TrackNum, 1, &et, &sd, &mt, &em);
if ((nbEdts>2) || (em!=GF_ISOM_EDIT_EMPTY)) {
GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("[rtp hinter] Cannot hint track whith EditList\n"));
return NULL;
}
}
if (nbEdts) gf_isom_remove_edit_segments(file, TrackNum);
if (!gf_isom_is_track_enabled(file, TrackNum)) return NULL;
/*by default NO PL signaled*/
PL_ID = 0;
OfficialPayloadID = 0;
force_dts_delta = 0;
streamType = oti = 0;
mpeg4mode = NULL;
required_rate = 0;
is_crypted = 0;
IV_length = KI_length = 0;
oti = 0;
nb_ch = 0;
avc_nalu_size = 0;
has_mpeg4_mapping = 1;
TrackMediaType = gf_isom_get_media_type(file, TrackNum);
TrackMediaSubType = gf_isom_get_media_subtype(file, TrackNum, 1);
/*for max compatibility with QT*/
if (!default_rtp_rate) default_rtp_rate = 90000;
/*timed-text is a bit special, we support multiple stream descriptions & co*/
if ( (TrackMediaType==GF_ISOM_MEDIA_TEXT) || (TrackMediaType==GF_ISOM_MEDIA_SUBT)) {
hintType = GF_RTP_PAYT_3GPP_TEXT;
oti = GPAC_OTI_TEXT_MPEG4;
streamType = GF_STREAM_TEXT;
/*fixme - this works cos there's only one PL for text in mpeg4 at the current time*/
PL_ID = 0x10;
} else {
if (gf_isom_get_sample_description_count(file, TrackNum) > 1) return NULL;
TrackMediaSubType = gf_isom_get_media_subtype(file, TrackNum, 1);
switch (TrackMediaSubType) {
case GF_ISOM_SUBTYPE_MPEG4_CRYP:
is_crypted = 1;
case GF_ISOM_SUBTYPE_MPEG4:
esd = gf_isom_get_esd(file, TrackNum, 1);
hintType = GF_RTP_PAYT_MPEG4;
if (esd) {
streamType = esd->decoderConfig->streamType;
oti = esd->decoderConfig->objectTypeIndication;
if (esd->URLString) hintType = 0;
/*AAC*/
if ((streamType==GF_STREAM_AUDIO) && esd->decoderConfig->decoderSpecificInfo
/*(nb: we use mpeg4 for MPEG-2 AAC)*/
&& ((oti==GPAC_OTI_AUDIO_AAC_MPEG4) || (oti==GPAC_OTI_AUDIO_AAC_MPEG4) || (oti==GPAC_OTI_AUDIO_AAC_MPEG2_MP) || (oti==GPAC_OTI_AUDIO_AAC_MPEG2_LCP) || (oti==GPAC_OTI_AUDIO_AAC_MPEG2_SSRP)) ) {
u32 sample_rate;
GF_M4ADecSpecInfo a_cfg;
gf_m4a_get_config(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, &a_cfg);
nb_ch = a_cfg.nb_chan;
sample_rate = a_cfg.base_sr;
PL_ID = a_cfg.audioPL;
switch (a_cfg.base_object_type) {
case GF_M4A_AAC_MAIN:
case GF_M4A_AAC_LC:
if (flags & GP_RTP_PCK_USE_LATM_AAC) {
hintType = GF_RTP_PAYT_LATM;
break;
}
case GF_M4A_AAC_SBR:
case GF_M4A_AAC_PS:
case GF_M4A_AAC_LTP:
case GF_M4A_AAC_SCALABLE:
case GF_M4A_ER_AAC_LC:
case GF_M4A_ER_AAC_LTP:
case GF_M4A_ER_AAC_SCALABLE:
mpeg4mode = "AAC";
break;
case GF_M4A_CELP:
case GF_M4A_ER_CELP:
mpeg4mode = "CELP";
break;
}
required_rate = sample_rate;
}
/*MPEG1/2 audio*/
else if ((streamType==GF_STREAM_AUDIO) && ((oti==GPAC_OTI_AUDIO_MPEG2_PART3) || (oti==GPAC_OTI_AUDIO_MPEG1))) {
u32 sample_rate;
if (!is_crypted) {
GF_ISOSample *samp = gf_isom_get_sample(file, TrackNum, 1, NULL);
u32 hdr = GF_4CC((u8)samp->data[0], (u8)samp->data[1], (u8)samp->data[2], (u8)samp->data[3]);
nb_ch = gf_mp3_num_channels(hdr);
sample_rate = gf_mp3_sampling_rate(hdr);
gf_isom_sample_del(&samp);
hintType = GF_RTP_PAYT_MPEG12_AUDIO;
/*use official RTP/AVP payload type*/
OfficialPayloadID = 14;
required_rate = 90000;
}
/*encrypted MP3 must be sent through MPEG-4 generic to signal all ISMACryp stuff*/
else {
u8 bps;
gf_isom_get_audio_info(file, TrackNum, 1, &sample_rate, &nb_ch, &bps);
required_rate = sample_rate;
}
}
/*QCELP audio*/
else if ((streamType==GF_STREAM_AUDIO) && (oti==GPAC_OTI_AUDIO_13K_VOICE)) {
hintType = GF_RTP_PAYT_QCELP;
OfficialPayloadID = 12;
required_rate = 8000;
streamType = GF_STREAM_AUDIO;
nb_ch = 1;
}
/*EVRC/SVM audio*/
else if ((streamType==GF_STREAM_AUDIO) && ((oti==GPAC_OTI_AUDIO_EVRC_VOICE) || (oti==GPAC_OTI_AUDIO_SMV_VOICE)) ) {
hintType = GF_RTP_PAYT_EVRC_SMV;
required_rate = 8000;
streamType = GF_STREAM_AUDIO;
nb_ch = 1;
}
/*visual streams*/
else if (streamType==GF_STREAM_VISUAL) {
if (oti==GPAC_OTI_VIDEO_MPEG4_PART2) {
GF_M4VDecSpecInfo dsi;
gf_m4v_get_config(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, &dsi);
PL_ID = dsi.VideoPL;
}
/*MPEG1/2 video*/
if ( ((oti>=GPAC_OTI_VIDEO_MPEG2_SIMPLE) && (oti<=GPAC_OTI_VIDEO_MPEG2_422)) || (oti==GPAC_OTI_VIDEO_MPEG1)) {
if (!is_crypted) {
hintType = GF_RTP_PAYT_MPEG12_VIDEO;
OfficialPayloadID = 32;
}
}
/*for ISMA*/
if (is_crypted) {
/*that's another pain with ISMACryp, even if no B-frames the DTS is signaled...*/
if (oti==GPAC_OTI_VIDEO_MPEG4_PART2) force_dts_delta = 22;
else if (oti==GPAC_OTI_VIDEO_AVC) {
flags &= ~GP_RTP_PCK_USE_MULTI;
force_dts_delta = 22;
}
flags |= GP_RTP_PCK_SIGNAL_RAP | GP_RTP_PCK_SIGNAL_TS;
}
required_rate = default_rtp_rate;
}
/*systems streams*/
else if (gf_isom_has_sync_shadows(file, TrackNum) || gf_isom_has_sample_dependency(file, TrackNum)) {
flags |= GP_RTP_PCK_SYSTEMS_CAROUSEL;
}
gf_odf_desc_del((GF_Descriptor*)esd);
}
break;
case GF_ISOM_SUBTYPE_3GP_H263:
hintType = GF_RTP_PAYT_H263;
required_rate = 90000;
streamType = GF_STREAM_VISUAL;
OfficialPayloadID = 34;
/*not 100% compliant (short header is missing) but should still work*/
oti = GPAC_OTI_VIDEO_MPEG4_PART2;
PL_ID = 0x01;
break;
case GF_ISOM_SUBTYPE_3GP_AMR:
required_rate = 8000;
hintType = GF_RTP_PAYT_AMR;
streamType = GF_STREAM_AUDIO;
has_mpeg4_mapping = 0;
nb_ch = 1;
break;
case GF_ISOM_SUBTYPE_3GP_AMR_WB:
required_rate = 16000;
hintType = GF_RTP_PAYT_AMR_WB;
streamType = GF_STREAM_AUDIO;
has_mpeg4_mapping = 0;
nb_ch = 1;
break;
case GF_ISOM_SUBTYPE_AVC_H264:
case GF_ISOM_SUBTYPE_AVC2_H264:
case GF_ISOM_SUBTYPE_SVC_H264:
{
GF_AVCConfig *avcc = gf_isom_avc_config_get(file, TrackNum, 1);
required_rate = 90000; /* "90 kHz clock rate MUST be used"*/
hintType = GF_RTP_PAYT_H264_AVC;
streamType = GF_STREAM_VISUAL;
avc_nalu_size = avcc->nal_unit_size;
oti = GPAC_OTI_VIDEO_AVC;
PL_ID = 0x0F;
gf_odf_avc_cfg_del(avcc);
}
break;
case GF_ISOM_SUBTYPE_3GP_QCELP:
required_rate = 8000;
hintType = GF_RTP_PAYT_QCELP;
streamType = GF_STREAM_AUDIO;
oti = GPAC_OTI_AUDIO_13K_VOICE;
OfficialPayloadID = 12;
nb_ch = 1;
break;
case GF_ISOM_SUBTYPE_3GP_EVRC:
case GF_ISOM_SUBTYPE_3GP_SMV:
required_rate = 8000;
hintType = GF_RTP_PAYT_EVRC_SMV;
streamType = GF_STREAM_AUDIO;
oti = (TrackMediaSubType==GF_ISOM_SUBTYPE_3GP_EVRC) ? GPAC_OTI_AUDIO_EVRC_VOICE : GPAC_OTI_AUDIO_SMV_VOICE;
nb_ch = 1;
break;
case GF_ISOM_SUBTYPE_3GP_DIMS:
hintType = GF_RTP_PAYT_3GPP_DIMS;
streamType = GF_STREAM_SCENE;
break;
case GF_ISOM_SUBTYPE_AC3:
hintType = GF_RTP_PAYT_AC3;
streamType = GF_STREAM_AUDIO;
gf_isom_get_audio_info(file, TrackNum, 1, NULL, &nb_ch, NULL);
break;
default:
/*ERROR*/
hintType = 0;
break;
}
}
/*not hintable*/
if (!hintType) return NULL;
/*we only support self-contained files for hinting*/
gf_isom_get_data_reference(file, TrackNum, 1, &url, &urn);
if (url || urn) return NULL;
*e = GF_OUT_OF_MEM;
GF_SAFEALLOC(tmp, GF_RTPHinter);
if (!tmp) return NULL;
/*override hinter type if requested and possible*/
if (has_mpeg4_mapping && (flags & GP_RTP_PCK_FORCE_MPEG4)) {
hintType = GF_RTP_PAYT_MPEG4;
avc_nalu_size = 0;
}
/*use static payload ID if enabled*/
else if (OfficialPayloadID && (flags & GP_RTP_PCK_USE_STATIC_ID) ) {
PayloadID = OfficialPayloadID;
}
tmp->file = file;
tmp->TrackNum = TrackNum;
tmp->avc_nalu_size = avc_nalu_size;
tmp->nb_chan = nb_ch;
/*spatial scalability check*/
tmp->has_ctts = gf_isom_has_time_offset(file, TrackNum);
/*get sample info*/
gf_media_get_sample_average_infos(file, TrackNum, &MinSize, &MaxSize, &avgTS, &maxDTSDelta, &const_dur, &bandwidth);
/*systems carousel: we need at least IDX and RAP signaling*/
if (flags & GP_RTP_PCK_SYSTEMS_CAROUSEL) {
flags |= GP_RTP_PCK_SIGNAL_RAP;
}
/*update flags in MultiSL*/
if (flags & GP_RTP_PCK_USE_MULTI) {
if (MinSize != MaxSize) flags |= GP_RTP_PCK_SIGNAL_SIZE;
if (!const_dur) flags |= GP_RTP_PCK_SIGNAL_TS;
}
if (tmp->has_ctts) flags |= GP_RTP_PCK_SIGNAL_TS;
/*default SL for RTP */
InitSL_RTP(&my_sl);
my_sl.timestampResolution = gf_isom_get_media_timescale(file, TrackNum);
/*override clockrate if set*/
if (required_rate) {
Double sc = required_rate;
sc /= my_sl.timestampResolution;
maxDTSDelta = (u32) (maxDTSDelta*sc);
my_sl.timestampResolution = required_rate;
}
/*switch to RTP TS*/
max_ptime = (u32) (max_ptime * my_sl.timestampResolution / 1000);
my_sl.AUSeqNumLength = gf_get_bit_size(gf_isom_get_sample_count(file, TrackNum));
my_sl.CUDuration = const_dur;
if (gf_isom_has_sync_points(file, TrackNum)) {
my_sl.useRandomAccessPointFlag = 1;
} else {
my_sl.useRandomAccessPointFlag = 0;
my_sl.hasRandomAccessUnitsOnlyFlag = 1;
}
if (is_crypted) {
Bool use_sel_enc;
gf_isom_get_ismacryp_info(file, TrackNum, 1, NULL, NULL, NULL, NULL, NULL, &use_sel_enc, &IV_length, &KI_length);
if (use_sel_enc) flags |= GP_RTP_PCK_SELECTIVE_ENCRYPTION;
}
// in case a different timescale was provided
tmp->OrigTimeScale = gf_isom_get_media_timescale(file, TrackNum);
tmp->rtp_p = gf_rtp_builder_new(hintType, &my_sl, flags, tmp,
MP4T_OnNewPacket, MP4T_OnPacketDone,
/*if copy, no data ref*/
copy_media ? NULL : MP4T_OnDataRef,
MP4T_OnData);
//init the builder
gf_rtp_builder_init(tmp->rtp_p, PayloadID, Path_MTU, max_ptime,
streamType, oti, PL_ID, MinSize, MaxSize, avgTS, maxDTSDelta, IV_length, KI_length, mpeg4mode);
/*ISMA compliance is a pain...*/
if (force_dts_delta) tmp->rtp_p->slMap.DTSDeltaLength = force_dts_delta;
/* Hint Track Setup */
tmp->TrackID = gf_isom_get_track_id(file, TrackNum);
tmp->HintID = tmp->TrackID + 65535;
while (gf_isom_get_track_by_id(file, tmp->HintID)) tmp->HintID++;
tmp->HintTrack = gf_isom_new_track(file, tmp->HintID, GF_ISOM_MEDIA_HINT, my_sl.timestampResolution);
gf_isom_setup_hint_track(file, tmp->HintTrack, GF_ISOM_HINT_RTP);
/*create a hint description*/
gf_isom_new_hint_description(file, tmp->HintTrack, -1, -1, 0, &descIndex);
gf_isom_rtp_set_timescale(file, tmp->HintTrack, descIndex, my_sl.timestampResolution);
if (hintType==GF_RTP_PAYT_MPEG4) {
tmp->rtp_p->slMap.ObjectTypeIndication = oti;
/*set this SL for extraction.*/
gf_isom_set_extraction_slc(file, TrackNum, 1, &my_sl);
}
tmp->bandwidth = bandwidth;
/*set interleaving*/
gf_isom_set_track_group(file, TrackNum, InterleaveGroupID);
if (!copy_media) {
/*if we don't copy data set hint track and media track in the same group*/
gf_isom_set_track_group(file, tmp->HintTrack, InterleaveGroupID);
} else {
gf_isom_set_track_group(file, tmp->HintTrack, InterleaveGroupID + OFFSET_HINT_GROUP_ID);
}
/*use user-secified priority*/
InterleaveGroupPriority*=2;
gf_isom_set_track_priority_in_group(file, TrackNum, InterleaveGroupPriority+1);
gf_isom_set_track_priority_in_group(file, tmp->HintTrack, InterleaveGroupPriority);
#if 0
/*QT FF: not setting these flags = server uses a random offset*/
gf_isom_rtp_set_time_offset(file, tmp->HintTrack, 1, 0);
/*we don't use seq offset for maintainance pruposes*/
gf_isom_rtp_set_time_sequence_offset(file, tmp->HintTrack, 1, 0);
#endif
*e = GF_OK;
return tmp;
}
static GF_Err ISOW_Write(GF_StreamingCache *mc, LPNETCHANNEL ch, char *data, u32 data_size, GF_SLHeader *sl_hdr)
{
ISOMChannel *mch;
GF_ESD *esd;
u32 di, mtype;
u64 DTS, CTS;
ISOMReader *cache = (ISOMReader *)mc->priv;
if (!cache->mov || !cache->service) return GF_BAD_PARAM;
mch = isor_get_channel(cache, ch);
if (!mch) {
Bool mapped;
GF_NetworkCommand com;
com.base.on_channel = ch;
com.base.command_type = GF_NET_CHAN_GET_ESD;
gf_service_command(cache->service, &com, GF_OK);
if (!com.cache_esd.esd) return GF_SERVICE_ERROR;
esd = (GF_ESD *)com.cache_esd.esd;
switch (esd->decoderConfig->streamType) {
case GF_STREAM_OD:
mtype = GF_ISOM_MEDIA_OD;
break;
case GF_STREAM_SCENE:
mtype = GF_ISOM_MEDIA_SCENE;
break;
case GF_STREAM_VISUAL:
mtype = GF_ISOM_MEDIA_VISUAL;
break;
case GF_STREAM_AUDIO:
mtype = GF_ISOM_MEDIA_AUDIO;
break;
case GF_STREAM_MPEG7:
mtype = GF_ISOM_MEDIA_MPEG7;
break;
case GF_STREAM_OCI:
mtype = GF_ISOM_MEDIA_OCI;
break;
case GF_STREAM_IPMP:
mtype = GF_ISOM_MEDIA_IPMP;
break;
case GF_STREAM_MPEGJ:
mtype = GF_ISOM_MEDIA_MPEGJ;
break;
case GF_STREAM_TEXT:
mtype = GF_ISOM_MEDIA_TEXT;
break;
default:
return GF_NOT_SUPPORTED;
}
GF_SAFEALLOC(mch, ISOMChannel);
if (!mch) {
return GF_OUT_OF_MEM;
}
mch->time_scale = esd->slConfig->timestampResolution;
mch->streamType = esd->decoderConfig->streamType;
mch->track = gf_isom_new_track(cache->mov, com.cache_esd.esd->ESID, mtype, mch->time_scale);
mch->is_playing = GF_TRUE;
mch->channel = ch;
mch->owner = cache;
gf_isom_set_track_enabled(cache->mov, mch->track, 1);
/*translate 3GP streams to MP4*/
mapped = GF_FALSE;
if (esd->decoderConfig->objectTypeIndication==GPAC_OTI_MEDIA_GENERIC) {
char szCode[5];
strncpy(szCode, esd->decoderConfig->decoderSpecificInfo->data, 4);
szCode[4]=0;
if (!stricmp(szCode, "samr") || !stricmp(szCode, "amr ") || !stricmp(szCode, "sawb")) {
GF_3GPConfig amrc;
mapped = GF_TRUE;
memset(&amrc, 0, sizeof(GF_3GPConfig));
amrc.frames_per_sample = (u32) esd->decoderConfig->decoderSpecificInfo->data[13];
amrc.type = (!stricmp(szCode, "sawb")) ? GF_ISOM_SUBTYPE_3GP_AMR_WB : GF_ISOM_SUBTYPE_3GP_AMR;
amrc.vendor = GF_VENDOR_GPAC;
gf_isom_3gp_config_new(cache->mov, mch->track, &amrc, NULL, NULL, &di);
} else if (!stricmp(szCode, "h263")) {
GF_3GPConfig h263c;
memset(&h263c, 0, sizeof(GF_3GPConfig));
h263c.type = GF_ISOM_SUBTYPE_3GP_H263;
h263c.vendor = GF_VENDOR_GPAC;
gf_isom_3gp_config_new(cache->mov, mch->track, &h263c, NULL, NULL, &di);
mapped = GF_TRUE;
}
}
if (!mapped) gf_isom_new_mpeg4_description(cache->mov, mch->track, esd, NULL, NULL, &di);
if (com.cache_esd.is_iod_stream) gf_isom_add_track_to_root_od(cache->mov, mch->track);
gf_list_add(cache->channels, mch);
}
/*first sample, cache it*/
if (!mch->cache_sample) {
mch->cache_seed_ts = sl_hdr->decodingTimeStamp;
mch->cache_sample = gf_isom_sample_new();
mch->cache_sample->IsRAP = sl_hdr->randomAccessPointFlag;
mch->cache_sample->dataLength = data_size;
mch->cache_sample->data = (char*)gf_malloc(sizeof(char)*data_size);
memcpy(mch->cache_sample->data, data, sizeof(char)*data_size);
return GF_OK;
}
/*adjust DTS/CTS*/
DTS = sl_hdr->decodingTimeStamp - mch->cache_seed_ts;
if ((mch->streamType==GF_STREAM_VISUAL) && (DTS<=mch->cache_sample->DTS)) {
assert(DTS>mch->prev_dts);
CTS = mch->cache_sample->DTS + mch->cache_sample->CTS_Offset;
mch->cache_sample->CTS_Offset = 0;
/*first time, shift all CTS*/
if (!mch->frame_cts_offset) {
u32 i, count = gf_isom_get_sample_count(cache->mov, mch->track);
mch->frame_cts_offset = (u32) (DTS-mch->prev_dts);
for (i=0; i<count; i++) {
gf_isom_modify_cts_offset(cache->mov, mch->track, i+1, mch->frame_cts_offset);
}
mch->cache_sample->CTS_Offset += mch->frame_cts_offset;
}
mch->cache_sample->DTS = mch->prev_dts + mch->frame_cts_offset;
mch->cache_sample->CTS_Offset += (u32) (CTS-mch->cache_sample->DTS);
}
/*deal with reference picture insertion: if no CTS offset and biggest CTS until now, this is
a reference insertion - we must check that in order to make sure we have strictly increasing DTSs*/
if (mch->max_cts && !mch->cache_sample->CTS_Offset && (mch->cache_sample->DTS+mch->cache_sample->CTS_Offset > mch->max_cts)) {
assert(mch->cache_sample->DTS > mch->prev_dts + mch->frame_cts_offset);
CTS = mch->cache_sample->DTS + mch->cache_sample->CTS_Offset;
mch->cache_sample->DTS = mch->prev_dts + mch->frame_cts_offset;
mch->cache_sample->CTS_Offset = (u32) (CTS-mch->cache_sample->DTS);
}
if (mch->cache_sample->CTS_Offset)
mch->max_cts = mch->cache_sample->DTS+mch->cache_sample->CTS_Offset;
/*add cache*/
gf_isom_add_sample(cache->mov, mch->track, 1, mch->cache_sample);
assert(!mch->prev_dts || (mch->prev_dts < mch->cache_sample->DTS));
mch->prev_dts = mch->cache_sample->DTS;
mch->duration = MAX(mch->max_cts, mch->prev_dts);
gf_isom_sample_del(&mch->cache_sample);
/*store sample*/
mch->cache_sample = gf_isom_sample_new();
mch->cache_sample->IsRAP = sl_hdr->randomAccessPointFlag;
mch->cache_sample->DTS = DTS + mch->frame_cts_offset;
mch->cache_sample->CTS_Offset = (u32) (sl_hdr->compositionTimeStamp - mch->cache_seed_ts - DTS);
mch->cache_sample->dataLength = data_size;
mch->cache_sample->data = (char*)gf_malloc(sizeof(char)*data_size);
memcpy(mch->cache_sample->data, data, sizeof(char)*data_size);
return GF_OK;
}
int main(int argc, char **argv)
{
GF_ISOFile *movie;
GF_ESD *esd;
GF_Err e;
Double gb_size = 5.0;
u8 store_mode;
u32 track, di, i, nb_samp;
GF_ISOSample *samp;
store_mode = GF_ISOM_OPEN_WRITE;
for (i=1; i<argc; i++) {
if (!strcmp(argv[i], "-flat")) store_mode = GF_ISOM_OPEN_WRITE;
else if (!strcmp(argv[i], "-inter")) store_mode = GF_ISOM_WRITE_EDIT;
else if (!strcmp(argv[i], "-size") && (i+1<argc)) {
gb_size = atof(argv[i+1]);
i++;
}
else if (!strcmp(argv[i], "-h")) {
PrintUsage();
return 0;
}
}
nb_samp = (u32) (gb_size*1024);
fprintf(stdout, "Creating test file %s - %g GBytes - %d samples - %s mode\n", TEST_FILE_NAME, gb_size, nb_samp, (store_mode == GF_ISOM_OPEN_WRITE) ? "Flat" : "Interleaved");
movie = gf_isom_open(TEST_FILE_NAME, store_mode, NULL);
if (!movie) {
fprintf(stdout, "Error creating file: %s\n", gf_error_to_string(gf_isom_last_error(NULL)));
return 1;
}
track = gf_isom_new_track(movie, 1, GF_ISOM_MEDIA_VISUAL, 25);
esd = gf_odf_desc_esd_new(2);
esd->decoderConfig->streamType = 4;
gf_isom_new_mpeg4_description(movie, track, esd, NULL, NULL, &di);
samp = gf_isom_sample_new();
samp->dataLength = 1024*1024;
samp->data = gf_malloc(sizeof(char)*samp->dataLength);
memset(samp->data, 0, sizeof(char)*samp->dataLength);
for (i=0; i<nb_samp; i++) {
if (samp->DTS % 25) samp->IsRAP = 0;
else samp->IsRAP = 1;
e = gf_isom_add_sample(movie, track, di, samp);
samp->DTS += 1;
fprintf(stdout, "Writing sample %d / %d \r", i+1, nb_samp);
if (e) break;
}
gf_isom_sample_del(&samp);
if (e) {
fprintf(stdout, "\nError writing sample %d\n", i);
gf_isom_delete(movie);
return 1;
}
fprintf(stdout, "\nDone writing samples\n");
e = gf_isom_close(movie);
if (e) {
fprintf(stdout, "Error writing file\n");
return 1;
}
return 0;
}
int dc_gpac_audio_moov_create(AudioOutputFile *audio_output_file, char *filename)
{
GF_Err ret;
u32 di, track;
u8 bpsample;
GF_ESD *esd;
#ifndef GPAC_DISABLE_AV_PARSERS
GF_M4ADecSpecInfo acfg;
#endif
AVCodecContext *audio_codec_ctx = audio_output_file->codec_ctx;
audio_output_file->isof = gf_isom_open(filename, GF_ISOM_OPEN_WRITE, NULL);
if (!audio_output_file->isof) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Cannot open iso file %s\n", filename));
return -1;
}
esd = gf_odf_desc_esd_new(2);
if (!esd) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Cannot create GF_ESD\n"));
return -1;
}
esd->decoderConfig = (GF_DecoderConfig *) gf_odf_desc_new(GF_ODF_DCD_TAG);
esd->slConfig = (GF_SLConfig *) gf_odf_desc_new(GF_ODF_SLC_TAG);
esd->decoderConfig->streamType = GF_STREAM_AUDIO;
if (!strcmp(audio_output_file->codec_ctx->codec->name, "aac")) { //TODO: find an automatic table
esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_AAC_MPEG4;
esd->decoderConfig->bufferSizeDB = 20;
esd->slConfig->timestampResolution = audio_codec_ctx->sample_rate;
esd->decoderConfig->decoderSpecificInfo = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
esd->ESID = 1;
#ifndef GPAC_DISABLE_AV_PARSERS
memset(&acfg, 0, sizeof(GF_M4ADecSpecInfo));
acfg.base_object_type = GF_M4A_AAC_LC;
acfg.base_sr = audio_codec_ctx->sample_rate;
acfg.nb_chan = audio_codec_ctx->channels;
acfg.sbr_object_type = 0;
acfg.audioPL = gf_m4a_get_profile(&acfg);
ret = gf_m4a_write_config(&acfg, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
assert(ret == GF_OK);
#endif
} else {
if (strcmp(audio_output_file->codec_ctx->codec->name, "mp2")) {
GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("Unlisted codec, setting GPAC_OTI_AUDIO_MPEG1 descriptor.\n"));
}
esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_MPEG1;
esd->decoderConfig->bufferSizeDB = 20;
esd->slConfig->timestampResolution = audio_codec_ctx->sample_rate;
esd->decoderConfig->decoderSpecificInfo = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
esd->ESID = 1;
#ifndef GPAC_DISABLE_AV_PARSERS
memset(&acfg, 0, sizeof(GF_M4ADecSpecInfo));
acfg.base_object_type = GF_M4A_LAYER2;
acfg.base_sr = audio_codec_ctx->sample_rate;
acfg.nb_chan = audio_codec_ctx->channels;
acfg.sbr_object_type = 0;
acfg.audioPL = gf_m4a_get_profile(&acfg);
ret = gf_m4a_write_config(&acfg, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
assert(ret == GF_OK);
#endif
}
//gf_isom_store_movie_config(video_output_file->isof, 0);
track = gf_isom_new_track(audio_output_file->isof, esd->ESID, GF_ISOM_MEDIA_AUDIO, audio_codec_ctx->sample_rate);
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("TimeScale: %d \n", audio_codec_ctx->time_base.den));
if (!track) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Cannot create new track\n"));
return -1;
}
ret = gf_isom_set_track_enabled(audio_output_file->isof, track, 1);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_set_track_enabled\n", gf_error_to_string(ret)));
return -1;
}
// if (!esd->ESID) esd->ESID = gf_isom_get_track_id(audio_output_file->isof, track);
ret = gf_isom_new_mpeg4_description(audio_output_file->isof, track, esd, NULL, NULL, &di);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_new_mpeg4_description\n", gf_error_to_string(ret)));
return -1;
}
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
bpsample = av_get_bytes_per_sample(audio_output_file->codec_ctx->sample_fmt) * 8;
ret = gf_isom_set_audio_info(audio_output_file->isof, track, di, audio_codec_ctx->sample_rate, audio_output_file->codec_ctx->channels, bpsample);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_set_audio_info\n", gf_error_to_string(ret)));
return -1;
}
#ifndef GPAC_DISABLE_AV_PARSERS
ret = gf_isom_set_pl_indication(audio_output_file->isof, GF_ISOM_PL_AUDIO, acfg.audioPL);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_set_pl_indication\n", gf_error_to_string(ret)));
return -1;
}
#endif
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("time scale: %d sample dur: %d \n", audio_codec_ctx->time_base.den, audio_output_file->codec_ctx->frame_size));
ret = gf_isom_setup_track_fragment(audio_output_file->isof, track, 1, audio_output_file->codec_ctx->frame_size, 0, 0, 0, 0);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_setup_track_fragment\n", gf_error_to_string(ret)));
return -1;
}
//gf_isom_add_track_to_root_od(video_output_file->isof,1);
ret = gf_isom_finalize_for_fragment(audio_output_file->isof, 1);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_finalize_for_fragment\n", gf_error_to_string(ret)));
return -1;
}
ret = gf_media_get_rfc_6381_codec_name(audio_output_file->isof, track, audio_output_file->audio_data_conf->codec6381, GF_FALSE, GF_FALSE);
if (ret != GF_OK) return -1;
return 0;
}
int dc_gpac_audio_moov_create(AudioOutputFile * p_aoutf, char * psz_name) {
GF_Err ret;
AVCodecContext * p_audio_codec_ctx = p_aoutf->p_codec_ctx;
u32 di;
u32 track;
GF_M4ADecSpecInfo acfg;
p_aoutf->p_isof = gf_isom_open(psz_name,
GF_ISOM_OPEN_WRITE, NULL);
if (!p_aoutf->p_isof) {
fprintf(stderr, "Cannot open iso file %s\n",
psz_name);
return -1;
}
memset(&acfg, 0, sizeof(GF_M4ADecSpecInfo));
acfg.base_object_type = GF_M4A_AAC_LC;
acfg.base_sr = p_audio_codec_ctx->sample_rate;
acfg.nb_chan = p_audio_codec_ctx->channels;
acfg.sbr_object_type = 0;
acfg.audioPL = gf_m4a_get_profile(&acfg);
GF_ESD * p_esd = gf_odf_desc_esd_new(2);
if (!p_esd) {
fprintf(stderr, "Cannot create GF_ESD\n");
return -1;
}
p_esd->decoderConfig = (GF_DecoderConfig *) gf_odf_desc_new(GF_ODF_DCD_TAG);
p_esd->slConfig = (GF_SLConfig *) gf_odf_desc_new(GF_ODF_SLC_TAG);
p_esd->decoderConfig->streamType = GF_STREAM_AUDIO;
p_esd->decoderConfig->objectTypeIndication = GPAC_OTI_AUDIO_AAC_MPEG4;
p_esd->decoderConfig->bufferSizeDB = 20;
p_esd->slConfig->timestampResolution = p_audio_codec_ctx->sample_rate;
p_esd->decoderConfig->decoderSpecificInfo = (GF_DefaultDescriptor *) gf_odf_desc_new(GF_ODF_DSI_TAG);
p_esd->ESID = 1;
ret = gf_m4a_write_config(&acfg, &p_esd->decoderConfig->decoderSpecificInfo->data, &p_esd->decoderConfig->decoderSpecificInfo->dataLength);
//gf_isom_store_movie_config(p_voutf->p_isof, 0);
track = gf_isom_new_track(p_aoutf->p_isof, p_esd->ESID,
GF_ISOM_MEDIA_AUDIO, p_audio_codec_ctx->sample_rate);
//printf("TimeScale: %d \n", p_video_codec_ctx->time_base.den);
if (!track) {
fprintf(stderr, "Cannot create new track\n");
return -1;
}
ret = gf_isom_set_track_enabled(p_aoutf->p_isof, track, 1);
if (ret != GF_OK) {
fprintf(stderr, "%s: gf_isom_set_track_enabled\n",
gf_error_to_string(ret));
return -1;
}
// if (!p_esd->ESID) p_esd->ESID = gf_isom_get_track_id(p_aoutf->p_isof, track);
ret = gf_isom_new_mpeg4_description(p_aoutf->p_isof, track, p_esd, NULL,
NULL, &di);
if (ret != GF_OK) {
fprintf(stderr, "%s: gf_isom_new_mpeg4_description\n",
gf_error_to_string(ret));
return -1;
}
gf_odf_desc_del((GF_Descriptor *) p_esd);
p_esd = NULL;
u8 bpsample = av_get_bytes_per_sample(p_aoutf->p_codec_ctx->sample_fmt) * 8;
ret = gf_isom_set_audio_info(p_aoutf->p_isof, track, di,
p_audio_codec_ctx->sample_rate, p_aoutf->p_codec_ctx->channels,
bpsample);
if (ret != GF_OK) {
fprintf(stderr, "%s: gf_isom_set_audio_info\n",
gf_error_to_string(ret));
return -1;
}
ret = gf_isom_set_pl_indication(p_aoutf->p_isof, GF_ISOM_PL_AUDIO, acfg.audioPL);
if (ret != GF_OK) {
fprintf(stderr, "%s: gf_isom_set_pl_indication\n",
gf_error_to_string(ret));
return -1;
}
//printf("time scale: %d sample dur: %d \n",
// p_video_codec_ctx->time_base.den, p_aoutf->p_codec_ctx->frame_size);
ret = gf_isom_setup_track_fragment(p_aoutf->p_isof, track, 1,
p_aoutf->p_codec_ctx->frame_size, 0, 0, 0, 0);
if (ret != GF_OK) {
fprintf(stderr, "%s: gf_isom_setup_track_fragment\n",
gf_error_to_string(ret));
return -1;
}
//gf_isom_add_track_to_root_od(p_voutf->p_isof,1);
ret = gf_isom_finalize_for_fragment(p_aoutf->p_isof, 1);
if (ret != GF_OK) {
fprintf(stderr, "%s: gf_isom_finalize_for_fragment\n",
gf_error_to_string(ret));
return -1;
}
return 0;
}
int dc_gpac_video_moov_create(VideoOutputFile *video_output_file, char *filename)
{
GF_Err ret;
AVCodecContext *video_codec_ctx = video_output_file->codec_ctx;
u32 di, track;
//TODO: For the moment it is fixed
//u32 sample_dur = video_output_file->codec_ctx->time_base.den;
//int64_t profile = 0;
//av_opt_get_int(video_output_file->codec_ctx->priv_data, "level", AV_OPT_SEARCH_CHILDREN, &profile);
video_output_file->isof = gf_isom_open(filename, GF_ISOM_OPEN_WRITE, NULL);
if (!video_output_file->isof) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Cannot open iso file %s\n", filename));
return -1;
}
//gf_isom_store_movie_config(video_output_file->isof, 0);
track = gf_isom_new_track(video_output_file->isof, 0, GF_ISOM_MEDIA_VISUAL, video_codec_ctx->time_base.den);
video_output_file->trackID = gf_isom_get_track_id(video_output_file->isof, track);
video_output_file->timescale = video_codec_ctx->time_base.den;
if (!video_output_file->frame_dur)
video_output_file->frame_dur = video_codec_ctx->time_base.num;
if (!track) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Cannot create new track\n"));
return -1;
}
ret = gf_isom_set_track_enabled(video_output_file->isof, track, 1);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_set_track_enabled\n", gf_error_to_string(ret)));
return -1;
}
ret = dc_gpac_video_write_config(video_output_file, &di, track);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: dc_gpac_video_write_config\n", gf_error_to_string(ret)));
return -1;
}
gf_isom_set_visual_info(video_output_file->isof, track, di, video_codec_ctx->width, video_codec_ctx->height);
gf_isom_set_sync_table(video_output_file->isof, track);
ret = gf_isom_setup_track_fragment(video_output_file->isof, track, 1, video_output_file->use_source_timing ? (u32) video_output_file->frame_dur : 1, 0, 0, 0, 0);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_setup_track_fragment\n", gf_error_to_string(ret)));
return -1;
}
//gf_isom_add_track_to_root_od(video_output_file->isof,1);
ret = gf_isom_finalize_for_fragment(video_output_file->isof, track);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_finalize_for_fragment\n", gf_error_to_string(ret)));
return -1;
}
ret = gf_media_get_rfc_6381_codec_name(video_output_file->isof, track, video_output_file->video_data_conf->codec6381);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_finalize_for_fragment\n", gf_error_to_string(ret)));
return -1;
}
return 0;
}