| /* | |
| * GPAC - Multimedia Framework C SDK | |
| * | |
| * Authors: Jean Le Feuvre | |
| * Copyright (c) Telecom ParisTech 2017-2026 | |
| * All rights reserved | |
| * | |
| * This file is part of GPAC / generic stream to file filter | |
| * | |
| * GPAC is free software; you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation; either version 2, or (at your option) | |
| * any later version. | |
| * | |
| * GPAC is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| * GNU Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; see the file COPYING. If not, write to | |
| * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | |
| * | |
| */ | |
| #include <gpac/filters.h> | |
| #include <gpac/constants.h> | |
| #include <gpac/bitstream.h> | |
| #include <gpac/xml.h> | |
| #include <gpac/base_coding.h> | |
| #ifndef GPAC_DISABLE_WRITEGEN | |
| #include <gpac/internal/isomedia_dev.h> | |
| GF_OPT_ENUM (GF_DecoderConfigInsertMode, | |
| DECINFO_NO=0, | |
| DECINFO_FIRST, | |
| DECINFO_SAP, | |
| DECINFO_AUTO, | |
| ); | |
| GF_OPT_ENUM (GF_VttHeaderInjectionMode, | |
| VTTH_SINGLE=0, | |
| VTTH_SEG, | |
| VTTH_ALL, | |
| ); | |
| typedef struct | |
| { | |
| //opts | |
| Bool exporter, frame, split, merge_region, add_nl, rawb; | |
| u32 sstart, send; | |
| GF_VttHeaderInjectionMode vtth; | |
| u32 pfmt, afmt; | |
| GF_DecoderConfigInsertMode decinfo; | |
| GF_Fraction dur; | |
| //only one input pid declared | |
| GF_FilterPid *ipid; | |
| //only one output pid declared | |
| GF_FilterPid *opid; | |
| u32 codecid; | |
| Bool is_mj2k; | |
| Bool is_iamf; | |
| u32 sample_num; | |
| const char *dcfg; | |
| u32 dcfg_size; | |
| Bool cfg_sent; | |
| GF_Fraction64 duration; | |
| Bool first; | |
| GF_BitStream *bs; | |
| u32 target_pfmt, target_afmt; | |
| Bool is_bmp; | |
| u32 is_y4m; | |
| u32 is_wav; | |
| u32 w, h, stride; | |
| u64 nb_bytes; | |
| Bool dash_mode; | |
| Bool trunc_audio; | |
| Bool webvtt; | |
| u64 first_dts_plus_one; | |
| Bool ttml_agg; | |
| GF_XMLNode *ttml_root; | |
| GF_FilterPacket *ttml_dash_pck; | |
| Bool dump_srt, srt_dump_forced; | |
| Bool need_ttxt_footer; | |
| u8 *write_buf; | |
| u32 write_alloc; | |
| Bool unframe_only; | |
| Bool vc1_ilaced; | |
| Bool ttml_merger; | |
| u64 ttml_cts_offset; // used to rewrite ttml timestamps over reconfigure (i.e. DASH period change) | |
| u64 ttml_first_cts; | |
| GF_FilterPacket *ttml_first_pck; | |
| } GF_GenDumpCtx; | |
| GF_Err writegen_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove) | |
| { | |
| u32 cid, chan, sr, w, h, stype, pf, sfmt, av1mode, nb_bps; | |
| const char *name, *mimetype, *out_ext=NULL; | |
| char szExt[GF_4CC_MSIZE], szCodecExt[30], *sep; | |
| const GF_PropertyValue *p; | |
| GF_GenDumpCtx *ctx = gf_filter_get_udta(filter); | |
| if (is_remove) { | |
| ctx->ipid = NULL; | |
| if (ctx->opid) { | |
| gf_filter_pid_remove(ctx->opid); | |
| ctx->opid = NULL; | |
| } | |
| return GF_OK; | |
| } | |
| if (! gf_filter_pid_check_caps(pid)) { | |
| p = ctx->frame ? gf_filter_pid_get_property(pid, GF_PROP_PID_UNFRAMED) : NULL; | |
| if (p && p->value.boolean) { | |
| GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("Option frame specified as inherited and writegen loaded dynamically, input data will be unframed ! Use `writegen:frame -o dst` for raw frame dump\n", szExt)); | |
| } else { | |
| return GF_NOT_SUPPORTED; | |
| } | |
| } | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID); | |
| if (!p) return GF_NOT_SUPPORTED; | |
| cid = p->value.uint; | |
| ctx->codecid = cid; | |
| ctx->is_iamf = GF_FALSE; | |
| if (!ctx->opid) { | |
| ctx->opid = gf_filter_pid_new(filter); | |
| if (!ctx->opid) | |
| return GF_OUT_OF_MEM; | |
| ctx->first = GF_TRUE; | |
| } | |
| ctx->ipid = pid; | |
| //copy properties at init or reconfig | |
| gf_filter_pid_copy_properties(ctx->opid, pid); | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DECODER_CONFIG, NULL); | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_STREAM_TYPE); | |
| stype = p ? p->value.uint : 0; | |
| if (stype!=GF_STREAM_TEXT) ctx->add_nl = GF_FALSE; | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_SAMPLE_RATE); | |
| sr = p ? p->value.uint : 0; | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_NUM_CHANNELS); | |
| chan = p ? p->value.uint : 0; | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_AUDIO_FORMAT); | |
| sfmt = p ? p->value.uint : GF_AUDIO_FMT_S16; | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_AUDIO_BPS); | |
| nb_bps = p ? p->value.uint : 0; | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_WIDTH); | |
| ctx->w = w = p ? p->value.uint : 0; | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_HEIGHT); | |
| ctx->h = h = p ? p->value.uint : 0; | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_PIXFMT); | |
| pf = p ? p->value.uint : 0; | |
| if (!pf) pf = GF_PIXEL_YUV; | |
| //get DSI except for unframed streams | |
| Bool get_dsi = GF_FALSE; | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_UNFRAMED); | |
| if (!p ) p = gf_filter_pid_get_property(pid, GF_PROP_PID_UNFRAMED_LATM); | |
| if (!p || !p->value.boolean) { | |
| get_dsi = GF_TRUE; | |
| } | |
| //we need this one for tx3g and webvtt | |
| if ((cid==GF_CODECID_TX3G) || (cid==GF_CODECID_WEBVTT)) | |
| get_dsi = GF_TRUE; | |
| if (get_dsi) { | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG); | |
| if (p) { | |
| ctx->dcfg = p->value.data.ptr; | |
| ctx->dcfg_size = p->value.data.size; | |
| } | |
| } | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_DASH_MODE); | |
| ctx->dash_mode = (p && p->value.uint) ? GF_TRUE : GF_FALSE; | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(GF_STREAM_FILE) ); | |
| //special case for xml text, override to xml | |
| switch (cid) { | |
| case GF_CODECID_META_XML: | |
| case GF_CODECID_SUBS_XML: | |
| gf_strcpy(szCodecExt, "xml"); | |
| break; | |
| default: | |
| gf_strcpy(szCodecExt, gf_codecid_file_ext(cid)); | |
| sep = strchr(szCodecExt, '|'); | |
| if (sep) sep[0] = 0; | |
| break; | |
| } | |
| ctx->dump_srt = GF_FALSE; | |
| p = gf_filter_pid_caps_query(ctx->opid, GF_PROP_PID_FILE_EXT); | |
| if (p && p->value.string) { | |
| out_ext = p->value.string; | |
| if (!strcmp(out_ext, "srt")) { | |
| ctx->dump_srt = GF_TRUE; | |
| gf_strcpy(szCodecExt, "srt"); | |
| } | |
| } | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING(szCodecExt) ); | |
| mimetype = gf_codecid_mime(cid); | |
| switch (cid) { | |
| case GF_CODECID_AAC_MPEG4: | |
| case GF_CODECID_AAC_MPEG2_MP: | |
| case GF_CODECID_AAC_MPEG2_LCP: | |
| case GF_CODECID_AAC_MPEG2_SSRP: | |
| //override extension to latm for aac if unframed latm data - NOT for usac | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_UNFRAMED_LATM); | |
| if (p && p->value.boolean) { | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING("latm") ); | |
| } | |
| break; | |
| case GF_CODECID_PNG: | |
| case GF_CODECID_JPEG: | |
| ctx->split = GF_TRUE; | |
| break; | |
| case GF_CODECID_J2K: | |
| ctx->split = GF_TRUE; | |
| ctx->is_mj2k = GF_TRUE; | |
| break; | |
| case GF_CODECID_IAMF: | |
| ctx->is_iamf = GF_TRUE; | |
| if (ctx->decinfo == DECINFO_AUTO) | |
| ctx->decinfo = DECINFO_FIRST; | |
| break; | |
| case GF_CODECID_AMR: | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) ); | |
| ctx->dcfg = "#!AMR\n"; | |
| ctx->dcfg_size = 6; | |
| ctx->decinfo = DECINFO_FIRST; | |
| break; | |
| case GF_CODECID_AMR_WB: | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) ); | |
| ctx->dcfg = "#!AMR-WB\n"; | |
| ctx->dcfg_size = 9; | |
| ctx->decinfo = DECINFO_FIRST; | |
| break; | |
| case GF_CODECID_SMV: | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) ); | |
| ctx->dcfg = "#!SMV\n"; | |
| ctx->dcfg_size = 6; | |
| ctx->decinfo = DECINFO_FIRST; | |
| break; | |
| case GF_CODECID_EVRC_PV: | |
| case GF_CODECID_EVRC: | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) ); | |
| ctx->dcfg = "#!EVRC\n"; | |
| ctx->dcfg_size = 7; | |
| ctx->decinfo = DECINFO_FIRST; | |
| break; | |
| case GF_CODECID_FLAC: | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) ); | |
| ctx->decinfo = DECINFO_FIRST; | |
| break; | |
| case GF_CODECID_SIMPLE_TEXT: | |
| if (!gf_filter_pid_get_property(pid, GF_PROP_PID_MIME)) | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) ); | |
| if (ctx->decinfo == DECINFO_AUTO) | |
| ctx->decinfo = DECINFO_FIRST; | |
| if (!out_ext || stricmp(out_ext, "txt")) { | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_UNFRAMED); | |
| if (p && p->value.boolean) | |
| ctx->dump_srt = GF_TRUE; | |
| } | |
| break; | |
| case GF_CODECID_TX3G: | |
| if (!gf_filter_pid_get_property(pid, GF_PROP_PID_MIME)) | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) ); | |
| if (ctx->decinfo == DECINFO_AUTO) | |
| ctx->decinfo = DECINFO_FIRST; | |
| break; | |
| case GF_CODECID_META_TEXT: | |
| if (!gf_filter_pid_get_property(pid, GF_PROP_PID_MIME)) | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) ); | |
| if (ctx->decinfo == DECINFO_AUTO) | |
| ctx->decinfo = DECINFO_FIRST; | |
| break; | |
| case GF_CODECID_META_XML: | |
| if (!gf_filter_pid_get_property(pid, GF_PROP_PID_MIME)) | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) ); | |
| if (ctx->decinfo == DECINFO_AUTO) | |
| ctx->decinfo = DECINFO_FIRST; | |
| break; | |
| case GF_CODECID_SUBS_TEXT: | |
| if (!gf_filter_pid_get_property(pid, GF_PROP_PID_MIME)) | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) ); | |
| if (ctx->decinfo == DECINFO_AUTO) | |
| ctx->decinfo = DECINFO_FIRST; | |
| break; | |
| case GF_CODECID_WEBVTT: | |
| if (!gf_filter_pid_get_property(pid, GF_PROP_PID_MIME)) | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) ); | |
| if (ctx->decinfo == DECINFO_AUTO) | |
| ctx->decinfo = DECINFO_FIRST; | |
| ctx->webvtt = GF_TRUE; | |
| break; | |
| case GF_CODECID_SUBS_XML: | |
| if (!gf_filter_pid_get_property(pid, GF_PROP_PID_MIME)) | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) ); | |
| if (ctx->dash_mode) { | |
| ctx->ttml_agg = GF_TRUE; | |
| } | |
| else if (!ctx->frame && !ctx->split) { | |
| ctx->ttml_agg = GF_TRUE; | |
| } else { | |
| ctx->split = GF_TRUE; | |
| } | |
| if (ctx->decinfo == DECINFO_AUTO) | |
| ctx->decinfo = DECINFO_FIRST; | |
| break; | |
| case GF_CODECID_SUBS_SSA: | |
| ctx->add_nl = GF_TRUE; | |
| break; | |
| case GF_CODECID_AV1: | |
| av1mode = 0; | |
| p = gf_filter_pid_get_property_str(ctx->ipid, "obu:mode"); | |
| if (p) av1mode = p->value.uint; | |
| if (av1mode==1) { | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING("av1b") ); | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("video/x-av1b") ); | |
| } else if (av1mode==2) { | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING("ivf") ); | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("video/x-ivf") ); | |
| } else { | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING("obu") ); | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("video/x-av1") ); | |
| } | |
| break; | |
| case GF_CODECID_RAW: | |
| ctx->dcfg = NULL; | |
| ctx->dcfg_size = 0; | |
| if (stype==GF_STREAM_VISUAL) { | |
| gf_strcpy(szExt, gf_pixel_fmt_sname(ctx->target_pfmt ? ctx->target_pfmt : pf)); | |
| p = gf_filter_pid_caps_query(ctx->opid, GF_PROP_PID_FILE_EXT); | |
| if (p) { | |
| gf_strcpy(szExt, p->value.string); | |
| if (!strcmp(szExt, "bmp")) { | |
| ctx->is_bmp = GF_TRUE; | |
| //request BGR | |
| ctx->target_pfmt = GF_PIXEL_BGR; | |
| ctx->split = GF_TRUE; | |
| } else if (!strcmp(szExt, "y4m")) { | |
| ctx->is_y4m = GF_TRUE; | |
| ctx->target_pfmt = GF_PIXEL_YUV; | |
| } else { | |
| ctx->target_pfmt = gf_pixel_fmt_parse(szExt); | |
| if (!ctx->target_pfmt) { | |
| GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("Cannot guess pixel format from extension type %s\n", szExt)); | |
| return GF_NOT_SUPPORTED; | |
| } | |
| gf_strcpy(szExt, gf_pixel_fmt_sname(ctx->target_pfmt)); | |
| } | |
| //forcing pixel format regardless of extension | |
| if (ctx->pfmt) { | |
| if (pf != ctx->pfmt) { | |
| gf_filter_pid_negotiate_property(ctx->ipid, GF_PROP_PID_PIXFMT, &PROP_UINT(ctx->pfmt)); | |
| //make sure we reconfigure | |
| ctx->codecid = 0; | |
| pf = ctx->pfmt; | |
| } | |
| } | |
| //use extension to derive pixel format | |
| else if (pf != ctx->target_pfmt) { | |
| gf_filter_pid_negotiate_property(ctx->ipid, GF_PROP_PID_PIXFMT, &PROP_UINT(ctx->target_pfmt)); | |
| gf_strcpy(szExt, gf_pixel_fmt_sname(ctx->target_pfmt)); | |
| //make sure we reconfigure | |
| ctx->codecid = 0; | |
| } | |
| } | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_STRIDE); | |
| ctx->stride = p ? p->value.uint : 0; | |
| if (!ctx->stride) { | |
| gf_pixel_get_size_info(ctx->target_pfmt ? ctx->target_pfmt : pf, ctx->w, ctx->h, NULL, &ctx->stride, NULL, NULL, NULL); | |
| } | |
| } else if (stype==GF_STREAM_AUDIO) { | |
| gf_strcpy(szExt, gf_audio_fmt_sname(ctx->target_afmt ? ctx->target_afmt : sfmt)); | |
| p = gf_filter_pid_caps_query(ctx->opid, GF_PROP_PID_FILE_EXT); | |
| if (p) { | |
| gf_strcpy(szExt, p->value.string); | |
| if (!strcmp(szExt, "wav")) { | |
| ctx->is_wav = GF_TRUE; | |
| //request PCMs16 ? | |
| switch (sfmt) { | |
| case GF_AUDIO_FMT_FLTP: | |
| ctx->target_afmt = GF_AUDIO_FMT_FLT; | |
| break; | |
| case GF_AUDIO_FMT_FLT: | |
| case GF_AUDIO_FMT_S16: | |
| case GF_AUDIO_FMT_S24: | |
| case GF_AUDIO_FMT_S32: | |
| ctx->target_afmt = sfmt; | |
| break; | |
| default: | |
| ctx->target_afmt = GF_AUDIO_FMT_S16; | |
| break; | |
| } | |
| } else { | |
| ctx->target_afmt = gf_audio_fmt_parse(szExt); | |
| gf_strcpy(szExt, gf_audio_fmt_sname(ctx->target_afmt)); | |
| } | |
| //forcing sample format regardless of extension | |
| if (ctx->afmt) { | |
| if (sfmt != ctx->afmt) { | |
| gf_filter_pid_negotiate_property(ctx->ipid, GF_PROP_PID_AUDIO_FORMAT, &PROP_UINT(ctx->afmt)); | |
| //make sure we reconfigure | |
| ctx->codecid = 0; | |
| sfmt = ctx->afmt; | |
| } | |
| } | |
| //use extension to derive sample format | |
| else if (sfmt != ctx->target_afmt) { | |
| gf_filter_pid_negotiate_property(ctx->ipid, GF_PROP_PID_AUDIO_FORMAT, &PROP_UINT(ctx->target_afmt)); | |
| gf_strcpy(szExt, gf_audio_fmt_sname(ctx->target_afmt)); | |
| //make sure we reconfigure | |
| ctx->codecid = 0; | |
| } | |
| if (ctx->dur.num && ctx->dur.den && !gf_audio_fmt_is_planar(ctx->target_afmt ? ctx->target_afmt : ctx->afmt)) | |
| ctx->trunc_audio = GF_TRUE; | |
| } | |
| } else { | |
| gf_strcpy(szExt, gf_4cc_to_str(cid)); | |
| } | |
| if (ctx->is_bmp) gf_strcpy(szExt, "bmp"); | |
| else if (ctx->is_y4m) gf_strcpy(szExt, "y4m"); | |
| else if (ctx->is_wav) { | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_DISABLE_PROGRESSIVE, &PROP_UINT(GF_PID_FILE_PATCH_REPLACE) ); | |
| gf_strcpy(szExt, "wav"); | |
| } else if (!strlen(szExt)) gf_strcpy(szExt, "raw"); | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING( szExt ) ); | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING("application/octet-string") ); | |
| if (!ctx->codecid) return GF_OK; | |
| break; | |
| default: | |
| if (!strcmp(szCodecExt, "raw")) { | |
| gf_strcpy(szExt, gf_4cc_to_str(cid)); | |
| if (!strlen(szExt)) gf_strcpy(szExt, "raw"); | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING( szExt ) ); | |
| } else { | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_FILE_EXT, &PROP_STRING( szCodecExt ) ); | |
| } | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_MIME, &PROP_STRING(mimetype) ); | |
| break; | |
| } | |
| if (ctx->decinfo == DECINFO_AUTO) | |
| ctx->decinfo = DECINFO_NO; | |
| name = gf_codecid_name(cid); | |
| if (ctx->exporter) { | |
| if (w && h) { | |
| if (cid==GF_CODECID_RAW) name = gf_pixel_fmt_name(pf); | |
| GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("Exporting %s - Size %dx%d\n", name, w, h)); | |
| } else if (sr && chan) { | |
| if (cid==GF_CODECID_RAW) { | |
| GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("Exporting PCM %s SampleRate %d %d channels %d bits per sample\n", gf_audio_fmt_name(sfmt), sr, chan, gf_audio_fmt_bit_depth(sfmt) )); | |
| } else { | |
| if (!nb_bps) | |
| nb_bps = gf_audio_fmt_bit_depth(sfmt); | |
| GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("Exporting %s - SampleRate %d %d channels %d bits per sample\n", name, sr, chan, nb_bps )); | |
| } | |
| } else { | |
| GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("Exporting %s\n", name)); | |
| } | |
| } | |
| //avoid creating a file when dumping individual samples | |
| if (ctx->split) { | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_NB_FRAMES); | |
| if (p && (p->value.uint<=1)) | |
| ctx->split = GF_FALSE; | |
| } | |
| p = gf_filter_pid_get_property(pid, GF_PROP_PID_DURATION); | |
| if (p && (p->value.lfrac.num>0)) ctx->duration = p->value.lfrac; | |
| if (ctx->unframe_only) { | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_UNFRAMED, &PROP_BOOL(GF_TRUE)); | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_STREAM_TYPE, &PROP_UINT(stype)); | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_CODECID, &PROP_UINT(cid)); | |
| } | |
| if (ctx->ttml_merger) { | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_NB_FRAMES, NULL); | |
| gf_filter_pid_set_property(ctx->opid, GF_PROP_PID_UNFRAMED, NULL); | |
| ctx->ttml_cts_offset = GF_FILTER_NO_TS; | |
| } | |
| if (ctx->dump_srt && gf_opts_get_bool("core", "srt-forced")) | |
| ctx->srt_dump_forced = GF_TRUE; | |
| else | |
| ctx->srt_dump_forced = GF_FALSE; | |
| gf_filter_pid_set_framing_mode(pid, GF_TRUE); | |
| return GF_OK; | |
| } | |
| static GF_FilterPacket *writegen_write_j2k(GF_GenDumpCtx *ctx, char *data, u32 data_size, GF_FilterPacket *in_pck) | |
| { | |
| u32 size; | |
| u8 *output; | |
| GF_FilterPacket *dst_pck; | |
| char sig[8]; | |
| sig[0] = sig[1] = sig[2] = 0; | |
| sig[3] = 0xC; | |
| sig[4] = 'j'; | |
| sig[5] = 'P'; | |
| sig[6] = sig[7] = ' '; | |
| if ((data_size>16) && !memcmp(data, sig, 8)) { | |
| return gf_filter_pck_new_ref(ctx->opid, 0, 0, in_pck); | |
| } | |
| size = data_size + 8*4 /*jP%20%20 + ftyp*/ + ctx->dcfg_size + 8; | |
| dst_pck = gf_filter_pck_new_alloc(ctx->opid, size, &output); | |
| if (!dst_pck) return NULL; | |
| if (!ctx->bs) ctx->bs = gf_bs_new(output, size, GF_BITSTREAM_WRITE); | |
| else gf_bs_reassign_buffer(ctx->bs, output, size); | |
| gf_bs_write_u32(ctx->bs, 12); | |
| gf_bs_write_u32(ctx->bs, GF_ISOM_BOX_TYPE_JP); | |
| gf_bs_write_u32(ctx->bs, 0x0D0A870A); | |
| gf_bs_write_u32(ctx->bs, 20); | |
| gf_bs_write_u32(ctx->bs, GF_ISOM_BOX_TYPE_FTYP); | |
| gf_bs_write_u32(ctx->bs, GF_ISOM_BRAND_JP2); | |
| gf_bs_write_u32(ctx->bs, 0); | |
| gf_bs_write_u32(ctx->bs, GF_ISOM_BRAND_JP2); | |
| //todo, write colr and other info ? | |
| if (ctx->dcfg) { | |
| gf_bs_write_u32(ctx->bs, 8+ctx->dcfg_size); | |
| gf_bs_write_u32(ctx->bs, GF_ISOM_BOX_TYPE_JP2H); | |
| gf_bs_write_data(ctx->bs, ctx->dcfg, ctx->dcfg_size); | |
| } | |
| gf_bs_write_data(ctx->bs, data, data_size); | |
| return dst_pck; | |
| } | |
| #ifdef WIN32 | |
| #include <windows.h> | |
| #else | |
| typedef struct tagBITMAPFILEHEADER | |
| { | |
| u16 bfType; | |
| u32 bfSize; | |
| u16 bfReserved1; | |
| u16 bfReserved2; | |
| u32 bfOffBits; | |
| } BITMAPFILEHEADER; | |
| typedef struct tagBITMAPINFOHEADER { | |
| u32 biSize; | |
| s32 biWidth; | |
| s32 biHeight; | |
| u16 biPlanes; | |
| u16 biBitCount; | |
| u32 biCompression; | |
| u32 biSizeImage; | |
| s32 biXPelsPerMeter; | |
| s32 biYPelsPerMeter; | |
| u32 biClrUsed; | |
| u32 biClrImportant; | |
| } BITMAPINFOHEADER; | |
| #define BI_RGB 0L | |
| #endif | |
| static GF_FilterPacket *writegen_write_bmp(GF_GenDumpCtx *ctx, char *data, u32 data_size) | |
| { | |
| u32 size; | |
| u8 *output; | |
| BITMAPFILEHEADER fh; | |
| BITMAPINFOHEADER fi; | |
| GF_FilterPacket *dst_pck; | |
| u32 i; | |
| size = ctx->w*ctx->h*3 + 54; //14 + 40 = size of BMP file header and BMP file info; | |
| dst_pck = gf_filter_pck_new_alloc(ctx->opid, size, &output); | |
| if (!dst_pck) return NULL; | |
| memset(&fh, 0, sizeof(fh)); | |
| fh.bfType = 19778; | |
| fh.bfOffBits = 54; | |
| if (!ctx->bs) ctx->bs = gf_bs_new(output, size, GF_BITSTREAM_WRITE); | |
| else gf_bs_reassign_buffer(ctx->bs, output, size); | |
| gf_bs_write_data(ctx->bs, (const char *) &fh.bfType, 2); | |
| gf_bs_write_data(ctx->bs, (const char *) &fh.bfSize, 4); | |
| gf_bs_write_data(ctx->bs, (const char *) &fh.bfReserved1, 2); | |
| gf_bs_write_data(ctx->bs, (const char *) &fh.bfReserved2, 2); | |
| gf_bs_write_data(ctx->bs, (const char *) &fh.bfOffBits, 4); | |
| memset(&fi, 0, sizeof(char)*40); | |
| fi.biSize = 40; | |
| fi.biWidth = ctx->w; | |
| fi.biHeight = ctx->h; | |
| fi.biPlanes = 1; | |
| fi.biBitCount = 24; | |
| fi.biCompression = BI_RGB; | |
| fi.biSizeImage = ctx->w * ctx->h * 3; | |
| memcpy(output+14, &fi, sizeof(char)*40); | |
| //reverse lines | |
| output += sizeof(u8) * 54; | |
| for (i=ctx->h; i>0; i--) { | |
| u8 *ptr = data + (i-1)*ctx->stride; | |
| memcpy(output, ptr, sizeof(u8)*3*ctx->w); | |
| output += 3*ctx->w; | |
| } | |
| return dst_pck; | |
| } | |
| static void writegen_write_wav_header(GF_GenDumpCtx *ctx) | |
| { | |
| u32 size; | |
| u8 *output; | |
| GF_FilterPacket *dst_pck; | |
| const GF_PropertyValue *p; | |
| u32 nb_ch, sample_rate, afmt, bps; | |
| const char chunkID[] = {'R', 'I', 'F', 'F'}; | |
| const char format[] = {'W', 'A', 'V', 'E'}; | |
| const char subchunk1ID[] = {'f', 'm', 't', ' '}; | |
| const char subchunk2ID[] = {'d', 'a', 't', 'a'}; | |
| if (ctx->is_wav!=1) return; | |
| ctx->is_wav = 2; | |
| p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_SAMPLE_RATE); | |
| if (!p) return; | |
| sample_rate = p->value.uint; | |
| p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_NUM_CHANNELS); | |
| if (!p) return; | |
| nb_ch = p->value.uint; | |
| p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_AUDIO_FORMAT); | |
| if (!p) return; | |
| afmt = p->value.uint; | |
| bps = gf_audio_fmt_bit_depth(afmt); | |
| size = 44; | |
| dst_pck = gf_filter_pck_new_alloc(ctx->opid, size, &output); | |
| if (!dst_pck) return; | |
| if (!ctx->bs) ctx->bs = gf_bs_new(output, size, GF_BITSTREAM_WRITE); | |
| else gf_bs_reassign_buffer(ctx->bs, output, size); | |
| gf_bs_write_data(ctx->bs, chunkID, 4); | |
| gf_bs_write_u32_le(ctx->bs, (u32) ctx->nb_bytes + 36); | |
| gf_bs_write_data(ctx->bs, format, 4); | |
| gf_bs_write_data(ctx->bs, subchunk1ID, 4); | |
| gf_bs_write_u32_le(ctx->bs, 16); //subchunk1 size | |
| //audio format | |
| if (afmt==GF_AUDIO_FMT_FLT) | |
| gf_bs_write_u16_le(ctx->bs, 3); | |
| else | |
| gf_bs_write_u16_le(ctx->bs, 1); | |
| gf_bs_write_u16_le(ctx->bs, nb_ch); | |
| gf_bs_write_u32_le(ctx->bs, sample_rate); | |
| gf_bs_write_u32_le(ctx->bs, sample_rate * nb_ch * bps / 8); //byte rate | |
| gf_bs_write_u16_le(ctx->bs, nb_ch * bps / 8); // block align | |
| gf_bs_write_u16_le(ctx->bs, bps); | |
| gf_bs_write_data(ctx->bs, subchunk2ID, 4); | |
| gf_bs_write_u32_le(ctx->bs, (u32) ctx->nb_bytes); | |
| gf_filter_pck_set_framing(dst_pck, GF_FALSE, GF_FALSE); | |
| gf_filter_pck_set_byte_offset(dst_pck, 0); | |
| gf_filter_pck_set_seek_flag(dst_pck, GF_TRUE); | |
| gf_filter_pck_send(dst_pck); | |
| } | |
| GF_XMLAttribute *ttml_get_attr(GF_XMLNode *node, char *name) | |
| { | |
| u32 i=0; | |
| GF_XMLAttribute *att; | |
| while (node && (att = gf_list_enum(node->attributes, &i)) ) { | |
| if (!strcmp(att->name, name)) return att; | |
| } | |
| return NULL; | |
| } | |
| static GF_XMLNode *ttml_locate_div(GF_XMLNode *body, const char *region_name, u32 div_idx) | |
| { | |
| u32 i=0, loc_div_idx=0; | |
| GF_XMLNode *div; | |
| while ( (div = gf_list_enum(body->content, &i)) ) { | |
| if (div->type) continue; | |
| if (strcmp(div->name, "div")) continue; | |
| if (!region_name) { | |
| if (div_idx==loc_div_idx) return div; | |
| loc_div_idx++; | |
| } else { | |
| GF_XMLAttribute *att = ttml_get_attr(div, "region"); | |
| if (att && att->value && !strcmp(att->value, region_name)) | |
| return div; | |
| } | |
| } | |
| if (region_name) { | |
| return ttml_locate_div(body, NULL, div_idx); | |
| } | |
| return NULL; | |
| } | |
| static GF_XMLNode *ttml_get_head(GF_XMLNode *root) | |
| { | |
| u32 i=0; | |
| GF_XMLNode *child; | |
| while (root && (child = gf_list_enum(root->content, &i)) ) { | |
| if (child->type) continue; | |
| if (!strcmp(child->name, "head")) return child; | |
| } | |
| return NULL; | |
| } | |
| GF_XMLNode *ttml_get_body(GF_XMLNode *root) | |
| { | |
| u32 i=0; | |
| GF_XMLNode *child; | |
| while (root && (child = gf_list_enum(root->content, &i)) ) { | |
| if (child->type) continue; | |
| if (!strcmp(child->name, "body")) return child; | |
| } | |
| return NULL; | |
| } | |
| static Bool ttml_same_attr(GF_XMLNode *n1, GF_XMLNode *n2) | |
| { | |
| u32 i=0; | |
| GF_XMLAttribute *att1; | |
| while ( (att1 = gf_list_enum(n1->attributes, &i))) { | |
| Bool found = GF_FALSE; | |
| u32 j=0; | |
| GF_XMLAttribute *att2; | |
| while ( (att2 = gf_list_enum(n2->attributes, &j))) { | |
| if (!strcmp(att1->name, att2->name)) { | |
| if (!strcmp(att1->value, att2->value)) { | |
| found = GF_TRUE; | |
| break; | |
| } | |
| } | |
| } | |
| if (!found) return GF_FALSE; | |
| } | |
| return GF_TRUE; | |
| } | |
| static void ttml_merge_head(GF_XMLNode *node_src, GF_XMLNode *node_dst) | |
| { | |
| u32 i=0; | |
| GF_XMLNode *child_src; | |
| while ( (child_src = gf_list_enum(node_src->content, &i)) ) { | |
| Bool found = GF_FALSE; | |
| u32 j=0; | |
| GF_XMLNode *child_dst; | |
| while ( (child_dst = gf_list_enum(node_dst->content, &j)) ) { | |
| if (!strcmp(child_src->name, child_dst->name) && ttml_same_attr(child_dst, child_src)) { | |
| found = GF_TRUE; | |
| break; | |
| } | |
| } | |
| if (found) { | |
| ttml_merge_head(child_src, child_dst); | |
| continue; | |
| } | |
| i--; | |
| gf_list_rem(node_src->content, i); | |
| if (!node_dst->content) node_dst->content = gf_list_new(); | |
| gf_list_add(node_dst->content, child_src); | |
| } | |
| return; | |
| } | |
| static GF_Err ttml_embed_data(GF_XMLNode *node, u8 *aux_data, u32 aux_data_size, u8 *subs_data, u32 subs_data_size) | |
| { | |
| u32 i=0; | |
| GF_XMLNode *child; | |
| u32 subs_idx=0; | |
| GF_XMLAttribute *att; | |
| Bool is_source = GF_FALSE; | |
| Bool has_src_att = GF_FALSE; | |
| if (!node || node->type) return GF_BAD_PARAM; | |
| if (!strcmp(node->name, "source")) { | |
| is_source = GF_TRUE; | |
| } | |
| while ((att = gf_list_enum(node->attributes, &i))) { | |
| char *sep, *fext; | |
| if (strcmp(att->name, "src")) continue; | |
| has_src_att = GF_TRUE; | |
| if (strncmp(att->value, "urn:", 4)) continue; | |
| sep = strrchr(att->value, ':'); | |
| if (!sep) continue; | |
| sep++; | |
| fext = gf_file_ext_start(sep); | |
| if (fext) fext[0] = 0; | |
| subs_idx = atoi(sep); | |
| if (fext) fext[0] = '.'; | |
| if (!subs_idx || ((subs_idx-1) * 14 > subs_data_size)) { | |
| subs_idx = 0; | |
| continue; | |
| } | |
| break; | |
| } | |
| if (subs_idx) { | |
| GF_XMLNode *data; | |
| u32 subs_offset = 0; | |
| u32 subs_size = 0; | |
| u32 idx = 1; | |
| //fetch subsample info | |
| for (i=0; i<subs_data_size; i+=14) { | |
| u32 a_subs_size = subs_data[i+4]; | |
| a_subs_size <<= 8; | |
| a_subs_size |= subs_data[i+5]; | |
| a_subs_size <<= 8; | |
| a_subs_size |= subs_data[i+6]; | |
| a_subs_size <<= 8; | |
| a_subs_size |= subs_data[i+7]; | |
| if (idx==subs_idx) { | |
| subs_size = a_subs_size; | |
| break; | |
| } | |
| subs_offset += a_subs_size; | |
| idx++; | |
| } | |
| if (!subs_size || (subs_offset + subs_size > aux_data_size)) { | |
| if (!subs_size) { | |
| GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("No subsample with index %u in sample\n", subs_idx)); | |
| } else { | |
| GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("Corrupted subsample %u info, size %u offset %u but sample size %u\n", subs_idx, subs_size, subs_offset, aux_data_size)); | |
| } | |
| return GF_NON_COMPLIANT_BITSTREAM; | |
| } | |
| //remove src attribute | |
| gf_list_del_item(node->attributes, att); | |
| if (att->name) gf_free(att->name); | |
| if (att->value) gf_free(att->value); | |
| gf_free(att); | |
| //create a source node | |
| if (!is_source) { | |
| GF_XMLNode *s; | |
| GF_SAFEALLOC(s, GF_XMLNode); | |
| if (!s) return GF_OUT_OF_MEM; | |
| s->attributes = gf_list_new(); | |
| s->content = gf_list_new(); | |
| s->name = gf_strdup("source"); | |
| if (!node->content) node->content = gf_list_new(); | |
| gf_list_add(node->content, s); | |
| if (!s->name || !s->content || !s->attributes) return GF_OUT_OF_MEM; | |
| //move @type to source | |
| att = ttml_get_attr(node, "type"); | |
| if (att) { | |
| gf_list_del_item(node->attributes, att); | |
| gf_list_add(s->attributes, att); | |
| } | |
| node = s; | |
| } | |
| //create a data node | |
| GF_SAFEALLOC(data, GF_XMLNode); | |
| if (!data) return GF_OUT_OF_MEM; | |
| data->attributes = gf_list_new(); | |
| data->content = gf_list_new(); | |
| data->name = gf_strdup("data"); | |
| if (!node->content) node->content = gf_list_new(); | |
| gf_list_add(node->content, data); | |
| if (!data->name || !data->content || !data->attributes) return GF_OUT_OF_MEM; | |
| //move @type to data | |
| att = ttml_get_attr(node, "type"); | |
| if (att) { | |
| gf_list_del_item(node->attributes, att); | |
| gf_list_add(data->attributes, att); | |
| } | |
| //base64 encode in a child | |
| GF_SAFEALLOC(node, GF_XMLNode) | |
| if (!node) return GF_OUT_OF_MEM; | |
| node->type = GF_XML_TEXT_TYPE; | |
| u32 size_64 = (subs_size * 2) + 3; | |
| node->name = gf_malloc(sizeof(char) * size_64); | |
| if (!node->name) { | |
| gf_free(node); | |
| return GF_OUT_OF_MEM; | |
| } | |
| subs_size = gf_base64_encode(aux_data + subs_offset, subs_size, (u8*) node->name, size_64); | |
| node->name[subs_size] = 0; | |
| return gf_list_add(data->content, node); | |
| } | |
| //src was present but not an embedded data, do not recurse | |
| if (has_src_att) return GF_OK; | |
| i=0; | |
| while ((child = gf_list_enum(node->content, &i))) { | |
| if (child->type) continue; | |
| ttml_embed_data(child, aux_data, aux_data_size, subs_data, subs_data_size); | |
| } | |
| return GF_OK; | |
| } | |
| //from filter txtin | |
| u64 ttml_get_timestamp_ex(char *value, u32 tick_rate, u32 *ttml_fps_num, u32 *ttml_fps_den, u32 *ttml_sfps); | |
| static u64 ttml_get_timestamp(char *value) | |
| { | |
| u32 ttml_fps_num, ttml_fps_den, ttml_sfps; | |
| return ttml_get_timestamp_ex(value, 25, &ttml_fps_num, &ttml_fps_den, &ttml_sfps); | |
| } | |
| // modifications in this function should be mirrored in load_text.c-ttml_rewrite_timestamp() | |
| static void writegen_rewrite_timestamp_ttml(s64 ts_offset, GF_XMLAttribute *att, s64 *value) | |
| { | |
| u64 v; | |
| char szTS[21]; | |
| u32 h, m, s, ms; | |
| *value = ttml_get_timestamp(att->value); | |
| if (!ts_offset) | |
| return; | |
| *value += ts_offset; | |
| v = (u64) (*value / 1000); | |
| h = (u32) (v / 3600); | |
| m = (u32) (v - h*3600) / 60; | |
| s = (u32) (v - h*3600 - m*60); | |
| ms = (*value) % 1000; | |
| snprintf(szTS, 20, "%02u:%02u:%02u.%03u", h, m, s, ms); | |
| szTS[20] = 0; | |
| gf_free(att->value); | |
| att->value = gf_strdup(szTS); | |
| return; | |
| } | |
| static void ttml_rewrite_timestamp(u64 offset, GF_List *p_attributes) | |
| { | |
| u32 p_idx = 0; | |
| GF_XMLAttribute *p_att; | |
| while ( (p_att = (GF_XMLAttribute*)gf_list_enum(p_attributes, &p_idx))) { | |
| if (!strcmp(p_att->name, "begin")) { | |
| s64 unused = 0; | |
| writegen_rewrite_timestamp_ttml(offset, p_att, &unused); | |
| } | |
| if (!strcmp(p_att->name, "end")) { | |
| s64 unused = 0; | |
| writegen_rewrite_timestamp_ttml(offset, p_att, &unused); | |
| } | |
| } | |
| } | |
| static GF_Err writegen_push_ttml(GF_GenDumpCtx *ctx, char *data, u32 data_size, GF_FilterPacket *in_pck) | |
| { | |
| const GF_PropertyValue *subs = gf_filter_pck_get_property(in_pck, GF_PROP_PCK_SUBS); | |
| char *ttml_text = NULL; | |
| GF_Err e = GF_OK; | |
| u32 ttml_text_size; | |
| GF_DOMParser *dom; | |
| u32 txt_size, nb_children; | |
| u32 i, k, div_idx; | |
| GF_XMLNode *root_pck, *root_global, *p_global, *p_pck, *body_pck, *body_global, *head_pck, *head_global; | |
| if (subs) { | |
| if (subs->value.data.size < 14) | |
| return GF_NON_COMPLIANT_BITSTREAM; | |
| txt_size = subs->value.data.ptr[4]; | |
| txt_size <<= 8; | |
| txt_size |= subs->value.data.ptr[5]; | |
| txt_size <<= 8; | |
| txt_size |= subs->value.data.ptr[6]; | |
| txt_size <<= 8; | |
| txt_size |= subs->value.data.ptr[7]; | |
| if (txt_size>data_size) | |
| return GF_NON_COMPLIANT_BITSTREAM; | |
| } else { | |
| txt_size = data_size; | |
| } | |
| ttml_text_size = txt_size + 2; | |
| ttml_text = gf_malloc(sizeof(char) * ttml_text_size); | |
| if (!ttml_text) return GF_OUT_OF_MEM; | |
| memcpy(ttml_text, data, txt_size); | |
| ttml_text[txt_size] = 0; | |
| ttml_text[txt_size+1] = 0; | |
| dom = gf_xml_dom_new(); | |
| if (!dom) return GF_OUT_OF_MEM; | |
| e = gf_xml_dom_parse_string(dom, ttml_text); | |
| if (e) { | |
| GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("[XML] Invalid TTML doc: %s\n\tXML text was:\n%s", gf_xml_dom_get_error(dom), ttml_text)); | |
| goto exit; | |
| } | |
| root_pck = gf_xml_dom_get_root(dom); | |
| //subsamples, replace all data embedded as subsample with base64 encoding | |
| if (subs && root_pck) { | |
| e = ttml_embed_data(root_pck, data+txt_size, data_size-txt_size, subs->value.data.ptr+14, subs->value.data.size-14); | |
| if (e) goto exit; | |
| } | |
| //if previous root is empty, reset - we do this in 2 passes so that single-sample emty ttml can be dumped | |
| if (ctx->ttml_root && (gf_list_count(ctx->ttml_root->content)==0)) { | |
| gf_xml_dom_node_del(ctx->ttml_root); | |
| ctx->ttml_root = NULL; | |
| } | |
| if (!ctx->ttml_root) { | |
| ctx->ttml_root = gf_xml_dom_detach_root(dom); | |
| // walk through the document to find <p> to rewrite timestamps | |
| body_pck = ttml_get_body(root_pck); | |
| if (body_pck) { | |
| div_idx = 0; | |
| nb_children = body_pck ? gf_list_count(body_pck->content) : 0; | |
| for (k=0; k<nb_children; k++) { | |
| GF_XMLNode *div_pck; | |
| div_pck = gf_list_get(body_pck->content, k); | |
| if (div_pck) { | |
| u32 j=0; | |
| while ( (p_pck = gf_list_enum(div_pck->content, &j)) ) { | |
| if (p_pck->type) continue; | |
| if (strcmp(p_pck->name, "p")) continue; | |
| ttml_rewrite_timestamp(ctx->ttml_cts_offset, p_pck->attributes); | |
| } | |
| } | |
| } | |
| } | |
| goto exit; | |
| } | |
| root_global = ctx->ttml_root; | |
| head_global = ttml_get_head(root_global); | |
| head_pck = ttml_get_head(root_pck); | |
| if (head_pck) { | |
| if (!head_global) { | |
| gf_list_del_item(root_pck->content, head_pck); | |
| if (!root_global->content) root_global->content = gf_list_new(); | |
| gf_list_add(root_global->content, head_pck); | |
| } else { | |
| ttml_merge_head(head_pck, head_global); | |
| } | |
| } | |
| body_pck = ttml_get_body(root_pck); | |
| body_global = ttml_get_body(root_global); | |
| if (body_pck && !body_global) { | |
| gf_list_del_item(root_pck->content, body_pck); | |
| if (!root_global->content) root_global->content = gf_list_new(); | |
| gf_list_add(root_global->content, body_pck); | |
| goto exit; | |
| } | |
| div_idx = 0; | |
| nb_children = body_pck ? gf_list_count(body_pck->content) : 0; | |
| for (k=0; k<nb_children; k++) { | |
| GF_XMLAttribute *div_reg = NULL; | |
| GF_XMLNode *div_global, *div_pck; | |
| div_pck = gf_list_get(body_pck->content, k); | |
| if (!div_pck || div_pck->type) continue; | |
| if (strcmp(div_pck->name, "div")) continue; | |
| if (ctx->merge_region) | |
| div_reg = ttml_get_attr(div_pck, "region"); | |
| //merge input doc | |
| div_global = ttml_locate_div(body_global, div_reg ? div_reg->value : NULL, div_idx); | |
| if (!div_global) { | |
| gf_list_rem(body_pck->content, k); | |
| if (!body_global->content) body_global->content = gf_list_new(); | |
| gf_list_insert(body_global->content, div_pck, div_idx+1); | |
| div_idx++; | |
| continue; | |
| } | |
| div_idx++; | |
| i=0; | |
| while ( (p_pck = gf_list_enum(div_pck->content, &i)) ) { | |
| s32 idx; | |
| GF_XMLNode *txt; | |
| u32 j=0; | |
| Bool found = GF_FALSE; | |
| if (p_pck->type) continue; | |
| if (strcmp(p_pck->name, "p")) continue; | |
| while ( (p_global = gf_list_enum(div_global->content, &j)) ) { | |
| if (p_global->type) continue; | |
| if (strcmp(p_global->name, "p")) continue; | |
| if (ttml_same_attr(p_pck, p_global)) { | |
| found = GF_TRUE; | |
| break; | |
| } | |
| } | |
| if (found) continue; | |
| //insert this p - if last entry in global div is text, insert before | |
| txt = gf_list_last(div_global->content); | |
| if (txt && txt->type) { | |
| idx = gf_list_count(div_global->content) - 1; | |
| } else { | |
| idx = gf_list_count(div_global->content); | |
| } | |
| // rewrite the appended timestamp | |
| ttml_rewrite_timestamp(ctx->ttml_cts_offset, p_pck->attributes); | |
| i--; | |
| gf_list_rem(div_pck->content, i); | |
| if (!div_global->content) div_global->content = gf_list_new(); | |
| if (i) { | |
| txt = gf_list_get(div_pck->content, i-1); | |
| if (txt->type) { | |
| i--; | |
| gf_list_rem(div_pck->content, i); | |
| gf_list_insert(div_global->content, txt, idx); | |
| idx++; | |
| } | |
| } | |
| gf_list_insert(div_global->content, p_pck, idx); | |
| } | |
| } | |
| exit: | |
| if (ttml_text) gf_free(ttml_text); | |
| gf_xml_dom_del(dom); | |
| return e; | |
| } | |
| static GF_Err writegen_flush_ttml(GF_GenDumpCtx *ctx) | |
| { | |
| char *data; | |
| u8 *output; | |
| u32 size; | |
| GF_FilterPacket *pck; | |
| if (!ctx->ttml_root) return GF_OK; | |
| if (ctx->merge_region) { | |
| u32 i, count; | |
| GF_XMLNode *body_global = ttml_get_body(ctx->ttml_root); | |
| count = body_global ? gf_list_count(body_global->content) : 0; | |
| for (i=0; i<count; i++) { | |
| GF_XMLNode *child; | |
| GF_XMLNode *div = gf_list_get(body_global->content, i); | |
| if (div->type) continue; | |
| if (strcmp(div->name, "div")) continue; | |
| if (gf_list_count(div->content) > 1) continue; | |
| child = gf_list_get(div->content, 0); | |
| if (child && !child->type) continue; | |
| gf_list_rem(body_global->content, i); | |
| i--; | |
| count--; | |
| gf_xml_dom_node_del(div); | |
| } | |
| } | |
| data = gf_xml_dom_serialize_root(ctx->ttml_root, GF_FALSE, GF_FALSE); | |
| if (!data) return GF_OK; | |
| size = (u32) strlen(data); | |
| pck = gf_filter_pck_new_alloc(ctx->opid, size, &output); | |
| if (!pck) return GF_OUT_OF_MEM; | |
| memcpy(output, data, size); | |
| gf_free(data); | |
| if (ctx->ttml_dash_pck) { | |
| gf_filter_pck_merge_properties(ctx->ttml_dash_pck, pck); | |
| gf_filter_pck_set_byte_offset(pck, GF_FILTER_NO_BO); | |
| gf_filter_pck_set_dependency_flags(pck, 0); | |
| gf_filter_pck_unref(ctx->ttml_dash_pck); | |
| ctx->ttml_dash_pck = NULL; | |
| } | |
| gf_xml_dom_node_del(ctx->ttml_root); | |
| ctx->ttml_root = NULL; | |
| if (ctx->ttml_first_pck) { | |
| gf_filter_pck_merge_properties(ctx->ttml_first_pck, pck); | |
| gf_filter_pck_set_sap(pck, GF_FILTER_SAP_1); | |
| gf_filter_pck_set_dts(pck, ctx->ttml_first_cts); | |
| gf_filter_pck_set_cts(pck, ctx->ttml_first_cts); | |
| u64 last_cts = gf_filter_pck_get_cts(ctx->ttml_first_pck); | |
| last_cts += gf_filter_pck_get_duration(ctx->ttml_first_pck); | |
| gf_filter_pck_set_duration(pck, (u32) (last_cts - ctx->ttml_first_cts)); | |
| gf_filter_pck_unref(ctx->ttml_first_pck); | |
| ctx->ttml_first_pck = NULL; | |
| ctx->ttml_first_cts = 0; | |
| } | |
| gf_filter_pck_set_framing(pck, GF_TRUE, GF_TRUE); | |
| return gf_filter_pck_send(pck); | |
| } | |
| static GF_Err writegen_flush_ttxt(GF_GenDumpCtx *ctx) | |
| { | |
| const char *footer = "</TextStream>"; | |
| if (!ctx->need_ttxt_footer) return GF_OK; | |
| u32 size = (u32) strlen(footer); | |
| u8 *output; | |
| GF_FilterPacket *pck = gf_filter_pck_new_alloc(ctx->opid, size, &output); | |
| memcpy(output, footer, size); | |
| gf_filter_pck_set_framing(pck, GF_FALSE, GF_TRUE); | |
| gf_filter_pck_set_byte_offset(pck, GF_FILTER_NO_BO); | |
| ctx->need_ttxt_footer = GF_FALSE; | |
| return gf_filter_pck_send(pck); | |
| } | |
| #include <gpac/webvtt.h> | |
| static void webvtt_timestamps_dump(GF_BitStream *bs, u64 start_ts, u64 end_ts, u32 timescale, Bool write_srt, Bool forced) | |
| { | |
| #ifndef GPAC_DISABLE_VTT | |
| char szTS[200]; | |
| szTS[0] = 0; | |
| GF_WebVTTTimestamp start, end; | |
| gf_webvtt_timestamp_set(&start, gf_timestamp_rescale(start_ts, timescale, 1000) ); | |
| gf_webvtt_timestamp_set(&end, gf_timestamp_rescale(end_ts, timescale, 1000) ); | |
| Bool write_hour = GF_FALSE; | |
| if (gf_opts_get_bool("core", "webvtt-hours")) write_hour = GF_TRUE; | |
| else if (start.hour || end.hour) write_hour = GF_TRUE; | |
| else if (write_srt) write_hour = GF_TRUE; | |
| if (write_hour) { | |
| sprintf(szTS, "%02u:", start.hour); | |
| gf_bs_write_data(bs, szTS, (u32) strlen(szTS) ); | |
| } | |
| sprintf(szTS, "%02u:%02u%c%03u", start.min, start.sec, write_srt ? ',' : '.', start.ms); | |
| gf_bs_write_data(bs, szTS, (u32) strlen(szTS) ); | |
| sprintf(szTS, " --> "); | |
| gf_bs_write_data(bs, szTS, (u32) strlen(szTS) ); | |
| if (write_hour) { | |
| sprintf(szTS, "%02u:", end.hour); | |
| gf_bs_write_data(bs, szTS, (u32) strlen(szTS) ); | |
| } | |
| sprintf(szTS, "%02u:%02u%c%03u", end.min, end.sec, write_srt ? ',' : '.', end.ms); | |
| gf_bs_write_data(bs, szTS, (u32) strlen(szTS) ); | |
| if (write_srt && forced) { | |
| gf_bs_write_data(bs, " !!!", 4); | |
| } | |
| #endif | |
| } | |
| GF_Err writegen_process(GF_Filter *filter) | |
| { | |
| GF_GenDumpCtx *ctx = gf_filter_get_udta(filter); | |
| GF_FilterPacket *pck, *dst_pck = NULL; | |
| char *data; | |
| u32 pck_size; | |
| Bool seg_start = GF_FALSE; | |
| Bool do_abort = GF_FALSE; | |
| Bool split = ctx->split; | |
| if (!ctx->ipid) return GF_EOS; | |
| pck = gf_filter_pid_get_packet(ctx->ipid); | |
| if (!pck || !ctx->codecid) { | |
| if (gf_filter_pid_is_eos(ctx->ipid)) { | |
| if (ctx->is_wav) writegen_write_wav_header(ctx); | |
| else if (ctx->ttml_agg) writegen_flush_ttml(ctx); | |
| else if (ctx->codecid==GF_CODECID_TX3G) { | |
| writegen_flush_ttxt(ctx); | |
| } | |
| gf_filter_pid_set_eos(ctx->opid); | |
| return GF_EOS; | |
| } | |
| return GF_OK; | |
| } | |
| ctx->sample_num++; | |
| if (ctx->dash_mode) { | |
| Bool is_eods=GF_FALSE; | |
| //eods | |
| if (gf_filter_pck_get_property(pck, GF_PROP_PCK_EODS)) { | |
| is_eods=1; | |
| } | |
| //flush if first of segment or if eods | |
| if (ctx->ttml_agg && (gf_filter_pck_get_property(pck, GF_PROP_PCK_FILENUM) || is_eods)) { | |
| if (ctx->ttml_dash_pck) { | |
| writegen_flush_ttml(ctx); | |
| if (ctx->ttml_dash_pck) { | |
| gf_filter_pck_unref(ctx->ttml_dash_pck); | |
| ctx->ttml_dash_pck = NULL; | |
| } | |
| } | |
| //remember first pck of segment | |
| if (!is_eods) { | |
| ctx->ttml_dash_pck = pck; | |
| gf_filter_pck_ref_props(&ctx->ttml_dash_pck); | |
| } | |
| } | |
| //forward eods as is | |
| if (is_eods) { | |
| gf_filter_pck_forward(pck, ctx->opid); | |
| ctx->sample_num--; | |
| gf_filter_pid_drop_packet(ctx->ipid); | |
| return GF_OK; | |
| } | |
| const GF_PropertyValue *p = gf_filter_pck_get_property(pck, GF_PROP_PCK_FILENUM); | |
| if (p) seg_start = GF_TRUE; | |
| } | |
| if (ctx->sstart) { | |
| if (ctx->sstart > ctx->sample_num) { | |
| gf_filter_pid_drop_packet(ctx->ipid); | |
| return GF_OK; | |
| } | |
| if ((ctx->sstart <= ctx->send) && (ctx->sample_num>ctx->send) ) { | |
| do_abort = GF_TRUE; | |
| } | |
| } else if (ctx->dur.num && ctx->dur.den) { | |
| u64 dts = gf_filter_pck_get_dts(pck); | |
| if (dts==GF_FILTER_NO_TS) | |
| dts = gf_filter_pck_get_cts(pck); | |
| if (!ctx->first_dts_plus_one) { | |
| ctx->first_dts_plus_one = dts+1; | |
| } else { | |
| if (gf_timestamp_greater(dts + 1 - ctx->first_dts_plus_one, gf_filter_pck_get_timescale(pck), ctx->dur.num, ctx->dur.den)) { | |
| do_abort = GF_TRUE; | |
| } | |
| } | |
| } | |
| if (do_abort) { | |
| GF_FilterEvent evt; | |
| gf_filter_pid_drop_packet(ctx->ipid); | |
| GF_FEVT_INIT(evt, GF_FEVT_STOP, ctx->ipid); | |
| gf_filter_pid_send_event(ctx->ipid, &evt); | |
| return GF_OK; | |
| } | |
| //except in dash mode, force a new file if GF_PROP_PCK_FILENUM is set | |
| if (!ctx->dash_mode && (gf_filter_pck_get_property(pck, GF_PROP_PCK_FILENUM) != NULL)) { | |
| ctx->cfg_sent = GF_FALSE; | |
| ctx->first = GF_TRUE; | |
| } | |
| if (ctx->frame) { | |
| split = GF_TRUE; | |
| } else if (ctx->dcfg_size && (gf_filter_pck_get_sap(pck) || ctx->is_iamf) && !ctx->is_mj2k && !ctx->webvtt && (ctx->decinfo!=DECINFO_NO) && !ctx->cfg_sent) { | |
| if (ctx->codecid==GF_CODECID_FLAC) { | |
| u8 *dsi_out; | |
| dst_pck = gf_filter_pck_new_alloc(ctx->opid, ctx->dcfg_size+4, &dsi_out); | |
| if (!dst_pck) return GF_OUT_OF_MEM; | |
| dsi_out[0] = 'f'; | |
| dsi_out[1] = 'L'; | |
| dsi_out[2] = 'a'; | |
| dsi_out[3] = 'C'; | |
| memcpy(dsi_out+4, ctx->dcfg, ctx->dcfg_size); | |
| } else if (ctx->is_iamf) { | |
| GF_IAConfig *iacb = gf_odf_iamf_cfg_read((u8 *)ctx->dcfg, ctx->dcfg_size); | |
| if (iacb) { | |
| GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE); | |
| gf_odf_iamf_cfg_write_obus(iacb, bs); | |
| u8 *obus_data = NULL; | |
| u32 obus_size = 0; | |
| gf_bs_get_content(bs, &obus_data, &obus_size); | |
| gf_bs_del(bs); | |
| gf_odf_iamf_cfg_del(iacb); | |
| if (obus_data && obus_size) { | |
| u8 *pck_data; | |
| dst_pck = gf_filter_pck_new_alloc(ctx->opid, obus_size, &pck_data); | |
| if (!dst_pck) { | |
| gf_free(obus_data); | |
| return GF_OUT_OF_MEM; | |
| } | |
| memcpy(pck_data, obus_data, obus_size); | |
| gf_free(obus_data); | |
| } | |
| } | |
| if (!dst_pck) { | |
| dst_pck = gf_filter_pck_new_shared(ctx->opid, ctx->dcfg, ctx->dcfg_size, NULL); | |
| if (!dst_pck) return GF_OUT_OF_MEM; | |
| gf_filter_pck_set_readonly(dst_pck); | |
| } | |
| } else { | |
| dst_pck = gf_filter_pck_new_shared(ctx->opid, ctx->dcfg, ctx->dcfg_size, NULL); | |
| if (!dst_pck) return GF_OUT_OF_MEM; | |
| gf_filter_pck_set_readonly(dst_pck); | |
| } | |
| gf_filter_pck_merge_properties(pck, dst_pck); | |
| if (!ctx->unframe_only) | |
| gf_filter_pck_set_framing(dst_pck, ctx->first, GF_FALSE); | |
| if (ctx->first) { | |
| gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_FILENUM, &PROP_UINT(ctx->sample_num) ); | |
| ctx->sample_num--; | |
| } | |
| ctx->first = GF_FALSE; | |
| gf_filter_pck_send(dst_pck); | |
| if ((ctx->decinfo==DECINFO_FIRST) && !ctx->split) { | |
| ctx->dcfg_size = 0; | |
| ctx->dcfg = NULL; | |
| } | |
| ctx->cfg_sent = GF_TRUE; | |
| if (ctx->codecid==GF_CODECID_TX3G) | |
| ctx->need_ttxt_footer = GF_TRUE; | |
| return GF_OK; | |
| } | |
| ctx->cfg_sent = GF_FALSE; | |
| data = (char *) gf_filter_pck_get_data(pck, &pck_size); | |
| if (ctx->is_mj2k) { | |
| dst_pck = writegen_write_j2k(ctx, data, pck_size, pck); | |
| } else if (ctx->is_bmp) { | |
| dst_pck = writegen_write_bmp(ctx, data, pck_size); | |
| } else if (ctx->is_y4m) { | |
| char *y4m_hdr = NULL; | |
| if (ctx->is_y4m==1) { | |
| char szInfo[100]; | |
| const GF_PropertyValue *p; | |
| gf_dynstrcat(&y4m_hdr, "YUV4MPEG2", NULL); | |
| sprintf(szInfo, " W%d", ctx->w); | |
| gf_dynstrcat(&y4m_hdr, szInfo, NULL); | |
| sprintf(szInfo, " H%d", ctx->h); | |
| gf_dynstrcat(&y4m_hdr, szInfo, NULL); | |
| p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_FPS); | |
| if (p) { | |
| sprintf(szInfo, " F%d:%d", p->value.frac.num, p->value.frac.den); | |
| gf_dynstrcat(&y4m_hdr, szInfo, NULL); | |
| } | |
| p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_SAR); | |
| if (p && (p->value.frac.num>0)) { | |
| sprintf(szInfo, " A%d:%d", p->value.frac.num, p->value.frac.den); | |
| gf_dynstrcat(&y4m_hdr, szInfo, NULL); | |
| } | |
| u32 ilce = gf_filter_pck_get_interlaced(pck); | |
| sprintf(szInfo, " I%c", (ilce==0) ? 'p' : ((ilce==1) ? 't' : 'b')); | |
| gf_dynstrcat(&y4m_hdr, szInfo, NULL); | |
| switch (ctx->target_pfmt) { | |
| case GF_PIXEL_YUV: gf_dynstrcat(&y4m_hdr, " C420mpeg2", NULL); break; | |
| case GF_PIXEL_YUV444: gf_dynstrcat(&y4m_hdr, " C444", NULL); break; | |
| case GF_PIXEL_YUV422: gf_dynstrcat(&y4m_hdr, " C422", NULL); break; | |
| case GF_PIXEL_GREYSCALE: gf_dynstrcat(&y4m_hdr, " Cmono", NULL); break; | |
| case GF_PIXEL_YUVA444: gf_dynstrcat(&y4m_hdr, " C444alpha", NULL); break; | |
| } | |
| p = gf_filter_pid_get_property_str(ctx->ipid, "yuv4meg_meta"); | |
| if (p) { | |
| gf_dynstrcat(&y4m_hdr, p->value.string, " X"); | |
| } | |
| gf_dynstrcat(&y4m_hdr, "\n", NULL); | |
| ctx->is_y4m=2; | |
| } | |
| if (ctx->is_y4m==2) { | |
| gf_dynstrcat(&y4m_hdr, "FRAME\n", NULL); | |
| } | |
| u8 * output; | |
| u32 len = y4m_hdr ? (u32) strlen(y4m_hdr) : 0; | |
| dst_pck = gf_filter_pck_new_alloc(ctx->opid, pck_size + len, &output); | |
| if (!dst_pck) return GF_OUT_OF_MEM; | |
| if (y4m_hdr) memcpy(output, y4m_hdr, len); | |
| memcpy(output+len, data, pck_size); | |
| if (ctx->split) | |
| ctx->is_y4m=1; | |
| if (y4m_hdr) | |
| gf_free(y4m_hdr); | |
| } else if (ctx->is_wav && ctx->first) { | |
| u8 * output; | |
| dst_pck = gf_filter_pck_new_alloc(ctx->opid, 44, &output); | |
| if (!dst_pck) return GF_OUT_OF_MEM; | |
| gf_filter_pck_merge_properties(pck, dst_pck); | |
| gf_filter_pck_set_byte_offset(dst_pck, GF_FILTER_NO_BO); | |
| gf_filter_pck_set_framing(dst_pck, GF_TRUE, GF_FALSE); | |
| gf_filter_pck_set_corrupted(dst_pck, GF_TRUE); | |
| ctx->first = GF_FALSE; | |
| gf_filter_pck_send(dst_pck); | |
| ctx->nb_bytes += 44; | |
| return GF_OK; | |
| } else if (ctx->ttml_agg) { | |
| ctx->first = GF_FALSE; | |
| if (ctx->ttml_merger) { | |
| if (!ctx->ttml_first_pck) { | |
| ctx->ttml_first_cts = gf_filter_pck_get_cts(pck); | |
| ctx->ttml_first_pck = pck; | |
| gf_filter_pck_ref_props(&ctx->ttml_first_pck); | |
| // initialized once per reconfigure | |
| if (ctx->ttml_cts_offset == GF_FILTER_NO_TS) | |
| ctx->ttml_cts_offset = ctx->ttml_first_cts; | |
| } else { | |
| gf_filter_pck_merge_properties(pck, ctx->ttml_first_pck); | |
| } | |
| } | |
| GF_Err e = writegen_push_ttml(ctx, data, pck_size, pck); | |
| if (e) { | |
| gf_filter_pid_drop_packet(ctx->ipid); | |
| return e; | |
| } | |
| goto no_output; | |
| } else if (ctx->trunc_audio) { | |
| u64 dts = gf_filter_pck_get_dts(pck); | |
| if (dts==GF_FILTER_NO_TS) | |
| dts = gf_filter_pck_get_cts(pck); | |
| if (!ctx->first_dts_plus_one) { | |
| ctx->first_dts_plus_one = dts+1; | |
| } else { | |
| u32 timescale = gf_filter_pck_get_timescale(pck); | |
| u32 dur = gf_filter_pck_get_duration(pck); | |
| if (gf_timestamp_greater(dts + dur + 1 - ctx->first_dts_plus_one, timescale, ctx->dur.num, ctx->dur.den)) { | |
| u32 bpp; | |
| u8 *odata; | |
| const GF_PropertyValue *p; | |
| dur = ctx->dur.num * timescale / ctx->dur.den; | |
| dur -= (u32) (dts + 1 - ctx->first_dts_plus_one); | |
| bpp = gf_audio_fmt_bit_depth(ctx->target_afmt); | |
| p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_NUM_CHANNELS); | |
| if (p) bpp *= p->value.uint; | |
| bpp/= 8; | |
| p = gf_filter_pid_get_property(ctx->ipid, GF_PROP_PID_SAMPLE_RATE); | |
| if (p && (p->value.uint != timescale)) { | |
| dur *= p->value.uint; | |
| dur /= timescale; | |
| } | |
| gf_assert(pck_size >= bpp * dur); | |
| pck_size = bpp * dur; | |
| dst_pck = gf_filter_pck_new_alloc(ctx->opid, pck_size, &odata); | |
| if (dst_pck) | |
| memcpy(odata, data, pck_size); | |
| } | |
| } | |
| if (!dst_pck) { | |
| dst_pck = gf_filter_pck_new_ref(ctx->opid, 0, 0, pck); | |
| } | |
| } else if (ctx->webvtt || ctx->dump_srt) { | |
| Bool empty_seg = GF_FALSE; | |
| const GF_PropertyValue *p; | |
| if (!data || !pck_size) { | |
| if (ctx->dash_mode) { | |
| //do not forward empty packet if seg_start, we will need a WEBVTT header | |
| if (!seg_start && ((ctx->vtth<VTTH_ALL) || gf_filter_pck_get_property(pck, GF_PROP_PCK_EODS))) { | |
| gf_filter_pck_forward(pck, ctx->opid); | |
| goto no_output; | |
| } | |
| empty_seg=GF_TRUE; | |
| } else if (ctx->webvtt) { | |
| empty_seg=GF_TRUE; | |
| } else { | |
| ctx->sample_num--; | |
| goto no_output; | |
| } | |
| } | |
| u64 start = gf_filter_pck_get_cts(pck); | |
| u64 end = start + gf_filter_pck_get_duration(pck); | |
| u32 timescale = gf_filter_pck_get_timescale(pck); | |
| Bool first = ctx->first; | |
| Bool forced = GF_FALSE; | |
| //in dash mode always inject the webvtt header for HLS | |
| if (ctx->dash_mode && (ctx->vtth!=VTTH_SINGLE) && gf_filter_pck_get_property(pck, GF_PROP_PCK_FILENUM)) | |
| first = GF_TRUE; | |
| if (!ctx->bs) ctx->bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE); | |
| else gf_bs_reassign_buffer(ctx->bs, ctx->write_buf, ctx->write_alloc); | |
| if (first && !ctx->dump_srt) { | |
| if (ctx->dcfg && ctx->dcfg_size) { | |
| u32 len = ctx->dcfg_size; | |
| if (ctx->dcfg[len-1]==0) len--; | |
| gf_bs_write_data(ctx->bs, ctx->dcfg, len); | |
| if (ctx->dcfg[len-1]!='\n') | |
| gf_bs_write_data(ctx->bs, "\n", 1); | |
| gf_bs_write_data(ctx->bs, "\n", 1); | |
| } else | |
| gf_bs_write_data(ctx->bs, "WEBVTT\n\n", 8); | |
| } | |
| p = gf_filter_pck_get_property_str(pck, "vtt_pre"); | |
| if (!ctx->dump_srt && p && p->value.string) { | |
| u32 len = (u32) strlen(p->value.string); | |
| gf_bs_write_data(ctx->bs, p->value.string, len); | |
| if (len && (p->value.string[len-1]!='\n')) | |
| gf_bs_write_data(ctx->bs, "\n", 1); | |
| gf_bs_write_data(ctx->bs, "\n", 1); | |
| } | |
| p = gf_filter_pck_get_property_str(pck, "vtt_cueid"); | |
| if (!ctx->dump_srt && p && p->value.string) { | |
| u32 len = (u32) strlen(p->value.string) ; | |
| gf_bs_write_data(ctx->bs, p->value.string, len); | |
| if (len && (p->value.string[len-1]!='\n')) | |
| gf_bs_write_data(ctx->bs, "\n", 1); | |
| } | |
| if (ctx->srt_dump_forced) { | |
| p = gf_filter_pck_get_property(pck, GF_PROP_PCK_FORCED_SUB); | |
| if (p && p->value.boolean) { | |
| forced = GF_TRUE; | |
| } | |
| } | |
| if (!empty_seg) { | |
| if (ctx->dump_srt) { | |
| char szCID[100]; | |
| sprintf(szCID, "%d\n", ctx->sample_num); | |
| gf_bs_write_data(ctx->bs, szCID, (u32) strlen(szCID)); | |
| } | |
| webvtt_timestamps_dump(ctx->bs, start, end, timescale, ctx->dump_srt, forced); | |
| p = gf_filter_pck_get_property_str(pck, "vtt_settings"); | |
| if (!ctx->dump_srt && p && p->value.string) { | |
| gf_bs_write_data(ctx->bs, " ", 1); | |
| gf_bs_write_data(ctx->bs, p->value.string, (u32) strlen(p->value.string)); | |
| } | |
| gf_bs_write_data(ctx->bs, "\n", 1); | |
| if (data) { | |
| gf_bs_write_data(ctx->bs, data, pck_size); | |
| if (pck_size && (data[pck_size-1] != '\n')) | |
| gf_bs_write_data(ctx->bs, "\n", 1); | |
| } | |
| gf_bs_write_data(ctx->bs, "\n", 1); | |
| } | |
| u8 *odata; | |
| u32 vtt_data_size, alloc_size; | |
| gf_bs_get_content_no_truncate(ctx->bs, &ctx->write_buf, &vtt_data_size, &alloc_size); | |
| if (alloc_size>ctx->write_alloc) ctx->write_alloc = alloc_size; | |
| dst_pck = gf_filter_pck_new_alloc(ctx->opid, vtt_data_size, &odata); | |
| memcpy(odata, ctx->write_buf, vtt_data_size); | |
| } else { | |
| dst_pck = gf_filter_pck_new_ref(ctx->opid, 0, 0, pck); | |
| } | |
| if (!dst_pck) return GF_OUT_OF_MEM; | |
| gf_filter_pck_merge_properties(pck, dst_pck); | |
| //don't keep byte offset | |
| gf_filter_pck_set_byte_offset(dst_pck, GF_FILTER_NO_BO); | |
| if (split) { | |
| if (ctx->first) | |
| gf_filter_pck_set_property(dst_pck, GF_PROP_PCK_FILENUM, &PROP_UINT(ctx->sample_num) ); | |
| gf_filter_pck_set_framing(dst_pck, ctx->first, ctx->need_ttxt_footer ? GF_FALSE : GF_TRUE); | |
| ctx->first = GF_TRUE; | |
| } else { | |
| if (!ctx->unframe_only) | |
| gf_filter_pck_set_framing(dst_pck, ctx->first, GF_FALSE); | |
| ctx->first = GF_FALSE; | |
| } | |
| gf_filter_pck_set_seek_flag(dst_pck, 0); | |
| gf_filter_pck_send(dst_pck); | |
| if (ctx->add_nl) { | |
| u8 *output; | |
| dst_pck = gf_filter_pck_new_alloc(ctx->opid, 1, &output); | |
| output[0] = '\n'; | |
| gf_filter_pck_set_framing(dst_pck, GF_FALSE, GF_FALSE); | |
| gf_filter_pck_send(dst_pck); | |
| } | |
| if (split && ctx->need_ttxt_footer) | |
| writegen_flush_ttxt(ctx); | |
| ctx->nb_bytes += pck_size; | |
| no_output: | |
| if (ctx->exporter) { | |
| u32 timescale = gf_filter_pck_get_timescale(pck); | |
| u64 ts = gf_filter_pck_get_dts(pck); | |
| if (ts==GF_FILTER_NO_TS) | |
| ts = gf_filter_pck_get_cts(pck); | |
| if (ts!=GF_FILTER_NO_TS) { | |
| ts += gf_filter_pck_get_duration(pck); | |
| ts = gf_timestamp_rescale(ts, timescale, ctx->duration.den); | |
| gf_set_progress("Exporting", ts, ctx->duration.num); | |
| } | |
| } | |
| gf_filter_pid_drop_packet(ctx->ipid); | |
| return GF_OK; | |
| } | |
| /* | |
| We list capabilities per codec type, associating the codec type to the file extension. This allows, | |
| when matching to an output filter accepting a given file extension to match the codec type in write_gen caps, and | |
| setup the right filter chain | |
| */ | |
| static GF_FilterCapability GenDumpCaps[] = | |
| { | |
| //raw color dump YUV and RGB - keep it as first for field extension assignment | |
| //cf below | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_RAW), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "gpac"), | |
| {0}, | |
| //raw audio dump - keep it as second for field extension assignment | |
| //cf below | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_RAW), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "gpac" ), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_RAW), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "bmp"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "image/bmp"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_RAW), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "wav"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/wav|audio/wave"), | |
| {0}, | |
| //we accept unframed AVC (annex B format) | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AVC), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AVC_PS), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SVC), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MVC), | |
| CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "264|h264|avc|svc|mvc|26l|h26l"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/avc|video/h264|video/svc|video/mvc"), | |
| {0}, | |
| //we accept unframed HEVC (annex B format) | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_HEVC), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_LHVC), | |
| CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "265|h265|hvc|hevc|shvc|mhvc|lhvc"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/hevc|video/lhvc|video/shvc|video/mhvc"), | |
| {0}, | |
| //we accept unframed OBU (without size field) | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AV1), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_VP8), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_VP9), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_VP10), | |
| CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "obu|av1|av1b|ivf"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/x-ivf|video/av1"), | |
| {0}, | |
| //we accept unframed AC4 without sync word and size | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AC4), | |
| CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "ac4"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/x-ac4|audio/ac4"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPEG4_PART2), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "cmp|m4v"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/mp4v-es"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_H263), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_S263), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "h263|263|s263"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/h263"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPEG1), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "m1v"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/mpgv-es"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPEG2_422), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPEG2_SNR), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPEG2_HIGH), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPEG2_MAIN), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPEG2_SIMPLE), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPEG2_SPATIAL), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "m2v"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/mpgv-es"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AP4H), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AP4X), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_APCH), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_APCO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_APCS), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_APCN), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "prores"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/prores"), | |
| {0}, | |
| //we accept unframed AAC + ADTS | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG4), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG2_MP), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG2_LCP), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG2_SSRP), | |
| CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_BOOL(GF_CAPS_INPUT_EXCLUDED,GF_PROP_PID_UNFRAMED_LATM, GF_TRUE), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "aac|adts"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/x-m4a|audio/aac|audio/aacp|audio/x-aac"), | |
| {0}, | |
| //we accept unframed AAC + LATM | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG4), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG2_MP), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG2_LCP), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG2_SSRP), | |
| CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED_LATM, GF_TRUE), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "latm"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/aac+latm"), | |
| {0}, | |
| //we accept unframed USAC + LATM | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_USAC), | |
| CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED_LATM, GF_TRUE), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "usac|xheaac|latm"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/xheaac+latm"), | |
| {0}, | |
| //we accept IAMF | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_IAMF), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "iamf"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/iamf"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_PNG), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "png"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "image/png"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_JPEG), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "jpg|jpeg"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "image/jpg"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_J2K), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "jp2|j2k"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "image/jp2"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPEG_AUDIO), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "mp3"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/mp3|audio/x-mp3"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPEG2_PART3), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "mp2"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/mpeg|audio/x-mp2"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPEG_AUDIO_L1), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "mp1"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/mpeg|audio/x-mp1"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AMR), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AMR_WB), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "amr|awb"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/amr"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SMV), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "smv"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/smv"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_EVRC_PV), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_EVRC), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "evc"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/evrc"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_AC3), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "ac3"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/x-ac3|audio/ac3"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_EAC3), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "eac3"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/x-eac3|audio/eac3"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SIMPLE_TEXT), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_META_TEXT), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SUBS_TEXT), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "txt"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "x-subtitle/srt|subtitle/srt|text/srt"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_META_XML), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SUBS_XML), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "xml|txml|ttml"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "subtitle/ttml|text/ttml|application/xml+ttml"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_WEBVTT), | |
| CAP_BOOL(GF_CAPS_INPUT, GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "vtt"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "subtitle/vtt|text/vtt"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SIMPLE_TEXT), | |
| CAP_BOOL(GF_CAPS_INPUT, GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "srt"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "subtitle/srt|text/srt"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TX3G), | |
| CAP_BOOL(GF_CAPS_INPUT, GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "ttxt"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "x-subtitle/ttxt|subtitle/ttxt|text/ttxt"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SUBS_SSA), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "ssa|ass"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "x-subtitle/ssa"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_QCELP), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "qcelp"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/x-qcelp"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_THEORA), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "theo"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/x-theora"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_VORBIS), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "vorb"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/x-vorbis"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SPEEX), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "spx"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/x-speex"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_FLAC), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "flac"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/flac"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MPHA), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_MHAS), | |
| CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "mhas"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/mpegh"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_SMPTE_VC1), | |
| CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "vc1"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/vc1"), | |
| {0}, | |
| //we accept unframed VVC (annex B format) | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_VVC), | |
| CAP_BOOL(GF_CAPS_INPUT,GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "266|h266|vvc|lvvc"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/vvc|video/lvvc"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_TRUEHD), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "mlp|thd|truehd"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/truehd"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_FFV1), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "ffv1"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/x-ffv1"), | |
| {0}, | |
| //raw color dump YUV and RGB - keep it as first for field extension assignment | |
| //cf below | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_RAW), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "y4m"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "video/x-yuv4mpeg"), | |
| {0}, | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_DTS_CA), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_DTS_HD_HR_MASTER), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_DTS_HD_LOSSLESS), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_DTS_EXPRESS_LBR), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_DTS_X), | |
| CAP_UINT(GF_CAPS_INPUT,GF_PROP_PID_CODECID, GF_CODECID_DTS_Y), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "dts"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "audio/dts"), | |
| {0}, | |
| //anything else: only for explicit dump (filter loaded on purpose), otherwise don't load for filter link resolution | |
| CAP_UINT(GF_CAPS_OUTPUT_LOADED_FILTER, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_FILE_EXT, "*"), | |
| CAP_STRING(GF_CAPS_OUTPUT, GF_PROP_PID_MIME, "*"), | |
| //for the rest, we include everything, only specifies excluded ones from above and non-handled ones | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_AVC), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_AVC_PS), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_SVC), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_MVC), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_HEVC), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_LHVC), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_MPEG4_PART2), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_VVC), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_MPEG2_PART3), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_MPEG_AUDIO), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_MPEG_AUDIO_L1), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG4), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG2_MP), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG2_LCP), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_AAC_MPEG2_SSRP), | |
| // CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_RAW), | |
| //WebVTT needs rewrite | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_WEBVTT), | |
| //systems streams not dumpable to file | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_BIFS), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_BIFS_V2), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_OD_V1), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_OD_V2), | |
| //this one need QCP | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_QCELP), | |
| //other not supported (yet) | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_THEORA), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_VORBIS) | |
| }; | |
| #define OFFS(_n) #_n, offsetof(GF_GenDumpCtx, _n) | |
| static GF_FilterArgs GenDumpArgs[] = | |
| { | |
| { OFFS(exporter), "compatibility with old exporter, displays export results", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED}, | |
| { OFFS(pfmt), "pixel format for raw extract. If not set, derived from extension", GF_PROP_PIXFMT, "none", NULL, 0}, | |
| { OFFS(afmt), "audio format for raw extract. If not set, derived from extension", GF_PROP_PCMFMT, "none", NULL, 0}, | |
| { OFFS(decinfo), "decoder config insert mode\n" | |
| "- no: never inserted\n" | |
| "- first: inserted on first packet\n" | |
| "- sap: inserted at each SAP\n" | |
| "- auto: selects between no and first based on media type", GF_PROP_UINT, "auto", "no|first|sap|auto", GF_FS_ARG_HINT_ADVANCED}, | |
| { OFFS(split), "force one file per frame", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED}, | |
| { OFFS(frame), "force single frame dump with no rewrite. In this mode, all codec types are supported", GF_PROP_BOOL, "false", NULL, 0}, | |
| { OFFS(sstart), "start number of frame to forward. If 0, all samples are forwarded", GF_PROP_UINT, "0", NULL, 0}, | |
| { OFFS(send), "end number of frame to forward. If less than start frame, all samples after start are forwarded", GF_PROP_UINT, "0", NULL, 0}, | |
| { OFFS(dur), "duration of media to forward after first sample. If 0, all samples are forwarded", GF_PROP_FRACTION, "0", NULL, 0}, | |
| { OFFS(merge_region), "merge TTML regions with same ID while reassembling TTML doc", GF_PROP_BOOL, "false", NULL, 0}, | |
| { OFFS(vtth), "vtt header injection mode\n" | |
| "- single: inject only at first frame of the stream\n" | |
| "- seg: inject at each non-empty segment\n" | |
| "- all: inject at each segment even empty ones", GF_PROP_UINT, "seg", "single|seg|all", 0}, | |
| { OFFS(add_nl), "add new line after each packet when dumping text streams", GF_PROP_BOOL, "false", NULL, 0}, | |
| { OFFS(rawb), "force direct dump of input without framing rewrite. In this mode, all codec types are supported", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT}, | |
| {0} | |
| }; | |
| static GF_Err writegen_initialize(GF_Filter *filter); | |
| void writegen_finalize(GF_Filter *filter) | |
| { | |
| GF_GenDumpCtx *ctx = gf_filter_get_udta(filter); | |
| if (ctx->bs) gf_bs_del(ctx->bs); | |
| if (ctx->write_buf) gf_free(ctx->write_buf); | |
| if (ctx->ttml_root) | |
| gf_xml_dom_node_del(ctx->ttml_root); | |
| if (ctx->ttml_dash_pck) { | |
| gf_filter_pck_unref(ctx->ttml_dash_pck); | |
| ctx->ttml_dash_pck = NULL; | |
| } | |
| } | |
| GF_FilterRegister GenDumpRegister = { | |
| .name = "writegen", | |
| GF_FS_SET_DESCRIPTION("Stream to File converter") | |
| GF_FS_SET_HELP("Generic single stream to file converter, used when extracting/converting PIDs.\n" | |
| "The writegen filter should usually not be explicitly loaded without a source ID specified, since the filter would likely match any PID connection.") | |
| .private_size = sizeof(GF_GenDumpCtx), | |
| .args = GenDumpArgs, | |
| .initialize = writegen_initialize, | |
| .finalize = writegen_finalize, | |
| SETCAPS(GenDumpCaps), | |
| .configure_pid = writegen_configure_pid, | |
| .process = writegen_process, | |
| .flags = GF_FS_REG_TEMP_INIT, | |
| .hint_class_type = GF_FS_CLASS_TOOL | |
| }; | |
| static const GF_FilterCapability FrameDumpCaps[] = | |
| { | |
| CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_NONE), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_UNKNOWN), | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_UINT(GF_CAPS_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE) | |
| }; | |
| static GF_Err writegen_initialize(GF_Filter *filter) | |
| { | |
| GF_GenDumpCtx *ctx = gf_filter_get_udta(filter); | |
| if (ctx->frame || ctx->rawb) { | |
| return gf_filter_override_caps(filter, (const GF_FilterCapability *) FrameDumpCaps, sizeof(FrameDumpCaps) / sizeof(GF_FilterCapability)); | |
| } | |
| return GF_OK; | |
| } | |
| const GF_FilterRegister *writegen_register(GF_FilterSession *session) | |
| { | |
| //assign runtime caps on first load | |
| if (!strcmp(GenDumpCaps[3].val.value.string, "gpac")) { | |
| GenDumpCaps[3].val.value.string = (char *) gf_pixel_fmt_all_shortnames(); | |
| GenDumpCaps[8].val.value.string = (char *) gf_audio_fmt_all_shortnames(); | |
| GenDumpArgs[1].min_max_enum = gf_pixel_fmt_all_names(); | |
| GenDumpArgs[2].min_max_enum = gf_audio_fmt_all_names(); | |
| } | |
| return &GenDumpRegister; | |
| } | |
| static GF_Err writeuf_initialize(GF_Filter *filter) | |
| { | |
| GF_GenDumpCtx *ctx = gf_filter_get_udta(filter); | |
| ctx->unframe_only = GF_TRUE; | |
| return GF_OK; | |
| } | |
| /* writeuf: same as writegen but declare unframed output cap rather than mime / ext , used to force unframed format for all streams handled by writegen */ | |
| static GF_FilterCapability GenDumpXCaps[] = | |
| { | |
| CAP_UINT(GF_CAPS_INPUT_OUTPUT|GF_CAPFLAG_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_UINT(GF_CAPS_INPUT_OUTPUT|GF_CAPFLAG_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_NONE), | |
| CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| CAP_BOOL(GF_CAPS_OUTPUT, GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| //prevent connection of this filter to file outputs, we only connect to unframer or all reframers | |
| CAP_STRING(GF_CAPS_OUTPUT|GF_CAPFLAG_OPTIONAL, GF_PROP_PID_FILE_EXT, "__ignore"), | |
| }; | |
| const GF_FilterRegister WriteUFRegister = { | |
| .name = "writeuf", | |
| GF_FS_SET_DESCRIPTION("Framed to Unframed converter") | |
| GF_FS_SET_HELP("Generic single stream to unframed format converter, used when converting PIDs. This filter should not be explicitly loaded.\n") | |
| .private_size = sizeof(GF_GenDumpCtx), | |
| .initialize = writeuf_initialize, | |
| .finalize = writegen_finalize, | |
| SETCAPS(GenDumpXCaps), | |
| .configure_pid = writegen_configure_pid, | |
| .process = writegen_process, | |
| .hint_class_type = GF_FS_CLASS_FRAMING | |
| }; | |
| const GF_FilterRegister *writeuf_register(GF_FilterSession *session) | |
| { | |
| return &WriteUFRegister; | |
| } | |
| static GF_Err ttmlmerge_initialize(GF_Filter *filter) | |
| { | |
| GF_GenDumpCtx *ctx = gf_filter_get_udta(filter); | |
| ctx->unframe_only = GF_TRUE; | |
| ctx->ttml_merger = GF_TRUE; | |
| ctx->ttml_agg = GF_TRUE; | |
| return GF_OK; | |
| } | |
| /* ttml merger: we reuse writegen logic for TTML merging, but keeping sample timing*/ | |
| static GF_FilterCapability TTMLMergeCaps[] = | |
| { | |
| CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_TEXT), | |
| CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_SUBS_XML), | |
| CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE), | |
| }; | |
| const GF_FilterRegister TTMLMergeRegister = { | |
| .name = "ttmlmerge", | |
| GF_FS_SET_DESCRIPTION("TTML sample merger") | |
| GF_FS_SET_HELP("Merge input samples into a single TTML sample. Merging restarts at the start of DASH segments.\n") | |
| // .flags = GF_FS_REG_EXPLICIT_ONLY, | |
| .private_size = sizeof(GF_GenDumpCtx), | |
| .initialize = ttmlmerge_initialize, | |
| .finalize = writegen_finalize, | |
| SETCAPS(TTMLMergeCaps), | |
| .configure_pid = writegen_configure_pid, | |
| .process = writegen_process, | |
| .hint_class_type = GF_FS_CLASS_SUBTITLE | |
| }; | |
| const GF_FilterRegister *ttmlmerge_register(GF_FilterSession *session) | |
| { | |
| return &TTMLMergeRegister; | |
| } | |
| #else | |
| const GF_FilterRegister *writegen_register(GF_FilterSession *session) | |
| { | |
| return NULL; | |
| } | |
| const GF_FilterRegister *writeuf_register(GF_FilterSession *session) | |
| { | |
| return NULL; | |
| } | |
| const GF_FilterRegister *ttmlmerge_register(GF_FilterSession *session) | |
| { | |
| return NULL; | |
| } | |
| #endif //#ifndef GPAC_DISABLE_WRITEGEN |