| /* | |
| * GPAC - Multimedia Framework C SDK | |
| * | |
| * Authors: Jean Le Feuvre | |
| * Copyright (c) Telecom ParisTech 2022-2024 | |
| * All rights reserved | |
| * | |
| * This file is part of GPAC / compressed bitstream splitter 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/internal/media_dev.h> | |
| #include <gpac/mpeg4_odf.h> | |
| #if !defined(GPAC_DISABLE_AV_PARSERS) && !defined(GPAC_DISABLE_BSSPLIT) | |
| typedef struct | |
| { | |
| GF_FilterPid *opid; | |
| u32 max_layer_id, max_temporal_id; | |
| u32 min_lid_plus_one, min_tid_plus_one; | |
| Bool is_base, is_init; | |
| u32 id, dep_id, width, height; | |
| GF_FilterPacket *pck; | |
| GF_AVCConfig *svcc; | |
| } BSSplitOut; | |
| typedef struct _bs_split_ctx BSSplitCtx; | |
| typedef struct _bs_split_pid BSSplitIn; | |
| struct _bs_split_pid | |
| { | |
| u32 nalu_size_length; | |
| u32 codec_id; | |
| u64 first_ts_plus_one; | |
| GF_Err (*rewrite_pid_config)(BSSplitCtx *ctx, BSSplitIn *pctx); | |
| GF_Err (*split_packet)(BSSplitCtx *ctx, BSSplitIn *pctx, GF_FilterPacket *pck); | |
| GF_FilterPid *ipid; | |
| GF_List *opids; | |
| GF_AVCConfig *avcc; | |
| GF_AVCConfig *svcc; | |
| AVCState *avc_state; | |
| GF_BitStream *r_bs; | |
| u32 max_layers, max_sublayers; | |
| }; | |
| struct _bs_split_ctx | |
| { | |
| //options | |
| GF_PropStringList ltid; | |
| Bool sig_ltid, svcqid; | |
| //internal | |
| GF_Filter *filter; | |
| GF_List *pids; | |
| }; | |
| static Bool match_substream(BSSplitOut *c_opid, u32 layer_id, u32 temporal_id) | |
| { | |
| if (layer_id > c_opid->max_layer_id) return GF_FALSE; | |
| if (temporal_id > c_opid->max_temporal_id) return GF_FALSE; | |
| if (c_opid->min_lid_plus_one) { | |
| if (layer_id < c_opid->min_lid_plus_one-1) | |
| return GF_FALSE; | |
| if (layer_id > c_opid->min_lid_plus_one-1) | |
| return GF_TRUE; | |
| } | |
| if (c_opid->min_tid_plus_one) { | |
| if (temporal_id <= c_opid->min_tid_plus_one-1) | |
| return GF_FALSE; | |
| } | |
| return GF_TRUE; | |
| } | |
| //reinsert param set by ID order | |
| static void bs_split_svc_add_param(GF_List *ps_list, GF_NALUFFParam *sl) | |
| { | |
| u32 i, count=gf_list_count(ps_list); | |
| for (i=0; i<count; i++) { | |
| GF_NALUFFParam *p = gf_list_get(ps_list, i); | |
| if (p->id > sl->id) { | |
| gf_list_insert(ps_list, sl, i); | |
| return; | |
| } | |
| } | |
| gf_list_add(ps_list, sl); | |
| } | |
| static void bs_split_check_svc_config(BSSplitIn *pctx, BSSplitOut *c_opid) | |
| { | |
| u32 i; | |
| Bool sps_found=GF_FALSE, pps_found=GF_FALSE; | |
| u32 avc_pps_id = pctx->avc_state->s_info.pps->id; | |
| //warning the sps ID internally stored in svcc is shifted by GF_SVC_SSPS_ID_SHIFT | |
| u32 avc_sps_id; | |
| if (pctx->avc_state->last_nal_type_parsed == GF_AVC_NALU_SVC_SLICE) | |
| avc_sps_id = pctx->avc_state->s_info.pps->sps_id + GF_SVC_SSPS_ID_SHIFT; | |
| else | |
| avc_sps_id = pctx->avc_state->s_info.pps->sps_id; | |
| if (!c_opid->svcc) { | |
| GF_SAFEALLOC(c_opid->svcc, GF_AVCConfig); | |
| memcpy(c_opid->svcc, pctx->svcc, sizeof(GF_AVCConfig)); | |
| c_opid->svcc->sequenceParameterSets = gf_list_new(); | |
| c_opid->svcc->pictureParameterSets = gf_list_new(); | |
| c_opid->svcc->complete_representation = 0; | |
| } | |
| if (pctx->avc_state->sps[avc_sps_id].width > c_opid->width) { | |
| c_opid->width = pctx->avc_state->sps[avc_sps_id].width; | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_WIDTH, &PROP_UINT(c_opid->width)); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_WIDTH_MAX, &PROP_UINT(c_opid->width)); | |
| } | |
| if (pctx->avc_state->sps[avc_sps_id].height > c_opid->height) { | |
| c_opid->height = pctx->avc_state->sps[avc_sps_id].height; | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_HEIGHT, &PROP_UINT(c_opid->height)); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_HEIGHT_MAX, &PROP_UINT(c_opid->height)); | |
| } | |
| #define CHECK_PARAM(_name, _id, _res)\ | |
| for (i=0; i<gf_list_count(_name); i++) {\ | |
| GF_NALUFFParam *sl = gf_list_get(_name, i);\ | |
| if (sl->id == _id) { _res = GF_TRUE; break; }\ | |
| } | |
| //check sps, first in our config | |
| CHECK_PARAM(c_opid->svcc->sequenceParameterSets, avc_sps_id, sps_found) | |
| if (!sps_found) { | |
| //sps is in base config | |
| CHECK_PARAM(pctx->avcc->sequenceParameterSets, avc_sps_id, sps_found) | |
| if (!sps_found && (avc_sps_id<GF_SVC_SSPS_ID_SHIFT)) { | |
| CHECK_PARAM(c_opid->svcc->sequenceParameterSets, avc_sps_id+GF_SVC_SSPS_ID_SHIFT, sps_found) | |
| } | |
| } | |
| //check pps, first in our config | |
| CHECK_PARAM(c_opid->svcc->pictureParameterSets, avc_pps_id, pps_found) | |
| if (!pps_found) { | |
| //pps is in base config | |
| CHECK_PARAM(pctx->avcc->pictureParameterSets, avc_pps_id, pps_found) | |
| } | |
| if (pps_found && sps_found) return; | |
| if (!sps_found) { | |
| rebrowse_sps: | |
| for (i=0; i<gf_list_count(pctx->svcc->sequenceParameterSets); i++) { | |
| GF_NALUFFParam *sl = gf_list_get(pctx->svcc->sequenceParameterSets, i); | |
| if (sl->id == avc_sps_id) { | |
| sps_found = GF_TRUE; | |
| if (gf_list_find(c_opid->svcc->sequenceParameterSets, sl)<0) | |
| bs_split_svc_add_param(c_opid->svcc->sequenceParameterSets, sl); | |
| break; | |
| } | |
| } | |
| if (!sps_found && (avc_sps_id<GF_SVC_SSPS_ID_SHIFT)) { | |
| avc_sps_id+=GF_SVC_SSPS_ID_SHIFT; | |
| goto rebrowse_sps; | |
| } | |
| } | |
| if (!pps_found) { | |
| for (i=0; i<gf_list_count(pctx->svcc->pictureParameterSets); i++) { | |
| GF_NALUFFParam *sl = gf_list_get(pctx->svcc->pictureParameterSets, i); | |
| if (sl->id == avc_pps_id) { | |
| pps_found = GF_TRUE; | |
| if (gf_list_find(c_opid->svcc->pictureParameterSets, sl)<0) | |
| bs_split_svc_add_param(c_opid->svcc->pictureParameterSets, sl); | |
| break; | |
| } | |
| } | |
| } | |
| if (!sps_found) { | |
| GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[BSSplit] Missing sequence parameter set ID %d in input\n", (avc_sps_id>GF_SVC_SSPS_ID_SHIFT) ? (avc_sps_id-GF_SVC_SSPS_ID_SHIFT) : avc_sps_id)); | |
| } | |
| if (!pps_found) { | |
| GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[BSSplit] Missing picture parameter set ID %d in input\n", avc_pps_id)); | |
| } | |
| if (!pps_found && !sps_found) return; | |
| u8 *dsi; | |
| u32 dsi_size; | |
| gf_odf_avc_cfg_write(c_opid->svcc, &dsi, &dsi_size); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT, &PROP_DATA_NO_COPY(dsi, dsi_size) ); | |
| } | |
| static void bs_split_update_hevc_linf(BSSplitIn *pctx, BSSplitOut *c_opid) | |
| { | |
| u32 i; | |
| u32 max_lid = c_opid->max_layer_id; | |
| u32 max_tid = c_opid->max_temporal_id; | |
| u32 min_lid = 0; | |
| u32 min_tid = 0; | |
| for (i=0; i<gf_list_count(pctx->opids); i++) { | |
| BSSplitOut *an_out = gf_list_get(pctx->opids, i); | |
| if (an_out==c_opid) continue; | |
| if (max_lid < an_out->max_layer_id) continue; | |
| if (max_lid == an_out->max_layer_id) { | |
| if (min_tid<an_out->max_temporal_id) min_tid = an_out->max_temporal_id; | |
| continue; | |
| } | |
| if (min_lid < an_out->max_layer_id) min_lid = an_out->max_layer_id; | |
| } | |
| if (pctx->max_layers) { | |
| if (max_lid >= pctx->max_layers) max_lid = pctx->max_layers-1; | |
| } else { | |
| if (max_lid >= 63) max_lid = 63; | |
| } | |
| if (pctx->max_sublayers) { | |
| if (max_tid > pctx->max_sublayers) max_tid = pctx->max_sublayers; | |
| } else { | |
| if (max_tid > 7) max_tid = 7; | |
| } | |
| u32 nb_layers = (max_lid - min_lid); | |
| if (!nb_layers) { | |
| nb_layers = 1; | |
| min_lid = 0; | |
| } else { | |
| min_lid++; | |
| } | |
| GF_BitStream *bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE); | |
| gf_bs_write_int(bs, 0, 2); | |
| gf_bs_write_int(bs, nb_layers, 6); | |
| for (i=0; i<nb_layers; i++) { | |
| gf_bs_write_int(bs, 0, 4); | |
| gf_bs_write_int(bs, min_lid+i, 6); | |
| gf_bs_write_int(bs, min_tid+1, 3); | |
| gf_bs_write_int(bs, max_tid, 3); | |
| gf_bs_write_int(bs, 0, 1); | |
| gf_bs_write_int(bs, 0xFF, 7); | |
| } | |
| u8 *data; | |
| u32 data_size; | |
| gf_bs_get_content(bs, &data, &data_size); | |
| gf_bs_del(bs); | |
| gf_filter_pid_set_info_str(c_opid->opid, "hevc:linf", &PROP_DATA_NO_COPY(data, data_size) ); | |
| } | |
| static void bs_split_copy_props_base(BSSplitCtx *ctx, BSSplitOut *c_opid, GF_FilterPid *pid, u32 svc_base_id) | |
| { | |
| gf_filter_pid_copy_properties(c_opid->opid, pid); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_ID, &PROP_UINT(c_opid->id)); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_ISOM_STSD_TEMPLATE, NULL); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_ISOM_STSD_ALL_TEMPLATES, NULL); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_ISOM_SUBTYPE, NULL); | |
| if (!c_opid->is_base) { | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_ISOM_TRACK_TEMPLATE, NULL); | |
| } else { | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DOLBY_VISION, NULL); | |
| } | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_BITRATE, NULL); | |
| //we must force negctts on output MP4 otherwise the mux will adjust timings for some tracks (P frames) | |
| //but not for tracks containing only I or B frames | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_ISOM_FORCE_NEGCTTS, &PROP_BOOL(GF_TRUE)); | |
| if (c_opid->width && c_opid->height) { | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_WIDTH, &PROP_UINT(c_opid->width)); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_HEIGHT, &PROP_UINT(c_opid->height)); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_WIDTH_MAX, &PROP_UINT(c_opid->width)); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_HEIGHT_MAX, &PROP_UINT(c_opid->height)); | |
| } | |
| if (c_opid->dep_id) | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DEPENDENCY_ID, &PROP_UINT(c_opid->dep_id)); | |
| if (ctx->sig_ltid) { | |
| gf_filter_pid_set_property_str(c_opid->opid, "max_layer_id", &PROP_UINT(c_opid->max_layer_id)); | |
| gf_filter_pid_set_property_str(c_opid->opid, "max_temporal_id", &PROP_UINT(c_opid->max_temporal_id)); | |
| } | |
| if (svc_base_id) { | |
| GF_PropertyValue prop_sbas; | |
| prop_sbas.type = GF_PROP_UINT_LIST; | |
| prop_sbas.value.uint_list.nb_items = 1; | |
| prop_sbas.value.uint_list.vals = &svc_base_id; | |
| //inject sbas reference | |
| gf_filter_pid_set_property_str(c_opid->opid, "isom:sbas", &prop_sbas); | |
| } | |
| //the rest: codecID, decoder config and codec-specific props are done elsewhere | |
| } | |
| static BSSplitOut *bs_split_get_out_stream(BSSplitCtx *ctx, BSSplitIn *pctx, Bool is_config, u32 layer_id, u32 temporal_id, Bool force_dv) | |
| { | |
| u32 i, count; | |
| Bool update_linf=GF_FALSE; | |
| BSSplitOut *c_opid = NULL; | |
| BSSplitOut *max_c_opid = NULL; | |
| if (!layer_id && (temporal_id==1)) { | |
| c_opid = gf_list_get(pctx->opids, 0); | |
| c_opid->is_base = GF_TRUE; | |
| } else { | |
| count = gf_list_count(pctx->opids); | |
| for (i=0; i<count; i++) { | |
| c_opid = gf_list_get(pctx->opids, i); | |
| if ((c_opid->max_layer_id==99) && (c_opid->max_temporal_id==99)) | |
| max_c_opid = c_opid; | |
| if (match_substream(c_opid, layer_id, temporal_id)) | |
| break; | |
| c_opid = NULL; | |
| } | |
| } | |
| //assign config based on settings | |
| u32 min_lid_last = 0; | |
| u32 min_tid_last = 0; | |
| u32 max_lid = 0; | |
| u32 max_tid = 0; | |
| //no output or max TID not assigned, parse config | |
| if (!c_opid || !c_opid->max_temporal_id) { | |
| //if no config, assume layer split | |
| if (!ctx->ltid.nb_items) { | |
| max_lid = layer_id; | |
| max_tid = 99; | |
| } else { | |
| Bool found=GF_FALSE; | |
| for (i=0; i<ctx->ltid.nb_items; i++) { | |
| u32 max_layer_id = 0; | |
| u32 max_temporal_id = 0; | |
| char *ltid = ctx->ltid.vals[i]; | |
| if (ltid[0] == '.') { | |
| max_layer_id = 99; | |
| sscanf(ltid, ".%u", &max_temporal_id); | |
| } else if (!strcmp(ltid, "all")) { | |
| max_layer_id = layer_id; | |
| max_temporal_id = temporal_id; | |
| } else if (strchr(ltid, '.')) { | |
| sscanf(ltid, "%u.%u", &max_layer_id, &max_temporal_id); | |
| } else { | |
| sscanf(ltid, "%u", &max_layer_id); | |
| max_temporal_id=99; | |
| } | |
| if (!max_temporal_id) max_temporal_id = 1; | |
| if (max_layer_id!=99) { | |
| if (min_lid_last < max_layer_id+1) min_lid_last = max_layer_id+1; | |
| } | |
| if (max_temporal_id!=99) { | |
| if (min_tid_last < max_temporal_id+1) min_tid_last = max_temporal_id+1; | |
| } | |
| //layer not specified or we match our layer, check temporal | |
| if ((max_layer_id==99) || (max_layer_id == layer_id)) { | |
| if (max_temporal_id >= temporal_id) { | |
| max_lid = max_layer_id; | |
| max_tid = max_temporal_id; | |
| found = GF_TRUE; | |
| break; | |
| } | |
| } | |
| else if ((max_layer_id > layer_id) && (max_temporal_id >= temporal_id)) { | |
| max_lid = max_layer_id; | |
| max_tid = max_temporal_id; | |
| found = GF_TRUE; | |
| break; | |
| } | |
| } | |
| //no stream found (e.g. max stream), use max stream if existing | |
| if (!c_opid && !found && max_c_opid) { | |
| c_opid = max_c_opid; | |
| } | |
| else if (!found) { | |
| //if we get here, last layer specified, put everything higher in this stream | |
| max_lid = 99; | |
| max_tid = 99; | |
| } else { | |
| min_lid_last = 0; | |
| min_tid_last = 0; | |
| } | |
| } | |
| } | |
| if (!c_opid) { | |
| const GF_PropertyValue *p; | |
| BSSplitOut *base_out = gf_list_last(pctx->opids); | |
| u32 base_id; | |
| GF_SAFEALLOC(c_opid, BSSplitOut); | |
| if (!c_opid) return NULL; | |
| gf_list_add(pctx->opids, c_opid); | |
| c_opid->opid = gf_filter_pid_new(ctx->filter); | |
| p = gf_filter_pid_get_property(pctx->ipid, GF_PROP_PID_ID); | |
| base_id = p ? p->value.uint : 1; | |
| c_opid->id = base_id + 100 + gf_list_count(pctx->opids)-2; | |
| //check dependencies, first by layers, then by tid within layer | |
| //note that this is not sufficient: if we split L0(T1,T2)+L1(T1,T2) in 4 streams | |
| //L1T2 depends on both L1T1 and L0T2 | |
| BSSplitOut *dep=NULL; | |
| count = gf_list_count(pctx->opids); | |
| for (i=count; i>1; i--) { | |
| dep = gf_list_get(pctx->opids, i-2); | |
| if ((dep->max_layer_id==layer_id) && (dep->max_temporal_id < temporal_id)) { | |
| break; | |
| } | |
| dep=NULL; | |
| } | |
| if (!dep) { | |
| for (i=count; i>1; i--) { | |
| dep = gf_list_get(pctx->opids, i-2); | |
| if (dep->max_layer_id<layer_id) { | |
| break; | |
| } | |
| dep = NULL; | |
| } | |
| } | |
| if (!dep) | |
| dep = gf_list_get(pctx->opids, 0); | |
| c_opid->dep_id = dep->id; | |
| //get first stream with same layer ID and set width/height | |
| for (i=0; i<count-1; i++) { | |
| dep = gf_list_get(pctx->opids, i); | |
| if (dep->width && dep->height && (dep->max_layer_id == layer_id)) { | |
| c_opid->width = dep->width; | |
| c_opid->height = dep->height; | |
| break; | |
| } | |
| } | |
| //ready to copy properties | |
| bs_split_copy_props_base(ctx, c_opid, pctx->ipid, (pctx->codec_id==GF_CODECID_AVC) ? base_id : 0); | |
| //not called during config, we must recreate decoder config and set codec IDs | |
| //this happens for: | |
| //- temporal sublayers which are usually not detected at configure | |
| //- SVC for which we need frames to detect LID TID | |
| //- DolbyVision RPU/EL | |
| if (!is_config) { | |
| Bool base_is_enh=GF_FALSE; | |
| //always remove decoder config from enhancement | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DECODER_CONFIG, NULL); | |
| p = gf_filter_pid_get_property(base_out->opid, GF_PROP_PID_DECODER_CONFIG); | |
| if (!p) { | |
| base_is_enh = GF_TRUE; | |
| p = gf_filter_pid_get_property(base_out->opid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT); | |
| } | |
| //DV split | |
| if (force_dv) { | |
| u8 dvcfg[24]; | |
| //set dsi | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DECODER_CONFIG, p); | |
| //set dv | |
| p = gf_filter_pid_get_property(pctx->ipid, GF_PROP_PID_DOLBY_VISION); | |
| if (p && (p->value.data.size==24)) memcpy(dvcfg, p->value.data.ptr, 24); | |
| else { | |
| memset(dvcfg, 0, 24); | |
| dvcfg[0] = 1; | |
| dvcfg[0] = 1; | |
| } | |
| //remove bl_present_flag, last lsb bit of byte 4 | |
| dvcfg[3] &= ~1; | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DOLBY_VISION, &PROP_DATA(dvcfg, 24)); | |
| if ((pctx->codec_id==GF_CODECID_HEVC) || (pctx->codec_id==GF_CODECID_LHVC)) { | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_HEVC) ); | |
| } | |
| else if (pctx->codec_id==GF_CODECID_AVC) { | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_AVC) ); | |
| } | |
| //VVC, not defined yet | |
| else { | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_VVC) ); | |
| } | |
| } | |
| //L-HEVC split, build decoder config(s) | |
| else if ((pctx->codec_id==GF_CODECID_HEVC) || (pctx->codec_id==GF_CODECID_LHVC)) { | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_LHVC) ); | |
| if (p) { | |
| u8 *dsi; | |
| u32 dsi_size; | |
| GF_HEVCConfig *hvcc = gf_odf_hevc_cfg_read(p->value.data.ptr, p->value.data.size, (base_is_enh ? GF_TRUE : GF_FALSE) ); | |
| hvcc->is_lhvc = GF_TRUE; | |
| gf_odf_hevc_cfg_write(hvcc, &dsi, &dsi_size); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT, &PROP_DATA_NO_COPY(dsi, dsi_size) ); | |
| gf_odf_hevc_cfg_del(hvcc); | |
| } | |
| update_linf = GF_TRUE; | |
| } else { | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT, p); | |
| if (pctx->codec_id==GF_CODECID_AVC) { | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_SVC) ); | |
| } | |
| } | |
| } | |
| } | |
| if (!is_config && pctx->avc_state && (layer_id || (temporal_id>1))) | |
| bs_split_check_svc_config(pctx, c_opid); | |
| if (c_opid->max_temporal_id) | |
| return c_opid; | |
| c_opid->max_layer_id = max_lid; | |
| c_opid->max_temporal_id = max_tid; | |
| //keep track of min lid/tid defined in config so we don't put NALs on highest stream when intermediate stream | |
| //is not yet defined (temporal scalable) | |
| if (min_lid_last) c_opid->min_lid_plus_one = min_lid_last; | |
| if (min_tid_last) c_opid->min_tid_plus_one = min_tid_last; | |
| if (ctx->sig_ltid) { | |
| gf_filter_pid_set_property_str(c_opid->opid, "max_layer_id", &PROP_UINT(c_opid->max_layer_id)); | |
| gf_filter_pid_set_property_str(c_opid->opid, "max_temporal_id", &PROP_UINT(c_opid->max_temporal_id)); | |
| } | |
| if (update_linf) bs_split_update_hevc_linf(pctx, c_opid); | |
| return c_opid; | |
| } | |
| static void bs_split_svcc_del(GF_AVCConfig *svcc) | |
| { | |
| if (!svcc) return; | |
| gf_list_reset(svcc->sequenceParameterSets); | |
| gf_list_reset(svcc->pictureParameterSets); | |
| gf_odf_avc_cfg_del(svcc); | |
| } | |
| static GF_Err avc_rewrite_pid_config(BSSplitCtx *ctx, BSSplitIn *pctx) | |
| { | |
| GF_AVCConfig *avcc; | |
| BSSplitOut *c_opid; | |
| u8 *dsi; | |
| u32 dsi_size, i, count, base_id; | |
| u32 width=0, height=0; | |
| const GF_PropertyValue *prop; | |
| prop = gf_filter_pid_get_property(pctx->ipid, GF_PROP_PID_DECODER_CONFIG); | |
| if (!prop) return GF_OK; | |
| avcc = gf_odf_avc_cfg_read(prop->value.data.ptr, prop->value.data.size); | |
| if (!avcc) return GF_NON_COMPLIANT_BITSTREAM; | |
| if (!pctx->avc_state) pctx->avc_state = (AVCState *) gf_malloc(sizeof(AVCState)); | |
| memset(pctx->avc_state, 0, sizeof(AVCState)); | |
| if (!pctx->r_bs) | |
| pctx->r_bs = gf_bs_new((u8*)pctx->avc_state, 1, GF_BITSTREAM_READ); | |
| gf_odf_avc_cfg_write(avcc, &dsi, &dsi_size); | |
| pctx->nalu_size_length = avcc->nal_unit_size; | |
| //cleanup all svcc, they contain pointers to pctx->avcc andf pctx->svcc we are about to free | |
| for (i=1; i<gf_list_count(pctx->opids); i++) { | |
| c_opid = gf_list_get(pctx->opids, i); | |
| if (c_opid->svcc) { | |
| bs_split_svcc_del(c_opid->svcc); | |
| c_opid->svcc = NULL; | |
| } | |
| } | |
| if (pctx->avcc) gf_odf_avc_cfg_del(pctx->avcc); | |
| pctx->avcc = avcc; | |
| #define AVC_READ_LIST(_list, _is_sps) \ | |
| if (_list) {\ | |
| count = gf_list_count(_list);\ | |
| for (i=0; i<count; i++) {\ | |
| GF_NALUFFParam *sl = gf_list_get(_list, i);\ | |
| gf_bs_reassign_buffer(pctx->r_bs, sl->data, sl->size);\ | |
| gf_bs_enable_emulation_byte_removal(pctx->r_bs, GF_TRUE);\ | |
| s32 res = gf_avc_parse_nalu(pctx->r_bs, pctx->avc_state);\ | |
| if (res>=0) {\ | |
| sl->id = pctx->avc_state->last_ps_idx;\ | |
| if (_is_sps) {\ | |
| width = pctx->avc_state->sps[sl->id].width;\ | |
| height = pctx->avc_state->sps[sl->id].height;\ | |
| }\ | |
| }\ | |
| }\ | |
| }\ | |
| AVC_READ_LIST(pctx->avcc->sequenceParameterSets, GF_TRUE) | |
| AVC_READ_LIST(pctx->avcc->pictureParameterSets, GF_FALSE) | |
| AVC_READ_LIST(pctx->avcc->sequenceParameterSetExtensions, GF_FALSE) | |
| if (pctx->svcc) gf_odf_avc_cfg_del(pctx->svcc); | |
| pctx->svcc = NULL; | |
| prop = gf_filter_pid_get_property(pctx->ipid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT); | |
| if (prop) { | |
| pctx->svcc = gf_odf_avc_cfg_read(prop->value.data.ptr, prop->value.data.size); | |
| if (!pctx->svcc) return GF_NON_COMPLIANT_BITSTREAM; | |
| } | |
| //rewrite config of base | |
| c_opid = gf_list_get(pctx->opids, 0); | |
| if (width && height) { | |
| c_opid->width = width; | |
| c_opid->height = height; | |
| } | |
| bs_split_copy_props_base(ctx, c_opid, pctx->ipid, 0); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA_NO_COPY(dsi, dsi_size) ); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT, NULL); | |
| base_id = c_opid->id; | |
| //for SVC/MVC we need slices to figure out what shoud go where, which is why we keep a copy of avcC and svcC | |
| if (pctx->svcc) { | |
| AVC_READ_LIST(pctx->svcc->sequenceParameterSets, GF_FALSE) | |
| AVC_READ_LIST(pctx->svcc->pictureParameterSets, GF_FALSE) | |
| AVC_READ_LIST(pctx->svcc->sequenceParameterSetExtensions, GF_FALSE) | |
| } | |
| //copy props on all defined pids | |
| for (i=1; i<gf_list_count(pctx->opids); i++) { | |
| c_opid = gf_list_get(pctx->opids, i); | |
| bs_split_copy_props_base(ctx, c_opid, pctx->ipid, base_id); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_SVC) ); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DECODER_CONFIG, NULL); | |
| //reset decoder config, it will be recreated when parsing SVC slices | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT, NULL); | |
| } | |
| return GF_OK; | |
| } | |
| static GF_Err vvc_hevc_rewrite_pid_config(BSSplitCtx *ctx, BSSplitIn *pctx) | |
| { | |
| GF_HEVCConfig *hvcc=NULL; | |
| GF_HEVCConfig *hvcc_out = NULL; | |
| #ifndef GPAC_DISABLE_AV_PARSERS | |
| HEVCState *hvcc_state = NULL; | |
| VVCState *vvcc_state = NULL; | |
| #else | |
| void *hvcc_state = NULL; | |
| void *vvcc_state = NULL; | |
| #endif | |
| Bool is_vvc = GF_FALSE; | |
| GF_VVCConfig *vvcc=NULL; | |
| GF_VVCConfig *vvcc_out = NULL; | |
| u8 *dsi; | |
| u32 dsi_size, i, j, count; | |
| GF_List *param_array; | |
| const GF_PropertyValue *cfg, *cfg_enh; | |
| cfg = gf_filter_pid_get_property(pctx->ipid, GF_PROP_PID_DECODER_CONFIG); | |
| cfg_enh = gf_filter_pid_get_property(pctx->ipid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT); | |
| if (!cfg && !cfg_enh) return GF_OK; | |
| if (pctx->codec_id==GF_CODECID_VVC) is_vvc = GF_TRUE; | |
| if (cfg) { | |
| if (is_vvc) { | |
| vvcc = gf_odf_vvc_cfg_read(cfg->value.data.ptr, cfg->value.data.size); | |
| } else { | |
| hvcc = gf_odf_hevc_cfg_read(cfg->value.data.ptr, cfg->value.data.size, (!cfg_enh && (pctx->codec_id==GF_CODECID_LHVC)) ? GF_TRUE : GF_FALSE); | |
| } | |
| } else { | |
| if (is_vvc) { | |
| vvcc = gf_odf_vvc_cfg_read(cfg_enh->value.data.ptr, cfg_enh->value.data.size); | |
| } else { | |
| hvcc = gf_odf_hevc_cfg_read(cfg_enh->value.data.ptr, cfg_enh->value.data.size, GF_TRUE); | |
| } | |
| } | |
| if (vvcc) | |
| pctx->nalu_size_length = vvcc->nal_unit_size; | |
| else if (hvcc) | |
| pctx->nalu_size_length = hvcc->nal_unit_size; | |
| else | |
| return GF_NON_COMPLIANT_BITSTREAM; | |
| //gather all param sets | |
| restart: | |
| param_array = vvcc ? vvcc->param_array : hvcc->param_array; | |
| count = gf_list_count(param_array); | |
| for (i=0; i<count; i++) { | |
| GF_NALUFFParamArray *pa = gf_list_get(param_array, i); | |
| u32 count2 = gf_list_count(pa->nalus); | |
| for (j=0; j<count2; j++) { | |
| GF_List *pa_out_list; | |
| u32 layer_id=0, temporal_id=0; | |
| GF_NALUFFParamArray *pa_out = NULL; | |
| GF_NALUFFParam *nal = gf_list_get(pa->nalus, j); | |
| if (is_vvc) { | |
| layer_id = nal->data[0] & 0x3F; | |
| temporal_id = (nal->data[1] & 0x7); | |
| } else { | |
| layer_id = nal->data[0] & 1; | |
| layer_id <<= 5; | |
| layer_id |= (nal->data[1] >> 3) & 0x1F; | |
| temporal_id = (nal->data[1] & 0x7); | |
| } | |
| BSSplitOut *c_opid = bs_split_get_out_stream(ctx, pctx, GF_TRUE, layer_id, temporal_id, GF_FALSE); | |
| if (!c_opid) return GF_OUT_OF_MEM; | |
| if (is_vvc) { | |
| if (!vvcc_out) { | |
| GF_SAFEALLOC(vvcc_out, GF_VVCConfig); | |
| if (!vvcc_out) { | |
| gf_odf_vvc_cfg_del(vvcc); | |
| return GF_OUT_OF_MEM; | |
| } | |
| memcpy(vvcc_out, vvcc, sizeof(GF_VVCConfig)); | |
| vvcc_out->general_constraint_info = gf_malloc(sizeof(u8)*vvcc_out->num_constraint_info); | |
| if (!vvcc_out->general_constraint_info) { | |
| gf_odf_vvc_cfg_del(vvcc); | |
| return GF_OUT_OF_MEM; | |
| } | |
| memcpy(vvcc_out->general_constraint_info, vvcc->general_constraint_info, sizeof(u8)*vvcc_out->num_constraint_info); | |
| vvcc_out->param_array = gf_list_new(); | |
| if (!vvcc_out->param_array) { | |
| gf_odf_vvc_cfg_del(vvcc); | |
| gf_odf_vvc_cfg_del(vvcc_out); | |
| return GF_OUT_OF_MEM; | |
| } | |
| } | |
| pa_out_list = vvcc_out->param_array; | |
| } else { | |
| if (!hvcc_out) { | |
| GF_SAFEALLOC(hvcc_out, GF_HEVCConfig); | |
| if (!hvcc_out) { | |
| gf_odf_hevc_cfg_del(hvcc); | |
| return GF_OUT_OF_MEM; | |
| } | |
| memcpy(hvcc_out, hvcc, sizeof(GF_HEVCConfig)); | |
| hvcc_out->param_array = gf_list_new(); | |
| if (!hvcc_out->param_array) { | |
| gf_odf_hevc_cfg_del(hvcc); | |
| gf_odf_hevc_cfg_del(hvcc_out); | |
| return GF_OUT_OF_MEM; | |
| } | |
| } | |
| pa_out_list = hvcc_out->param_array; | |
| } | |
| for (u32 k=0; k<gf_list_count(pa_out_list); k++) { | |
| pa_out = gf_list_get(pa_out_list, k); | |
| if (pa_out->type == pa->type) break; | |
| pa_out = NULL; | |
| } | |
| if (pa_out == NULL) { | |
| GF_SAFEALLOC(pa_out, GF_NALUFFParamArray); | |
| if (pa_out) pa_out->nalus = gf_list_new(); | |
| if (!pa_out || !pa_out->nalus) { | |
| if (vvcc) gf_odf_vvc_cfg_del(vvcc); | |
| if (vvcc_out) gf_odf_vvc_cfg_del(vvcc_out); | |
| if (hvcc) gf_odf_hevc_cfg_del(hvcc); | |
| if (hvcc_out) gf_odf_hevc_cfg_del(hvcc_out); | |
| if (pa_out) gf_free(pa_out); | |
| return GF_OUT_OF_MEM; | |
| } | |
| pa_out->type = pa->type; | |
| pa_out->array_completeness = 1; | |
| gf_list_add(pa_out_list, pa_out); | |
| } | |
| GF_NALUFFParam *nal_out; | |
| GF_SAFEALLOC(nal_out, GF_NALUFFParam); | |
| nal_out->size = nal->size; | |
| nal_out->data = gf_malloc(sizeof(u8) * nal->size); | |
| memcpy(nal_out->data, nal->data, sizeof(u8) * nal->size); | |
| gf_list_add(pa_out->nalus, nal_out); | |
| } | |
| } | |
| if (vvcc) { | |
| gf_odf_vvc_cfg_del(vvcc); | |
| vvcc = NULL; | |
| } | |
| if (hvcc) { | |
| gf_odf_hevc_cfg_del(hvcc); | |
| hvcc = NULL; | |
| } | |
| //for hevc we might get l-hevc config on main stream | |
| if (cfg_enh && cfg && !is_vvc) { | |
| hvcc = gf_odf_hevc_cfg_read(cfg_enh->value.data.ptr, cfg_enh->value.data.size, GF_TRUE); | |
| if (!hvcc) { | |
| if (hvcc_out) gf_odf_hevc_cfg_del(hvcc_out); | |
| return GF_NON_COMPLIANT_BITSTREAM; | |
| } | |
| cfg_enh = NULL; | |
| goto restart; | |
| } | |
| GF_Err e = GF_OK; | |
| vvcc = vvcc_out; | |
| hvcc = hvcc_out; | |
| #ifndef GPAC_DISABLE_AV_PARSERS | |
| if (hvcc) GF_SAFEALLOC(hvcc_state, HEVCState); | |
| if (vvcc) GF_SAFEALLOC(vvcc_state, VVCState); | |
| #endif | |
| count = gf_list_count(pctx->opids); | |
| for (i=0; i<count; i++) { | |
| u32 max_w=0, max_h=0; | |
| GF_List *orig_pa_list, *out_param_array; | |
| BSSplitOut *c_opid = gf_list_get(pctx->opids, i); | |
| if (vvcc) { | |
| orig_pa_list = vvcc->param_array; | |
| vvcc->param_array = gf_list_new(); | |
| if (!vvcc->param_array) { | |
| vvcc->param_array = orig_pa_list; | |
| e = GF_OUT_OF_MEM; | |
| break; | |
| } | |
| out_param_array = vvcc->param_array; | |
| } | |
| else if (hvcc) { | |
| orig_pa_list = hvcc->param_array; | |
| hvcc->is_lhvc = !c_opid->is_base ? GF_TRUE : GF_FALSE; | |
| hvcc->param_array = gf_list_new(); | |
| if (!hvcc->param_array) { | |
| hvcc->param_array = orig_pa_list; | |
| e = GF_OUT_OF_MEM; | |
| break; | |
| } | |
| out_param_array = hvcc->param_array; | |
| } else { | |
| e = GF_SERVICE_ERROR; | |
| break; | |
| } | |
| u32 count2 = gf_list_count(orig_pa_list); | |
| for (j=0; j<count2; j++) { | |
| GF_NALUFFParamArray *pa = gf_list_get(orig_pa_list, j); | |
| GF_NALUFFParamArray *pa_out = NULL; | |
| for (u32 k=0; k<gf_list_count(pa->nalus); k++) { | |
| Bool do_add = GF_FALSE; | |
| u32 layer_id=0, temporal_id=0; | |
| GF_NALUFFParam *nal = gf_list_get(pa->nalus, k); | |
| if (vvcc) { | |
| layer_id = nal->data[0] & 0x3F; | |
| temporal_id = (nal->data[1] & 0x7); | |
| } else { | |
| //u32 nal_type = (nal->data[0] & 0x7E) >> 1; | |
| layer_id = nal->data[0] & 1; | |
| layer_id <<= 5; | |
| layer_id |= (nal->data[1] >> 3) & 0x1F; | |
| temporal_id = (nal->data[1] & 0x7); | |
| if (pa->type == GF_HEVC_NALU_VID_PARAM) do_add = GF_TRUE; | |
| } | |
| if (match_substream(c_opid, layer_id, temporal_id)) | |
| do_add = GF_TRUE; | |
| if (!do_add) continue; | |
| #ifndef GPAC_DISABLE_AV_PARSERS | |
| if (hvcc_state) { | |
| u8 ntype, tid, lid; | |
| s32 res = gf_hevc_parse_nalu(nal->data, nal->size, hvcc_state, &ntype, &tid, &lid); | |
| if ((res>=0) && (pa->type == GF_HEVC_NALU_SEQ_PARAM)) { | |
| if (max_w < hvcc_state->sps[hvcc_state->last_parsed_sps_id].width) | |
| max_w = hvcc_state->sps[hvcc_state->last_parsed_sps_id].width; | |
| if (max_h < hvcc_state->sps[hvcc_state->last_parsed_sps_id].height) | |
| max_h = hvcc_state->sps[hvcc_state->last_parsed_sps_id].height; | |
| } | |
| if ((res>=0) && (pa->type==GF_HEVC_NALU_VID_PARAM)) { | |
| pctx->max_layers = hvcc_state->vps[hvcc_state->last_parsed_vps_id].max_layers; | |
| pctx->max_sublayers = hvcc_state->vps[hvcc_state->last_parsed_vps_id].max_sub_layers; | |
| } | |
| } | |
| if (vvcc_state) { | |
| u8 ntype, tid, lid; | |
| s32 res = gf_vvc_parse_nalu(nal->data, nal->size, vvcc_state, &ntype, &tid, &lid); | |
| if ((res>=0) && (pa->type == GF_VVC_NALU_SEQ_PARAM)) { | |
| if (max_w < vvcc_state->sps[vvcc_state->last_parsed_sps_id].width) | |
| max_w = vvcc_state->sps[vvcc_state->last_parsed_sps_id].width; | |
| if (max_h < vvcc_state->sps[vvcc_state->last_parsed_sps_id].height) | |
| max_h = vvcc_state->sps[vvcc_state->last_parsed_sps_id].height; | |
| } | |
| if ((res>=0) && (pa->type==GF_VVC_NALU_VID_PARAM)) { | |
| pctx->max_layers = vvcc_state->vps[vvcc_state->last_parsed_vps_id].max_layers; | |
| pctx->max_sublayers = vvcc_state->vps[vvcc_state->last_parsed_vps_id].max_sub_layers; | |
| } | |
| } | |
| #endif | |
| if (pa_out == NULL) { | |
| GF_SAFEALLOC(pa_out, GF_NALUFFParamArray); | |
| if (pa_out) pa_out->nalus = gf_list_new(); | |
| if (!pa_out || !pa_out->nalus) { | |
| if (pa_out) gf_free(pa_out); | |
| e = GF_OUT_OF_MEM; | |
| break; | |
| } | |
| pa_out->type = pa->type; | |
| pa_out->array_completeness = pa->array_completeness; | |
| gf_list_add(out_param_array, pa_out); | |
| } | |
| gf_list_add(pa_out->nalus, nal); | |
| } | |
| if (e) break; | |
| } | |
| if (e) { | |
| if (vvcc) vvcc->param_array = orig_pa_list; | |
| else hvcc->param_array = orig_pa_list; | |
| break; | |
| } | |
| if (vvcc) | |
| gf_odf_vvc_cfg_write(vvcc, &dsi, &dsi_size); | |
| else | |
| gf_odf_hevc_cfg_write(hvcc, &dsi, &dsi_size); | |
| if (max_w && max_h) { | |
| c_opid->width = max_w; | |
| c_opid->height = max_h; | |
| } | |
| bs_split_copy_props_base(ctx, c_opid, pctx->ipid, 0); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DECODER_CONFIG, &PROP_DATA_NO_COPY(dsi, dsi_size) ); | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT, NULL ); | |
| if (is_vvc) { | |
| } else { | |
| if (hvcc->is_lhvc) { | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_LHVC) ); | |
| } else { | |
| gf_filter_pid_set_property(c_opid->opid, GF_PROP_PID_CODECID, &PROP_UINT(GF_CODECID_HEVC) ); | |
| } | |
| bs_split_update_hevc_linf(pctx, c_opid); | |
| } | |
| count2 = gf_list_count(out_param_array); | |
| for (j=0; j<count2; j++) { | |
| GF_NALUFFParamArray *pa = gf_list_get(out_param_array, j); | |
| gf_list_del(pa->nalus); | |
| gf_free(pa); | |
| } | |
| gf_list_del(out_param_array); | |
| if (vvcc) vvcc->param_array = orig_pa_list; | |
| else if (hvcc) hvcc->param_array = orig_pa_list; | |
| } | |
| #ifndef GPAC_DISABLE_AV_PARSERS | |
| if (hvcc_state) gf_free(hvcc_state); | |
| if (vvcc_state) gf_free(vvcc_state); | |
| #endif | |
| if (vvcc) gf_odf_vvc_cfg_del(vvcc); | |
| if (hvcc) gf_odf_hevc_cfg_del(hvcc); | |
| return GF_OK; | |
| } | |
| static GF_Err none_rewrite_pid_config(BSSplitCtx *ctx, BSSplitIn *pctx) | |
| { | |
| u32 i, count; | |
| count = gf_list_count(pctx->opids); | |
| for (i=0; i<count; i++) { | |
| BSSplitOut *c_opid = gf_list_get(pctx->opids, i); | |
| gf_filter_pid_copy_properties(c_opid->opid, pctx->ipid); | |
| } | |
| return GF_OK; | |
| } | |
| static GF_Err none_split_packet(BSSplitCtx *ctx, BSSplitIn *pctx, GF_FilterPacket *pck) | |
| { | |
| BSSplitOut *c_opid = gf_list_get(pctx->opids, 0); | |
| if (c_opid) | |
| return gf_filter_pck_forward(pck, c_opid->opid); | |
| return GF_OK; | |
| } | |
| static GF_Err nalu_split_packet(BSSplitCtx *ctx, BSSplitIn *pctx, GF_FilterPacket *pck, u32 codec_type) | |
| { | |
| u32 size, pck_size, min_nal_size; | |
| GF_Err e = GF_OK; | |
| u64 pck_ts; | |
| Bool has_svc_prefix = GF_FALSE; | |
| const u8 *data = gf_filter_pck_get_data(pck, &pck_size); | |
| if (!data) { | |
| BSSplitOut *c_opid = gf_list_get(pctx->opids, 0); | |
| if (c_opid) | |
| return gf_filter_pck_forward(pck, c_opid->opid); | |
| return GF_OK; | |
| } | |
| pck_ts = gf_filter_pck_get_dts(pck); | |
| if (pck_ts == GF_FILTER_NO_TS) | |
| pck_ts = gf_filter_pck_get_cts(pck); | |
| if (pck_ts == GF_FILTER_NO_TS) | |
| pck_ts = 0; | |
| if (!pctx->first_ts_plus_one) { | |
| pctx->first_ts_plus_one = pck_ts+1; | |
| } | |
| min_nal_size = codec_type ? 2 : 1; | |
| size=0; | |
| while (size<pck_size) { | |
| Bool force_dv = GF_FALSE; | |
| u32 nal_type=0; | |
| u32 layer_id = 0; | |
| u32 temporal_id = 0; | |
| u32 nal_hdr = pctx->nalu_size_length; | |
| u32 nal_size = 0; | |
| while (nal_hdr) { | |
| nal_size |= data[size]; | |
| size++; | |
| nal_hdr--; | |
| if (!nal_hdr) break; | |
| nal_size<<=8; | |
| } | |
| if (size + nal_size > pck_size) { | |
| GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[BSSplit] Invalid NAL size %d but remain %d\n", nal_size, pck_size-size)); | |
| e = GF_NON_COMPLIANT_BITSTREAM; | |
| break; | |
| } | |
| if (nal_size < min_nal_size) { | |
| GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[BSSplit] Invalid NAL size %d but mn size %d\n", nal_size, min_nal_size)); | |
| e = GF_NON_COMPLIANT_BITSTREAM; | |
| break; | |
| } | |
| //AVC | |
| if (codec_type==0) { | |
| Bool get_dqid=GF_FALSE; | |
| gf_bs_reassign_buffer(pctx->r_bs, data+size, nal_size); | |
| gf_avc_parse_nalu(pctx->r_bs, pctx->avc_state); | |
| nal_type = pctx->avc_state->last_nal_type_parsed; | |
| temporal_id = 1; | |
| //remember we had an svc prefix | |
| if (nal_type == GF_AVC_NALU_SVC_PREFIX_NALU) { | |
| has_svc_prefix = GF_TRUE; | |
| } | |
| //if slice is scalable extension, get dqid | |
| else if ((nal_type == GF_AVC_NALU_SVC_SLICE) && pctx->avc_state->s_info.pps) { | |
| //svc prefix is no longer valid | |
| has_svc_prefix = GF_FALSE; | |
| get_dqid = GF_TRUE; | |
| } | |
| //don't forward extractors | |
| else if (nal_type == GF_AVC_NALU_FF_EXTRACTOR) { | |
| size += nal_size; | |
| continue; | |
| } | |
| //todo, find a way to differentiate between FF AVC aggregator and DV EL ... | |
| //if we had an svc prefix, get dqid | |
| if (has_svc_prefix) { | |
| get_dqid = GF_TRUE; | |
| } | |
| if (get_dqid) { | |
| if (ctx->svcqid) | |
| layer_id = pctx->avc_state->s_info.svc_nalhdr.quality_id; | |
| else | |
| layer_id = pctx->avc_state->s_info.svc_nalhdr.dependency_id; | |
| temporal_id = 1+pctx->avc_state->s_info.svc_nalhdr.temporal_id; | |
| } | |
| //force layerID 100 for DV | |
| if ((nal_type == GF_AVC_NALU_DV_RPU) || (nal_type == GF_AVC_NALU_DV_EL)) { | |
| layer_id = 100; | |
| force_dv = GF_TRUE; | |
| } | |
| } | |
| //HEVC | |
| else if (codec_type==1) { | |
| nal_type = (data[size] & 0x7E) >> 1; | |
| layer_id = data[size] & 1; | |
| layer_id <<= 5; | |
| layer_id |= (data[size+1] >> 3) & 0x1F; | |
| temporal_id = (data[size+1] & 0x7); | |
| //force layerID 100 for DV | |
| if ((nal_type == GF_HEVC_NALU_DV_RPU) || (nal_type == GF_HEVC_NALU_DV_EL)) { | |
| layer_id = 100; | |
| force_dv = GF_TRUE; | |
| } | |
| //don't forward extractors nor aggregators | |
| else if ((nal_type == GF_HEVC_NALU_FF_EXTRACTOR) || (nal_type == GF_HEVC_NALU_FF_AGGREGATOR)) { | |
| size += nal_size; | |
| continue; | |
| } | |
| } | |
| //VVC | |
| else if (codec_type==2) { | |
| layer_id = data[size] & 0x3F; | |
| temporal_id = data[size+1] & 0x7; | |
| nal_type = data[size+1] >> 3; | |
| } | |
| BSSplitOut *c_opid = bs_split_get_out_stream(ctx, pctx, GF_FALSE, layer_id, temporal_id, force_dv); | |
| if (!c_opid) { | |
| e = GF_OUT_OF_MEM; | |
| break; | |
| } | |
| u8 *out_data; | |
| if (!c_opid->is_init) { | |
| u64 ts_diff = pck_ts - (pctx->first_ts_plus_one-1); | |
| c_opid->is_init = GF_TRUE; | |
| //tsdiff not 0, we are starting a new split stream on a temporal sublayer, inject empty AU with a single NALU AU delim | |
| //we do so because we need to make sure the muxer will not screw up timing: | |
| //for mp4 not fragmented, not injecting will result in this sample (being the first) having dts=0 plus edit | |
| //which will unalign the tracks in terms of dts/ctts, which is what implicit reconstruction uses.... | |
| if (ts_diff) { | |
| u32 isize; | |
| u8 *idata; | |
| if (codec_type==1) isize=3; | |
| else if (codec_type==2) isize=3; | |
| else isize=2; | |
| GF_FilterPacket *inject_pck = gf_filter_pck_new_alloc(c_opid->opid, isize+pctx->nalu_size_length, &idata); | |
| if (!inject_pck) { | |
| e = GF_OUT_OF_MEM; | |
| break; | |
| } | |
| GF_BitStream *aud_bs = gf_bs_new(idata, isize+pctx->nalu_size_length, GF_BITSTREAM_WRITE); | |
| if (!aud_bs) { | |
| e = GF_OUT_OF_MEM; | |
| break; | |
| } | |
| gf_bs_write_int(aud_bs, isize, 8*pctx->nalu_size_length); | |
| if (codec_type==1) { | |
| gf_bs_write_int(aud_bs, 0, 1); | |
| gf_bs_write_int(aud_bs, GF_HEVC_NALU_ACCESS_UNIT, 6); | |
| gf_bs_write_int(aud_bs, layer_id, 6); | |
| gf_bs_write_int(aud_bs, temporal_id, 3); | |
| /*pic-type - by default we signal all slice types possible*/ | |
| gf_bs_write_int(aud_bs, 2, 3); | |
| gf_bs_write_int(aud_bs, 1, 1); //stop bit | |
| gf_bs_write_int(aud_bs, 0, 4); //4 bits to 0 | |
| } else if (codec_type==2) { | |
| gf_bs_write_int(aud_bs, 0, 1); | |
| gf_bs_write_int(aud_bs, 0, 1); | |
| gf_bs_write_int(aud_bs, layer_id, 6); | |
| gf_bs_write_int(aud_bs, GF_VVC_NALU_ACCESS_UNIT, 5); | |
| gf_bs_write_int(aud_bs, temporal_id, 3); | |
| gf_bs_write_int(aud_bs, 0, 1); | |
| /*pic-type - by default we signal all slice types possible*/ | |
| gf_bs_write_int(aud_bs, 2, 3); | |
| gf_bs_write_int(aud_bs, 1, 1); //stop bit | |
| gf_bs_write_int(aud_bs, 0, 3); //3 bits to 0 | |
| } else { | |
| gf_bs_write_int(aud_bs, (data[size] & 0x60) | GF_AVC_NALU_ACCESS_UNIT, 8); | |
| gf_bs_write_int(aud_bs, 0xF0 , 8); /*7 "all supported NALUs" (=111) + rbsp trailing (10000)*/; | |
| } | |
| gf_bs_del(aud_bs); | |
| gf_filter_pck_set_dts(inject_pck, pctx->first_ts_plus_one-1); | |
| gf_filter_pck_set_cts(inject_pck, pctx->first_ts_plus_one-1); | |
| gf_filter_pck_set_duration(inject_pck, (u32) ts_diff); | |
| gf_filter_pck_set_framing(inject_pck, GF_TRUE, GF_TRUE); | |
| gf_filter_pck_send(inject_pck); | |
| } | |
| } | |
| if (!c_opid->pck) { | |
| c_opid->pck = gf_filter_pck_new_alloc(c_opid->opid, nal_size+pctx->nalu_size_length, &out_data); | |
| if (!c_opid->pck) { | |
| e = GF_OUT_OF_MEM; | |
| break; | |
| } | |
| gf_filter_pck_merge_properties(pck, c_opid->pck); | |
| if (!c_opid->is_base) | |
| gf_filter_pck_set_sap(c_opid->pck, GF_FILTER_SAP_NONE); | |
| } else { | |
| e = gf_filter_pck_expand(c_opid->pck, nal_size+pctx->nalu_size_length, NULL, &out_data, NULL); | |
| if (e) break; | |
| } | |
| memcpy(out_data, data + size - pctx->nalu_size_length, nal_size+pctx->nalu_size_length); | |
| size += nal_size; | |
| } | |
| u32 i, count = gf_list_count(pctx->opids); | |
| for (i=0; i<count; i++) { | |
| BSSplitOut *c_opid = gf_list_get(pctx->opids, i); | |
| if (c_opid->pck) { | |
| gf_filter_pck_send(c_opid->pck); | |
| c_opid->pck = NULL; | |
| } | |
| } | |
| return e; | |
| } | |
| static GF_Err avc_split_packet(BSSplitCtx *ctx, BSSplitIn *pctx, GF_FilterPacket *pck) | |
| { | |
| return nalu_split_packet(ctx, pctx, pck, 0); | |
| } | |
| static GF_Err hevc_split_packet(BSSplitCtx *ctx, BSSplitIn *pctx, GF_FilterPacket *pck) | |
| { | |
| return nalu_split_packet(ctx, pctx, pck, 1); | |
| } | |
| static GF_Err vvc_split_packet(BSSplitCtx *ctx, BSSplitIn *pctx, GF_FilterPacket *pck) | |
| { | |
| return nalu_split_packet(ctx, pctx, pck, 2); | |
| } | |
| static void bs_split_reset_stream(GF_Filter *filter, BSSplitCtx *ctx, BSSplitIn *pctx, Bool is_finalize, Bool is_reconf) | |
| { | |
| if (!pctx) return; | |
| while (gf_list_count(pctx->opids)) { | |
| BSSplitOut *c_opid = gf_list_pop_back(pctx->opids); | |
| if (!is_finalize) | |
| gf_filter_pid_remove(c_opid->opid); | |
| bs_split_svcc_del(c_opid->svcc); | |
| gf_free(c_opid); | |
| } | |
| if (pctx->avcc) { | |
| gf_odf_avc_cfg_del(pctx->avcc); | |
| pctx->avcc = NULL; | |
| } | |
| if (pctx->svcc) { | |
| gf_odf_avc_cfg_del(pctx->svcc); | |
| pctx->svcc = NULL; | |
| } | |
| if (pctx->avc_state) { | |
| gf_free(pctx->avc_state); | |
| pctx->avc_state = NULL; | |
| } | |
| if (pctx->r_bs) { | |
| gf_bs_del(pctx->r_bs); | |
| pctx->r_bs = NULL; | |
| } | |
| if (is_reconf) | |
| return; | |
| gf_list_del_item(ctx->pids, pctx); | |
| gf_list_del(pctx->opids); | |
| gf_free(pctx); | |
| } | |
| static GF_Err bs_split_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove) | |
| { | |
| const GF_PropertyValue *prop; | |
| BSSplitCtx *ctx = (BSSplitCtx *) gf_filter_get_udta(filter); | |
| BSSplitIn *pctx = gf_filter_pid_get_udta(pid); | |
| //disconnect of src pid | |
| if (is_remove) { | |
| if (pctx) { | |
| bs_split_reset_stream(filter, ctx, pctx, GF_FALSE, GF_FALSE); | |
| gf_filter_pid_set_udta(pid, NULL); | |
| } | |
| return GF_OK; | |
| } | |
| if (! gf_filter_pid_check_caps(pid)) | |
| return GF_NOT_SUPPORTED; | |
| if (!pctx) { | |
| BSSplitOut *base_opid; | |
| GF_SAFEALLOC(pctx, BSSplitIn); | |
| if (!pctx) return GF_OUT_OF_MEM; | |
| GF_SAFEALLOC(base_opid, BSSplitOut); | |
| if (!base_opid) { | |
| gf_free(pctx); | |
| return GF_OUT_OF_MEM; | |
| } | |
| pctx->ipid = pid; | |
| pctx->opids = gf_list_new(); | |
| gf_list_add(pctx->opids, base_opid); | |
| gf_filter_pid_set_udta(pid, pctx); | |
| gf_list_add(ctx->pids, pctx); | |
| base_opid->opid = gf_filter_pid_new(filter); | |
| if (!base_opid->opid) return GF_OUT_OF_MEM; | |
| const GF_PropertyValue *p = gf_filter_pid_get_property(pctx->ipid, GF_PROP_PID_ID); | |
| base_opid->id = p ? p->value.uint : 1; | |
| } | |
| prop = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID); | |
| gf_fatal_assert(prop); | |
| switch (prop->value.uint) { | |
| case GF_CODECID_AVC: | |
| case GF_CODECID_SVC: | |
| case GF_CODECID_MVC: | |
| pctx->rewrite_pid_config = avc_rewrite_pid_config; | |
| pctx->split_packet = avc_split_packet; | |
| break; | |
| case GF_CODECID_HEVC: | |
| case GF_CODECID_LHVC: | |
| pctx->rewrite_pid_config = vvc_hevc_rewrite_pid_config; | |
| pctx->split_packet = hevc_split_packet; | |
| break; | |
| case GF_CODECID_VVC: | |
| pctx->rewrite_pid_config = vvc_hevc_rewrite_pid_config; | |
| pctx->split_packet = vvc_split_packet; | |
| break; | |
| default: | |
| pctx->rewrite_pid_config = none_rewrite_pid_config; | |
| pctx->split_packet = none_split_packet; | |
| break; | |
| } | |
| //change of codec, reset output | |
| if (pctx->codec_id && (pctx->codec_id != prop->value.uint)) { | |
| bs_split_reset_stream(filter, ctx, pctx, GF_FALSE, GF_TRUE); | |
| } | |
| pctx->codec_id = prop->value.uint; | |
| gf_filter_pid_set_framing_mode(pid, GF_TRUE); | |
| //rewrite asap - waiting for first packet could lead to issues further down the chain, especially for movie fragments | |
| //were the init segment could have already been flushed at the time we will dispatch the first packet | |
| return pctx->rewrite_pid_config(ctx, pctx); | |
| } | |
| static GF_Err bs_split_process(GF_Filter *filter) | |
| { | |
| u32 i, count; | |
| BSSplitCtx *ctx = (BSSplitCtx *) gf_filter_get_udta(filter); | |
| count = gf_filter_get_ipid_count(filter); | |
| for (i=0; i<count; i++) { | |
| BSSplitIn *pctx; | |
| GF_FilterPacket *pck; | |
| GF_FilterPid *pid = gf_filter_get_ipid(filter, i); | |
| if (!pid) break; | |
| pctx = gf_filter_pid_get_udta(pid); | |
| if (!pctx) break; | |
| while (1) { | |
| pck = gf_filter_pid_get_packet(pid); | |
| if (!pck) { | |
| if (gf_filter_pid_is_eos(pctx->ipid)) { | |
| for (u32 j=0; j<gf_list_count(pctx->opids); j++) { | |
| BSSplitOut *c_opid = gf_list_get(pctx->opids, j); | |
| gf_filter_pid_set_eos(c_opid->opid); | |
| } | |
| } | |
| break; | |
| } | |
| pctx->split_packet(ctx, pctx, pck); | |
| gf_filter_pid_drop_packet(pid); | |
| } | |
| } | |
| return GF_OK; | |
| } | |
| static GF_Err bs_split_initialize(GF_Filter *filter) | |
| { | |
| BSSplitCtx *ctx = (BSSplitCtx *) gf_filter_get_udta(filter); | |
| ctx->pids = gf_list_new(); | |
| ctx->filter = filter; | |
| return GF_OK; | |
| } | |
| static void bs_split_finalize(GF_Filter *filter) | |
| { | |
| BSSplitCtx *ctx = (BSSplitCtx *) gf_filter_get_udta(filter); | |
| while (gf_list_count(ctx->pids)) { | |
| BSSplitIn *pctx = gf_list_pop_back(ctx->pids); | |
| bs_split_reset_stream(filter, ctx, pctx, GF_TRUE, GF_FALSE); | |
| } | |
| gf_list_del(ctx->pids); | |
| } | |
| #define OFFS(_n) #_n, offsetof(BSSplitCtx, _n) | |
| static GF_FilterArgs BSSplitArgs[] = | |
| { | |
| { OFFS(ltid), "temporal and layer ID of output streams", GF_PROP_STRING_LIST, NULL, NULL, 0}, | |
| { OFFS(svcqid), "use qualityID instead of dependencyID for SVC splitting", GF_PROP_BOOL, "false", NULL, 0}, | |
| { OFFS(sig_ltid), "signal maximum temporal (`max_temporal_id`) and layer ID (`max_layer_id`) of output streams (mostly used for debug)", GF_PROP_BOOL, "false", NULL, 0}, | |
| {0} | |
| }; | |
| static const GF_FilterCapability BSSplitCaps[] = | |
| { | |
| //we want the filter to act as passthrough for other media, so we accept everything | |
| CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| 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_DEPENDENCY_ID, 0), | |
| CAP_UINT(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE), | |
| CAP_UINT(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_NONE), | |
| }; | |
| GF_FilterRegister BSSplitRegister = { | |
| .name = "bssplit", | |
| GF_FS_SET_DESCRIPTION("Layered bitstream splitter") | |
| GF_FS_SET_HELP("This filter splits input stream by layers and sublayers\n" | |
| "\n" | |
| "The filter supports AVC|H264, HEVC and VVC stream splitting and is pass-through for other codec types.\n" | |
| "\n" | |
| "Splitting is based on temporalID value (start from 1) and layerID value (start from 0).\n" | |
| "For AVC|H264, layerID is the dependency value, or quality value if `svcqid` is set.\n" | |
| "\n" | |
| "Each input stream is filtered according to the `ltid` option as follows:\n" | |
| "- no value set: input stream is split by layerID, i.e. each layer creates an output\n" | |
| "- `all`: input stream is split by layerID and temporalID, i.e. each {layerID,temporalID} creates an output\n" | |
| "- `lID`: input stream is split according to layer `lID` value, and temporalID is ignored\n" | |
| "- `.tID`: input stream is split according to temporal sub-layer `tID` value and layerID is ignored\n" | |
| "- `lID.tID`: input stream is split according to layer `lID` and sub-layer `tID` values\n" | |
| "\n" | |
| "Note: A tID value of 0 in `ltid` is equivalent to value 1.\n" | |
| "\n" | |
| "Multiple values can be given in `ltid`, in which case each value gives the maximum {layerID,temporalID} values for the current layer.\n" | |
| "A few examples on an input with 2 layers each with 2 temporal sublayers:\n" | |
| "- `ltid=0.2`: this will split the stream in:\n" | |
| " - one stream with {lID=0,tID=1} and {lID=0,tID=2} NAL units\n" | |
| " - one stream with all other layers/substreams\n" | |
| "- `ltid=0.1,1.1`: this will split the stream in:\n" | |
| " - one stream with {lID=0,tID=1} NAL units\n" | |
| " - one stream with {lID=0,tID=2}, {lID=1,tID=1} NAL units\n" | |
| " - one stream with the rest {lID=0,tID=2}, {lID=1,tID=2} NAL units\n" | |
| "- `ltid=0.1,0.2`: this will split the stream in:\n" | |
| " - one stream with {lID=0,tID=1} NAL units\n" | |
| " - one stream with {lID=0,tID=2} NAL units\n" | |
| " - one stream with the rest {lID=1,tID=1}, {lID=1,tID=2} NAL units\n" | |
| "\n" | |
| "The filter can also be used on AVC and HEVC DolbyVision streams to split base stream and DV RPU/EL.\n" | |
| "\n" | |
| "The filter does not create aggregator or extractor NAL units.\n" | |
| ) | |
| .private_size = sizeof(BSSplitCtx), | |
| .max_extra_pids = 0xFFFFFFFF, | |
| .flags = GF_FS_REG_EXPLICIT_ONLY|GF_FS_REG_ALLOW_CYCLIC, | |
| .args = BSSplitArgs, | |
| SETCAPS(BSSplitCaps), | |
| .initialize = bs_split_initialize, | |
| .finalize = bs_split_finalize, | |
| .configure_pid = bs_split_configure_pid, | |
| .process = bs_split_process, | |
| .hint_class_type = GF_FS_CLASS_STREAM | |
| }; | |
| #endif | |
| const GF_FilterRegister *bssplit_register(GF_FilterSession *session) | |
| { | |
| #if !defined(GPAC_DISABLE_AV_PARSERS) && !defined(GPAC_DISABLE_BSSPLIT) | |
| return (const GF_FilterRegister *) &BSSplitRegister; | |
| #else | |
| return NULL; | |
| #endif | |
| } |