struct Record* create_Record(const char* medium, const char* title) { struct Record* new_Record = safe_malloc( sizeof( struct Record ) ); new_Record->ID = Record_ID_counter++; new_Record->rating = 0; new_Record->title = alloc_and_copy( title ); new_Record->medium = alloc_and_copy( medium ); return new_Record; }
StrVec &operator=(const StrVec &rhs) { // *cxx-except-self-assign* auto vec = alloc_and_copy(rhs.begin(), rhs.end()); free(); element_ = vec.first; free_ = cap_ = vec.second; return *this; }
struct program_config * parse_command_line_parameters(int argc, char *argv[]) { struct program_config * options = (struct program_config *)malloc(sizeof(struct program_config)); options->address_mpd = NULL; options->ip_address = NULL; options->webdir = NULL; if (options == NULL) { return NULL; } //Init the options to defaults. options->address_mpd = alloc_and_copy(options->address_mpd, MPD_CONTROL_ADDR); options->mpd_port = MPD_CONTROL_PORT; int c; int digit_optind = 0; int aopt = 0, bopt = 0; char *copt = 0, *dopt = 0; static struct option long_options[] = { {"ip_address", optional_argument, 0, 'i'}, {"port", optional_argument, 0, 'p'}, {"webdir", optional_argument, 0, 'w'}, {"mpd_port", optional_argument, 0, 'm'}, {"address_mpd", optional_argument, 0, 'a'}, {"help", no_argument, 0, 'h'}, {NULL, 0, NULL, 0} }; int option_index = 0; while ((c = getopt_long(argc, argv, "i:w:m:a:p:h", long_options, &option_index)) != -1) { int this_option_optind = optind ? optind : 1; switch (c) { case 0: switch(option_index) { case 0: options->ip_address = alloc_and_copy(options->ip_address, optarg); break; case 1: options->port = atoi(optarg); break; case 2: options->webdir = alloc_and_copy(options->webdir, optarg); break; case 3: options->address_mpd = alloc_and_copy(options->address_mpd, optarg); break; case 4: options->mpd_port = atoi(optarg); break; case 5: show_help(); free_config(options); options=NULL; break; } break; case 'i': printf ("setting ip_address to %s\n", optarg); options->ip_address = alloc_and_copy(options->ip_address, optarg); break; case 'p': printf ("setting port to %s\n", optarg); options->port = atoi(optarg); break; case 'w': printf("Setting webdir to %s\n", optarg); options->webdir = alloc_and_copy(options->webdir, optarg); break; case 'a': printf ("Setting player_control_addr '%s'\n", optarg); options->address_mpd = alloc_and_copy(options->address_mpd, optarg); break; case 'm': printf ("Setting player_control_port '%s'\n", optarg); options->mpd_port = atoi(optarg); break; case 'h': case '?': show_help(); free_config(options); options=NULL; break; default: printf ("?? getopt returned character code 0%o ??\n", c); } } if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) printf ("%s ", argv[optind++]); printf ("\n"); } return options; }
static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int keyframe) { H264BSFContext *ctx = bsfc->priv_data; uint8_t unit_type; int32_t nal_size; uint32_t cumul_size = 0; const uint8_t *buf_end = buf + buf_size; /* nothing to filter */ if (!avctx->extradata || avctx->extradata_size < 6) { *poutbuf = (uint8_t *) buf; *poutbuf_size = buf_size; return 0; } /* retrieve sps and pps NAL units from extradata */ if (!ctx->extradata_parsed) { uint16_t unit_size; uint64_t total_size = 0; uint8_t *out = NULL, unit_nb, sps_done = 0, sps_seen = 0, pps_seen = 0; const uint8_t *extradata = avctx->extradata + 4; static const uint8_t nalu_header[4] = {0, 0, 0, 1}; /* retrieve length coded size */ ctx->length_size = (*extradata++ & 0x3) + 1; if (ctx->length_size == 3) return AVERROR(EINVAL); /* retrieve sps and pps unit(s) */ unit_nb = *extradata++ & 0x1f; /* number of sps unit(s) */ if (!unit_nb) { goto pps; } else { sps_seen = 1; } while (unit_nb--) { void *tmp; unit_size = AV_RB16(extradata); total_size += unit_size + 4; if (total_size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE || extradata + 2 + unit_size > avctx->extradata + avctx->extradata_size) { av_free(out); return AVERROR(EINVAL); } tmp = av_realloc(out, total_size + FF_INPUT_BUFFER_PADDING_SIZE); if (!tmp) { av_free(out); return AVERROR(ENOMEM); } out = tmp; memcpy(out + total_size - unit_size - 4, nalu_header, 4); memcpy(out + total_size - unit_size, extradata + 2, unit_size); extradata += 2 + unit_size; pps: if (!unit_nb && !sps_done++) { unit_nb = *extradata++; /* number of pps unit(s) */ if (unit_nb) pps_seen = 1; } } if(out) memset(out + total_size, 0, FF_INPUT_BUFFER_PADDING_SIZE); if (!sps_seen) av_log(avctx, AV_LOG_WARNING, "Warning: SPS NALU missing or invalid. The resulting stream may not play.\n"); if (!pps_seen) av_log(avctx, AV_LOG_WARNING, "Warning: PPS NALU missing or invalid. The resulting stream may not play.\n"); av_free(avctx->extradata); avctx->extradata = out; avctx->extradata_size = total_size; ctx->first_idr = 1; ctx->extradata_parsed = 1; } *poutbuf_size = 0; *poutbuf = NULL; do { if (buf + ctx->length_size > buf_end) goto fail; if (ctx->length_size == 1) { nal_size = buf[0]; } else if (ctx->length_size == 2) { nal_size = AV_RB16(buf); } else nal_size = AV_RB32(buf); buf += ctx->length_size; unit_type = *buf & 0x1f; if (buf + nal_size > buf_end || nal_size < 0) goto fail; /* prepend only to the first type 5 NAL unit of an IDR picture */ if (ctx->first_idr && unit_type == 5) { if (alloc_and_copy(poutbuf, poutbuf_size, avctx->extradata, avctx->extradata_size, buf, nal_size) < 0) goto fail; ctx->first_idr = 0; } else { if (alloc_and_copy(poutbuf, poutbuf_size, NULL, 0, buf, nal_size) < 0) goto fail; if (!ctx->first_idr && unit_type == 1) ctx->first_idr = 1; } buf += nal_size; cumul_size += nal_size + ctx->length_size; } while (cumul_size < buf_size); return 1; fail: av_freep(poutbuf); *poutbuf_size = 0; return AVERROR(EINVAL); }
// copy controls StrVec(const StrVec &rhs) { auto vec = alloc_and_copy(rhs.begin(), rhs.end()); element_ = vec.first; free_ = cap_ = vec.second; }
static int h264_mp4toannexb_filter(AVBSFContext *ctx, AVPacket *out) { H264BSFContext *s = ctx->priv_data; AVPacket *in; uint8_t unit_type; int32_t nal_size; uint32_t cumul_size = 0; const uint8_t *buf; const uint8_t *buf_end; int buf_size; int ret = 0, i; ret = ff_bsf_get_packet(ctx, &in); if (ret < 0) return ret; /* nothing to filter */ if (!s->extradata_parsed) { av_packet_move_ref(out, in); av_packet_free(&in); return 0; } buf = in->data; buf_size = in->size; buf_end = in->data + in->size; do { ret= AVERROR(EINVAL); if (buf + s->length_size > buf_end) goto fail; for (nal_size = 0, i = 0; i<s->length_size; i++) nal_size = (nal_size << 8) | buf[i]; buf += s->length_size; unit_type = *buf & 0x1f; if (nal_size > buf_end - buf || nal_size < 0) goto fail; if (unit_type == 7) s->idr_sps_seen = s->new_idr = 1; else if (unit_type == 8) { s->idr_pps_seen = s->new_idr = 1; /* if SPS has not been seen yet, prepend the AVCC one to PPS */ if (!s->idr_sps_seen) { if (s->sps_offset == -1) av_log(ctx, AV_LOG_WARNING, "SPS not present in the stream, nor in AVCC, stream may be unreadable\n"); else { if ((ret = alloc_and_copy(out, ctx->par_out->extradata + s->sps_offset, s->pps_offset != -1 ? s->pps_offset : ctx->par_out->extradata_size - s->sps_offset, buf, nal_size)) < 0) goto fail; s->idr_sps_seen = 1; goto next_nal; } } } /* if this is a new IDR picture following an IDR picture, reset the idr flag. * Just check first_mb_in_slice to be 0 as this is the simplest solution. * This could be checking idr_pic_id instead, but would complexify the parsing. */ if (!s->new_idr && unit_type == 5 && (buf[1] & 0x80)) s->new_idr = 1; /* prepend only to the first type 5 NAL unit of an IDR picture, if no sps/pps are already present */ if (s->new_idr && unit_type == 5 && !s->idr_sps_seen && !s->idr_pps_seen) { if ((ret=alloc_and_copy(out, ctx->par_out->extradata, ctx->par_out->extradata_size, buf, nal_size)) < 0) goto fail; s->new_idr = 0; /* if only SPS has been seen, also insert PPS */ } else if (s->new_idr && unit_type == 5 && s->idr_sps_seen && !s->idr_pps_seen) { if (s->pps_offset == -1) { av_log(ctx, AV_LOG_WARNING, "PPS not present in the stream, nor in AVCC, stream may be unreadable\n"); if ((ret = alloc_and_copy(out, NULL, 0, buf, nal_size)) < 0) goto fail; } else if ((ret = alloc_and_copy(out, ctx->par_out->extradata + s->pps_offset, ctx->par_out->extradata_size - s->pps_offset, buf, nal_size)) < 0) goto fail; } else { if ((ret=alloc_and_copy(out, NULL, 0, buf, nal_size)) < 0) goto fail; if (!s->new_idr && unit_type == 1) { s->new_idr = 1; s->idr_sps_seen = 0; s->idr_pps_seen = 0; } } next_nal: buf += nal_size; cumul_size += nal_size + s->length_size; } while (cumul_size < buf_size); ret = av_packet_copy_props(out, in); if (ret < 0) goto fail; fail: if (ret < 0) av_packet_unref(out); av_packet_free(&in); return ret; }
StrVec(std::initializer_list<std::string> il) { auto vec = alloc_and_copy(il.begin(), il.end()); element_ = vec.first; free_ = cap_ = vec.second; }
static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int keyframe) { H264BSFContext *ctx = bsfc->priv_data; uint8_t unit_type; uint32_t nal_size, cumul_size = 0; /* nothing to filter */ if (!avctx->extradata || avctx->extradata_size < 6) { *poutbuf = (uint8_t*) buf; *poutbuf_size = buf_size; return 0; } /* retrieve sps and pps NAL units from extradata */ if (!ctx->sps_pps_data) { uint16_t unit_size; uint32_t total_size = 0; uint8_t *out = NULL, unit_nb, sps_done = 0; const uint8_t *extradata = avctx->extradata+4; static const uint8_t nalu_header[4] = {0, 0, 0, 1}; /* retrieve length coded size */ ctx->length_size = (*extradata++ & 0x3) + 1; if (ctx->length_size == 3) return AVERROR(EINVAL); /* retrieve sps and pps unit(s) */ unit_nb = *extradata++ & 0x1f; /* number of sps unit(s) */ if (!unit_nb) { unit_nb = *extradata++; /* number of pps unit(s) */ sps_done++; } while (unit_nb--) { unit_size = AV_RB16(extradata); total_size += unit_size+4; if (extradata+2+unit_size > avctx->extradata+avctx->extradata_size) { av_free(out); return AVERROR(EINVAL); } out = av_realloc(out, total_size); if (!out) return AVERROR(ENOMEM); memcpy(out+total_size-unit_size-4, nalu_header, 4); memcpy(out+total_size-unit_size, extradata+2, unit_size); extradata += 2+unit_size; if (!unit_nb && !sps_done++) unit_nb = *extradata++; /* number of pps unit(s) */ } ctx->sps_pps_data = out; ctx->size = total_size; ctx->first_idr = 1; } *poutbuf_size = 0; *poutbuf = NULL; do { if (ctx->length_size == 1) nal_size = buf[0]; else if (ctx->length_size == 2) nal_size = AV_RB16(buf); else nal_size = AV_RB32(buf); buf += ctx->length_size; unit_type = *buf & 0x1f; /* prepend only to the first type 5 NAL unit of an IDR picture */ if (ctx->first_idr && unit_type == 5) { alloc_and_copy(poutbuf, poutbuf_size, ctx->sps_pps_data, ctx->size, buf, nal_size); ctx->first_idr = 0; } else { alloc_and_copy(poutbuf, poutbuf_size, NULL, 0, buf, nal_size); if (!ctx->first_idr && unit_type == 1) ctx->first_idr = 1; } buf += nal_size; cumul_size += nal_size + ctx->length_size; } while (cumul_size < buf_size); return 1; }
string(MakeCopy, char const* from, unsigned len) : val(alloc_and_copy(from, len)), length(len) { }
static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int keyframe) { H264BSFContext *ctx = bsfc->priv_data; int i; uint8_t unit_type; int32_t nal_size; uint32_t cumul_size = 0; const uint8_t *buf_end = buf + buf_size; int ret = 0; /* nothing to filter */ if (!avctx->extradata || avctx->extradata_size < 6) { *poutbuf = (uint8_t *)buf; *poutbuf_size = buf_size; return 0; } /* retrieve sps and pps NAL units from extradata */ if (!ctx->extradata_parsed) { if (args && strstr(args, "private_spspps_buf")) ctx->private_spspps = 1; ret = h264_extradata_to_annexb(ctx, avctx, AV_INPUT_BUFFER_PADDING_SIZE); if (ret < 0) return ret; ctx->length_size = ret; ctx->new_idr = 1; ctx->idr_sps_seen = 0; ctx->idr_pps_seen = 0; ctx->extradata_parsed = 1; } *poutbuf_size = 0; *poutbuf = NULL; do { ret= AVERROR(EINVAL); if (buf + ctx->length_size > buf_end) goto fail; for (nal_size = 0, i = 0; i<ctx->length_size; i++) nal_size = (nal_size << 8) | buf[i]; buf += ctx->length_size; unit_type = *buf & 0x1f; if (buf + nal_size > buf_end || nal_size < 0) goto fail; if (unit_type == 7) ctx->idr_sps_seen = ctx->new_idr = 1; else if (unit_type == 8) { ctx->idr_pps_seen = ctx->new_idr = 1; /* if SPS has not been seen yet, prepend the AVCC one to PPS */ if (!ctx->idr_sps_seen) { if (ctx->sps_offset == -1) av_log(avctx, AV_LOG_WARNING, "SPS not present in the stream, nor in AVCC, stream may be unreadable\n"); else { if ((ret = alloc_and_copy(poutbuf, poutbuf_size, ctx->spspps_buf + ctx->sps_offset, ctx->pps_offset != -1 ? ctx->pps_offset : ctx->spspps_size - ctx->sps_offset, buf, nal_size)) < 0) goto fail; ctx->idr_sps_seen = 1; goto next_nal; } } } /* if this is a new IDR picture following an IDR picture, reset the idr flag. * Just check first_mb_in_slice to be 0 as this is the simplest solution. * This could be checking idr_pic_id instead, but would complexify the parsing. */ if (!ctx->new_idr && unit_type == 5 && (buf[1] & 0x80)) ctx->new_idr = 1; /* prepend only to the first type 5 NAL unit of an IDR picture, if no sps/pps are already present */ if (ctx->new_idr && unit_type == 5 && !ctx->idr_sps_seen && !ctx->idr_pps_seen) { if ((ret=alloc_and_copy(poutbuf, poutbuf_size, ctx->spspps_buf, ctx->spspps_size, buf, nal_size)) < 0) goto fail; ctx->new_idr = 0; /* if only SPS has been seen, also insert PPS */ } else if (ctx->new_idr && unit_type == 5 && ctx->idr_sps_seen && !ctx->idr_pps_seen) { if (ctx->pps_offset == -1) { av_log(avctx, AV_LOG_WARNING, "PPS not present in the stream, nor in AVCC, stream may be unreadable\n"); if ((ret = alloc_and_copy(poutbuf, poutbuf_size, NULL, 0, buf, nal_size)) < 0) goto fail; } else if ((ret = alloc_and_copy(poutbuf, poutbuf_size, ctx->spspps_buf + ctx->pps_offset, ctx->spspps_size - ctx->pps_offset, buf, nal_size)) < 0) goto fail; } else { if ((ret=alloc_and_copy(poutbuf, poutbuf_size, NULL, 0, buf, nal_size)) < 0) goto fail; if (!ctx->new_idr && unit_type == 1) { ctx->new_idr = 1; ctx->idr_sps_seen = 0; ctx->idr_pps_seen = 0; } } next_nal: buf += nal_size; cumul_size += nal_size + ctx->length_size; } while (cumul_size < buf_size); return 1; fail: av_freep(poutbuf); *poutbuf_size = 0; return ret; }
static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int keyframe) { H264BSFContext *ctx = bsfc->priv_data; int i; uint8_t unit_type; int32_t nal_size; uint32_t cumul_size = 0; const uint8_t *buf_end = buf + buf_size; int ret = 0; /* nothing to filter */ if (!avctx->extradata || avctx->extradata_size < 6) { *poutbuf = (uint8_t *)buf; *poutbuf_size = buf_size; return 0; } /* retrieve sps and pps NAL units from extradata */ if (!ctx->extradata_parsed) { ret = h264_extradata_to_annexb(avctx, FF_INPUT_BUFFER_PADDING_SIZE); if (ret < 0) return ret; ctx->length_size = ret; ctx->first_idr = 1; ctx->extradata_parsed = 1; } *poutbuf_size = 0; *poutbuf = NULL; do { ret= AVERROR(EINVAL); if (buf + ctx->length_size > buf_end) goto fail; for (nal_size = 0, i = 0; i<ctx->length_size; i++) nal_size = (nal_size << 8) | buf[i]; buf += ctx->length_size; unit_type = *buf & 0x1f; if (buf + nal_size > buf_end || nal_size < 0) goto fail; /* prepend only to the first type 5 NAL unit of an IDR picture */ if (ctx->first_idr && unit_type == 5) { if ((ret=alloc_and_copy(poutbuf, poutbuf_size, avctx->extradata, avctx->extradata_size, buf, nal_size)) < 0) goto fail; ctx->first_idr = 0; } else { if ((ret=alloc_and_copy(poutbuf, poutbuf_size, NULL, 0, buf, nal_size)) < 0) goto fail; if (!ctx->first_idr && unit_type == 1) ctx->first_idr = 1; } buf += nal_size; cumul_size += nal_size + ctx->length_size; } while (cumul_size < buf_size); return 1; fail: av_freep(poutbuf); *poutbuf_size = 0; return ret; }
static int h264_mp4toannexb_filter(AVBSFContext *ctx, AVPacket *out) { H264BSFContext *s = ctx->priv_data; AVPacket *in; uint8_t unit_type; int32_t nal_size; uint32_t cumul_size = 0; const uint8_t *buf; const uint8_t *buf_end; int buf_size; int ret = 0; ret = ff_bsf_get_packet(ctx, &in); if (ret < 0) return ret; /* nothing to filter */ if (!s->extradata_parsed) { av_packet_move_ref(out, in); av_packet_free(&in); return 0; } buf = in->data; buf_size = in->size; buf_end = in->data + in->size; do { if (buf + s->length_size > buf_end) goto fail; if (s->length_size == 1) { nal_size = buf[0]; } else if (s->length_size == 2) { nal_size = AV_RB16(buf); } else nal_size = AV_RB32(buf); buf += s->length_size; unit_type = *buf & 0x1f; if (buf + nal_size > buf_end || nal_size < 0) goto fail; /* prepend only to the first type 5 NAL unit of an IDR picture */ if (s->first_idr && unit_type == 5) { if (alloc_and_copy(out, ctx->par_out->extradata, ctx->par_out->extradata_size, buf, nal_size) < 0) goto fail; s->first_idr = 0; } else { if (alloc_and_copy(out, NULL, 0, buf, nal_size) < 0) goto fail; if (!s->first_idr && unit_type == 1) s->first_idr = 1; } buf += nal_size; cumul_size += nal_size + s->length_size; } while (cumul_size < buf_size); ret = av_packet_copy_props(out, in); if (ret < 0) goto fail; fail: if (ret < 0) av_packet_unref(out); av_packet_free(&in); return ret; }