sigrid/ffmpeg

fftools/ffprobe.c+1−1

@@ -2158,7 +2158,7 @@ static void show_packet(WriterContext w, InputFile ifile, AVPacket *pkt, int p · 2157 unmodified lines
2158	pkt->flags & AV_PKT_FLAG_DISCARD ? 'D' : '_');	2158	pkt->flags & AV_PKT_FLAG_DISCARD ? 'D' : '_');
2159		2159
2160	if (pkt->side_data_elems) {	2160	if (pkt->side_data_elems) {
2161	int size;	2161	size_t size;
2162	const uint8_t *side_metadata;	2162	const uint8_t *side_metadata;
2163		2163
2164	side_metadata = av_packet_get_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA, &size);	2164	side_metadata = av_packet_get_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA, &size);

libavcodec/aacdec_template.c+2−2

@@ -3437,11 +3437,11 @@ static int aac_decode_frame(AVCodecContext avctx, void data, · 3436 unmodified lines
3437	int buf_consumed;	3437	int buf_consumed;
3438	int buf_offset;	3438	int buf_offset;
3439	int err;	3439	int err;
3440	buffer_size_t new_extradata_size;	3440	size_t new_extradata_size;
3441	const uint8_t *new_extradata = av_packet_get_side_data(avpkt,	3441	const uint8_t *new_extradata = av_packet_get_side_data(avpkt,
3442	AV_PKT_DATA_NEW_EXTRADATA,	3442	AV_PKT_DATA_NEW_EXTRADATA,
3443	&new_extradata_size);	3443	&new_extradata_size);
3444	buffer_size_t jp_dualmono_size;	3444	size_t jp_dualmono_size;
3445	const uint8_t *jp_dualmono = av_packet_get_side_data(avpkt,	3445	const uint8_t *jp_dualmono = av_packet_get_side_data(avpkt,
3446	AV_PKT_DATA_JP_DUALMONO,	3446	AV_PKT_DATA_JP_DUALMONO,
3447	&jp_dualmono_size);	3447	&jp_dualmono_size);

libavcodec/adxdec.c+1−1

@@ -103,7 +103,7 @@ static int adx_decode_frame(AVCodecContext avctx, void data, · 102 unmodified lines
103	const uint8_t *buf = avpkt->data;	103	const uint8_t *buf = avpkt->data;
104	const uint8_t *buf_end = buf + avpkt->size;	104	const uint8_t *buf_end = buf + avpkt->size;
105	int num_blocks, ch, ret;	105	int num_blocks, ch, ret;
106	buffer_size_t new_extradata_size;	106	size_t new_extradata_size;
107	uint8_t *new_extradata;	107	uint8_t *new_extradata;
108		108
109	new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,	109	new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,

libavcodec/audiotoolboxdec.c+1−1

@@ -484,7 +484,7 @@ static int ffat_decode(AVCodecContext avctx, void data, · 483 unmodified lines
484	if (avctx->codec_id == AV_CODEC_ID_AAC) {	484	if (avctx->codec_id == AV_CODEC_ID_AAC) {
485	if (!at->extradata_size) {	485	if (!at->extradata_size) {
486	uint8_t *side_data;	486	uint8_t *side_data;
487	buffer_size_t side_data_size;	487	size_t side_data_size;
488		488
489	side_data = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,	489	side_data = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
490	&side_data_size);	490	&side_data_size);

libavcodec/avpacket.c+6−22

 uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
-                                 buffer_size_t size)
+                                 size_t size)
 {
     int ret;
     uint8_t *data;
-#if FF_API_BUFFER_SIZE_T
-    if ((unsigned)size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
-#else
     if (size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
-#endif
         return NULL;
     data = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
     if (!data)
 }
 uint8_t *av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
-                                 buffer_size_t *size)
+                                 size_t *size)
 {
     int i;
     return NULL;
 }
-#if FF_API_BUFFER_SIZE_T
-uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size)
-#else
 uint8_t *av_packet_pack_dictionary(AVDictionary *dict, size_t *size)
-#endif
 {
     uint8_t *data = NULL;
     *size = 0;
                 if (pass)
                     memcpy(data + total_length, str, len);
-#if FF_API_BUFFER_SIZE_T
-                else if (len > INT_MAX - total_length)
-#else
                 else if (len > SIZE_MAX - total_length)
-#endif
                     return NULL;
                 total_length += len;
             }
     return data;
 }
-#if FF_API_BUFFER_SIZE_T
-int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict)
-#else
 int av_packet_unpack_dictionary(const uint8_t *data, size_t size,
                                 AVDictionary **dict)
-#endif
 {
     const uint8_t *end;
     int ret;
 }
 int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
-                               buffer_size_t size)
+                               size_t size)
 {
     int i;
     dst->side_data_elems      = 0;
     for (i = 0; i < src->side_data_elems; i++) {
         enum AVPacketSideDataType type = src->side_data[i].type;
-        buffer_size_t size = src->side_data[i].size;
+        size_t size = src->side_data[i].size;
         uint8_t *src_data = src->side_data[i].data;
         uint8_t *dst_data = av_packet_new_side_data(dst, type, size);
 int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
 {
     uint8_t *side_data;
-    buffer_size_t side_data_size;
+    size_t side_data_size;
     int i;
     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS, &side_data_size);
 {
     AVProducerReferenceTime *prft;
     uint8_t *side_data;
-    buffer_size_t side_data_size;
+    size_t side_data_size;
     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PRFT, &side_data_size);
     if (!side_data) {

libavcodec/cbs_bsf.c+1−1

@@ -24,7 +24,7 @@ static int cbs_bsf_update_side_data(AVBSFContext bsf, AVPacket pkt) · 23 unmodified lines
24	CBSBSFContext *ctx = bsf->priv_data;	24	CBSBSFContext *ctx = bsf->priv_data;
25	CodedBitstreamFragment *frag = &ctx->fragment;	25	CodedBitstreamFragment *frag = &ctx->fragment;
26	uint8_t *side_data;	26	uint8_t *side_data;
27	buffer_size_t side_data_size;	27	size_t side_data_size;
28	int err;	28	int err;
29		29
30	side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,	30	side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,

libavcodec/decode.c+7−6

 static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
 {
     int ret;
-    buffer_size_t size;
+    size_t size;
     const uint8_t *data;
     uint32_t flags;
     int64_t val;
             got_frame = 0;
     } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
         uint8_t *side;
-        buffer_size_t side_size;
+        size_t side_size;
         uint32_t discard_padding = 0;
         uint8_t skip_reason = 0;
         uint8_t discard_reason = 0;
 static int add_metadata_from_side_data(const AVPacket *avpkt, AVFrame *frame)
 {
-    buffer_size_t size;
+    size_t size;
     const uint8_t *side_metadata;
     AVDictionary **frame_md = &frame->metadata;
     frame->pkt_size     = pkt->size;
     for (int i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
-        buffer_size_t size;
+        size_t size;
         uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
         if (packet_sd) {
             AVFrameSideData *frame_sd = av_frame_new_side_data(frame,
 int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
 {
-    buffer_size_t size;
+    size_t size;
     const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size);
     if (pal && size == AVPALETTE_SIZE) {
         memcpy(dst, pal, AVPALETTE_SIZE);
         return 1;
     } else if (pal) {
-        av_log(logctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
+        av_log(logctx, AV_LOG_ERROR,
+               "Palette size %"SIZE_SPECIFIER" is wrong\n", size);
     }
     return 0;
 }

libavcodec/h264_metadata_bsf.c+1−1

@@ -371,7 +371,7 @@ static int h264_metadata_handle_display_orientation(AVBSFContext *bsf, · 370 unmodified lines
371	H264RawSEIDisplayOrientation *disp =	371	H264RawSEIDisplayOrientation *disp =
372	&ctx->display_orientation_payload;	372	&ctx->display_orientation_payload;
373	uint8_t *data;	373	uint8_t *data;
374	buffer_size_t size;	374	size_t size;
375	int write = 0;	375	int write = 0;
376		376
377	data = av_packet_get_side_data(pkt, AV_PKT_DATA_DISPLAYMATRIX, &size);	377	data = av_packet_get_side_data(pkt, AV_PKT_DATA_DISPLAYMATRIX, &size);

libavcodec/h264dec.c+1−1

@@ -975,7 +975,7 @@ static int h264_decode_frame(AVCodecContext avctx, void data, · 974 unmodified lines
975	return send_next_delayed_frame(h, pict, got_frame, 0);	975	return send_next_delayed_frame(h, pict, got_frame, 0);
976		976
977	if (av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) {	977	if (av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) {
978	buffer_size_t side_size;	978	size_t side_size;
979	uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);	979	uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
980	ff_h264_decode_extradata(side, side_size,	980	ff_h264_decode_extradata(side, side_size,
981	&h->ps, &h->is_avc, &h->nal_length_size,	981	&h->ps, &h->is_avc, &h->nal_length_size,

libavcodec/hevcdec.c+1−1

@@ -3303,7 +3303,7 @@ static int hevc_decode_frame(AVCodecContext avctx, void data, int *got_output, · 3302 unmodified lines
3303	AVPacket *avpkt)	3303	AVPacket *avpkt)
3304	{	3304	{
3305	int ret;	3305	int ret;
3306	buffer_size_t new_extradata_size;	3306	size_t new_extradata_size;
3307	uint8_t *new_extradata;	3307	uint8_t *new_extradata;
3308	HEVCContext *s = avctx->priv_data;	3308	HEVCContext *s = avctx->priv_data;
3309		3309

libavcodec/libvpxdec.c+1−1

@@ -221,7 +221,7 @@ static int vpx_decode(AVCodecContext *avctx, · 220 unmodified lines
221	struct vpx_image img, img_alpha;	221	struct vpx_image img, img_alpha;
222	int ret;	222	int ret;
223	uint8_t *side_data = NULL;	223	uint8_t *side_data = NULL;
224	buffer_size_t side_data_size;	224	size_t side_data_size;
225		225
226	ret = decode_frame(avctx, &ctx->decoder, avpkt->data, avpkt->size);	226	ret = decode_frame(avctx, &ctx->decoder, avpkt->data, avpkt->size);
227	if (ret)	227	if (ret)

libavcodec/mpeg12enc.c+2−2

@@ -575,8 +575,8 @@ void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) · 574 unmodified lines
575	put_bits(&s->pb, 8, 0xff); // marker_bits	575	put_bits(&s->pb, 8, 0xff); // marker_bits
576	} else {	576	} else {
577	av_log(s->avctx, AV_LOG_WARNING,	577	av_log(s->avctx, AV_LOG_WARNING,
578	"Warning Closed Caption size (%d) can not exceed 93 bytes "	578	"Closed Caption size (%"SIZE_SPECIFIER") can not exceed "
579	"and must be a multiple of 3\n", side_data->size);	579	"93 bytes and must be a multiple of 3\n", side_data->size);
580	}	580	}
581	}	581	}
582	}	582	}

libavcodec/mscc.c+3−2

     }
     if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
-        buffer_size_t size;
+        size_t size;
         const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
         if (pal && size == AVPALETTE_SIZE) {
             for (j = 0; j < 256; j++)
                 s->pal[j] = 0xFF000000 | AV_RL32(pal + j * 4);
         } else if (pal) {
-            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
+            av_log(avctx, AV_LOG_ERROR,
+                   "Palette size %"SIZE_SPECIFIER" is wrong\n", size);
         }
         memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);
     }

libavcodec/nvdec.c+2−2

@@ -242,7 +242,7 @@ fail: · 241 unmodified lines
242	return ret;	242	return ret;
243	}	243	}
244		244
245	static AVBufferRef nvdec_decoder_frame_alloc(void opaque, buffer_size_t size)	245	static AVBufferRef nvdec_decoder_frame_alloc(void opaque, size_t size)
246	{	246	{
247	NVDECFramePool *pool = opaque;	247	NVDECFramePool *pool = opaque;
248	AVBufferRef *ret;	248	AVBufferRef *ret;
@@ -283,7 +283,7 @@ static void nvdec_free_dummy(struct AVHWFramesContext *ctx) · 34 unmodified lines
283	av_buffer_pool_uninit(&ctx->pool);	283	av_buffer_pool_uninit(&ctx->pool);
284	}	284	}
285		285
286	static AVBufferRef *nvdec_alloc_dummy(buffer_size_t size)	286	static AVBufferRef *nvdec_alloc_dummy(size_t size)
287	{	287	{
288	return av_buffer_create(NULL, 0, NULL, NULL, 0);	288	return av_buffer_create(NULL, 0, NULL, NULL, 0);
289	}	289	}

libavcodec/packet.h+0−24

 typedef struct AVPacketSideData {
     uint8_t *data;
-#if FF_API_BUFFER_SIZE_T
-    int      size;
-#else
     size_t   size;
-#endif
     enum AVPacketSideDataType type;
 } AVPacketSideData;
  * @return pointer to fresh allocated data or NULL otherwise
  */
 uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
-#if FF_API_BUFFER_SIZE_T
-                                 int size);
-#else
                                  size_t size);
-#endif
 /**
  * Wrap an existing array as a packet side data.
  * @return 0 on success, < 0 on failure
  */
 int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
-#if FF_API_BUFFER_SIZE_T
-                               int size);
-#else
                                size_t size);
-#endif
 /**
  * Get side information from packet.
  * @return pointer to data if present or NULL otherwise
  */
 uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
-#if FF_API_BUFFER_SIZE_T
-                                 int *size);
-#else
                                  size_t *size);
-#endif
 const char *av_packet_side_data_name(enum AVPacketSideDataType type);
  * @param size pointer to store the size of the returned data
  * @return pointer to data if successful, NULL otherwise
  */
-#if FF_API_BUFFER_SIZE_T
-uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size);
-#else
 uint8_t *av_packet_pack_dictionary(AVDictionary *dict, size_t *size);
-#endif
 /**
  * Unpack a dictionary from side_data.
  *
  * @param dict the metadata storage dictionary
  * @return 0 on success, < 0 on failure
  */
-#if FF_API_BUFFER_SIZE_T
-int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict);
-#else
 int av_packet_unpack_dictionary(const uint8_t *data, size_t size,
                                 AVDictionary **dict);
-#endif
 /**
  * Convenience function to free all the side data stored.

libavcodec/srtdec.c+1−1

@@ -59,7 +59,7 @@ static int srt_decode_frame(AVCodecContext *avctx, · 58 unmodified lines
59	AVBPrint buffer;	59	AVBPrint buffer;
60	int x1 = -1, y1 = -1, x2 = -1, y2 = -1;	60	int x1 = -1, y1 = -1, x2 = -1, y2 = -1;
61	int ret;	61	int ret;
62	buffer_size_t size;	62	size_t size;
63	const uint8_t *p = av_packet_get_side_data(avpkt, AV_PKT_DATA_SUBTITLE_POSITION, &size);	63	const uint8_t *p = av_packet_get_side_data(avpkt, AV_PKT_DATA_SUBTITLE_POSITION, &size);
64	FFASSDecoderContext *s = avctx->priv_data;	64	FFASSDecoderContext *s = avctx->priv_data;
65		65

libavcodec/vaapi_encode.c+1−1

@@ -2235,7 +2235,7 @@ static void vaapi_encode_free_output_buffer(void *opaque, · 2234 unmodified lines
2235	}	2235	}
2236		2236
2237	static AVBufferRef vaapi_encode_alloc_output_buffer(void opaque,	2237	static AVBufferRef vaapi_encode_alloc_output_buffer(void opaque,
2238	buffer_size_t size)	2238	size_t size)
2239	{	2239	{
2240	AVCodecContext *avctx = opaque;	2240	AVCodecContext *avctx = opaque;
2241	VAAPIEncodeContext *ctx = avctx->priv_data;	2241	VAAPIEncodeContext *ctx = avctx->priv_data;

libavdevice/decklink_dec.cpp+2−2

@@ -936,7 +936,7 @@ HRESULT decklink_input_callback::VideoInputFrameArrived( · 935 unmodified lines
936	}	936	}
937		937
938	if (av_dict_set(&metadata_dict, "timecode", tc, 0) >= 0) {	938	if (av_dict_set(&metadata_dict, "timecode", tc, 0) >= 0) {
939	buffer_size_t metadata_len;	939	size_t metadata_len;
940	packed_metadata = av_packet_pack_dictionary(metadata_dict, &metadata_len);	940	packed_metadata = av_packet_pack_dictionary(metadata_dict, &metadata_len);
941	av_dict_free(&metadata_dict);	941	av_dict_free(&metadata_dict);
942	if (packed_metadata) {	942	if (packed_metadata) {
@@ -1435,7 +1435,7 @@ int ff_decklink_read_packet(AVFormatContext avctx, AVPacket pkt) · 492 unmodified lines
1435	avpacket_queue_get(&ctx->queue, pkt, 1);	1435	avpacket_queue_get(&ctx->queue, pkt, 1);
1436		1436
1437	if (ctx->tc_format && !(av_dict_get(ctx->video_st->metadata, "timecode", NULL, 0))) {	1437	if (ctx->tc_format && !(av_dict_get(ctx->video_st->metadata, "timecode", NULL, 0))) {
1438	buffer_size_t size;	1438	size_t size;
1439	const uint8_t *side_metadata = av_packet_get_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA, &size);	1439	const uint8_t *side_metadata = av_packet_get_side_data(pkt, AV_PKT_DATA_STRINGS_METADATA, &size);
1440	if (side_metadata) {	1440	if (side_metadata) {
1441	if (av_packet_unpack_dictionary(side_metadata, size, &ctx->video_st->metadata) < 0)	1441	if (av_packet_unpack_dictionary(side_metadata, size, &ctx->video_st->metadata) < 0)

libavdevice/decklink_enc.cpp+1−1

@@ -313,7 +313,7 @@ static void construct_cc(AVFormatContext avctx, struct decklink_ctx ctx, · 312 unmodified lines
313	uint16_t *cdp_words;	313	uint16_t *cdp_words;
314	uint16_t len;	314	uint16_t len;
315	uint8_t cc_count;	315	uint8_t cc_count;
316	buffer_size_t size;	316	size_t size;
317	int ret, i;	317	int ret, i;
318		318
319	const uint8_t *data = av_packet_get_side_data(pkt, AV_PKT_DATA_A53_CC, &size);	319	const uint8_t *data = av_packet_get_side_data(pkt, AV_PKT_DATA_A53_CC, &size);

libavdevice/lavfi.c+1−1

@@ -446,7 +446,7 @@ static int lavfi_read_packet(AVFormatContext avctx, AVPacket pkt) · 445 unmodified lines
446		446
447	frame_metadata = frame->metadata;	447	frame_metadata = frame->metadata;
448	if (frame_metadata) {	448	if (frame_metadata) {
449	buffer_size_t size;	449	size_t size;
450	uint8_t *metadata = av_packet_pack_dictionary(frame_metadata, &size);	450	uint8_t *metadata = av_packet_pack_dictionary(frame_metadata, &size);
451		451
452	if (!metadata) {	452	if (!metadata) {

libavdevice/xcbgrab.c+1−1

@@ -236,7 +236,7 @@ static void free_shm_buffer(void opaque, uint8_t data) · 235 unmodified lines
236	shmdt(data);	236	shmdt(data);
237	}	237	}
238		238
239	static AVBufferRef allocate_shm_buffer(void opaque, buffer_size_t size)	239	static AVBufferRef allocate_shm_buffer(void opaque, size_t size)
240	{	240	{
241	xcb_connection_t *conn = opaque;	241	xcb_connection_t *conn = opaque;
242	xcb_shm_seg_t segment;	242	xcb_shm_seg_t segment;

libavfilter/af_ashowinfo.c+2−1

@@ -170,7 +170,8 @@ static void dump_audio_service_type(AVFilterContext ctx, AVFrameSideData sd) · 169 unmodified lines
170		170
171	static void dump_unknown(AVFilterContext ctx, AVFrameSideData sd)	171	static void dump_unknown(AVFilterContext ctx, AVFrameSideData sd)
172	{	172	{
173	av_log(ctx, AV_LOG_INFO, "unknown side data type: %d, size %d bytes", sd->type, sd->size);	173	av_log(ctx, AV_LOG_INFO, "unknown side data type: %d, size "
		174	"%"SIZE_SPECIFIER" bytes", sd->type, sd->size);
174	}	175	}
175		176
176	static int filter_frame(AVFilterLink inlink, AVFrame buf)	177	static int filter_frame(AVFilterLink inlink, AVFrame buf)

libavfilter/framepool.c+2−2

@@ -48,7 +48,7 @@ struct FFFramePool { · 47 unmodified lines
48		48
49	};	49	};
50		50
51	FFFramePool ff_frame_pool_video_init(AVBufferRef (*alloc)(buffer_size_t size),	51	FFFramePool ff_frame_pool_video_init(AVBufferRef (*alloc)(size_t size),
52	int width,	52	int width,
53	int height,	53	int height,
54	enum AVPixelFormat format,	54	enum AVPixelFormat format,
@@ -115,7 +115,7 @@ fail: · 60 unmodified lines
115	return NULL;	115	return NULL;
116	}	116	}
117		117
118	FFFramePool ff_frame_pool_audio_init(AVBufferRef (*alloc)(buffer_size_t size),	118	FFFramePool ff_frame_pool_audio_init(AVBufferRef (*alloc)(size_t size),
119	int channels,	119	int channels,
120	int nb_samples,	120	int nb_samples,
121	enum AVSampleFormat format,	121	enum AVSampleFormat format,

libavfilter/framepool.h+2−2

@@ -44,7 +44,7 @@ typedef struct FFFramePool FFFramePool; · 43 unmodified lines
44	* @param align buffers alignement of each frame in this pool	44	* @param align buffers alignement of each frame in this pool
45	* @return newly created video frame pool on success, NULL on error.	45	* @return newly created video frame pool on success, NULL on error.
46	*/	46	*/
47	FFFramePool ff_frame_pool_video_init(AVBufferRef (*alloc)(buffer_size_t size),	47	FFFramePool ff_frame_pool_video_init(AVBufferRef (*alloc)(size_t size),
48	int width,	48	int width,
49	int height,	49	int height,
50	enum AVPixelFormat format,	50	enum AVPixelFormat format,
@@ -62,7 +62,7 @@ FFFramePool ff_frame_pool_video_init(AVBufferRef (*alloc)(buffer_size_t size), · 11 unmodified lines
62	* @param align buffers alignement of each frame in this pool	62	* @param align buffers alignement of each frame in this pool
63	* @return newly created audio frame pool on success, NULL on error.	63	* @return newly created audio frame pool on success, NULL on error.
64	*/	64	*/
65	FFFramePool ff_frame_pool_audio_init(AVBufferRef (*alloc)(buffer_size_t size),	65	FFFramePool ff_frame_pool_audio_init(AVBufferRef (*alloc)(size_t size),
66	int channels,	66	int channels,
67	int samples,	67	int samples,
68	enum AVSampleFormat format,	68	enum AVSampleFormat format,

libavfilter/vf_showinfo.c+6−4

     int i;
     if (sd->size < uuid_size) {
-        av_log(ctx, AV_LOG_ERROR, "invalid data(%d < UUID(%d-bytes))\n", sd->size, uuid_size);
+        av_log(ctx, AV_LOG_ERROR, "invalid data(%"SIZE_SPECIFIER" < "
+               "UUID(%d-bytes))\n", sd->size, uuid_size);
         return;
     }
             av_log(ctx, AV_LOG_INFO, "pan/scan");
             break;
         case AV_FRAME_DATA_A53_CC:
-            av_log(ctx, AV_LOG_INFO, "A/53 closed captions (%d bytes)", sd->size);
+            av_log(ctx, AV_LOG_INFO, "A/53 closed captions "
+                   "(%"SIZE_SPECIFIER" bytes)", sd->size);
             break;
         case AV_FRAME_DATA_SPHERICAL:
             dump_spherical(ctx, frame, sd);
             dump_sei_unregistered_metadata(ctx, sd);
             break;
         default:
-            av_log(ctx, AV_LOG_WARNING, "unknown side data type %d (%d bytes)\n",
+            av_log(ctx, AV_LOG_WARNING, "unknown side data type %d "
-                   sd->type, sd->size);
+                   "(%"SIZE_SPECIFIER" bytes)\n", sd->type, sd->size);
             break;
         }

libavformat/adtsenc.c+1−1

@@ -170,7 +170,7 @@ static int adts_write_packet(AVFormatContext s, AVPacket pkt) · 169 unmodified lines
170	return 0;	170	return 0;
171	if (!par->extradata_size) {	171	if (!par->extradata_size) {
172	uint8_t *side_data;	172	uint8_t *side_data;
173	buffer_size_t side_data_size;	173	size_t side_data_size;
174	int ret;	174	int ret;
175		175
176	side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,	176	side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,

libavformat/apngenc.c+1−1

@@ -119,7 +119,7 @@ static int flush_packet(AVFormatContext format_context, AVPacket packet) · 118 unmodified lines
119	AVIOContext *io_context = format_context->pb;	119	AVIOContext *io_context = format_context->pb;
120	AVStream *codec_stream = format_context->streams[0];	120	AVStream *codec_stream = format_context->streams[0];
121	uint8_t *side_data = NULL;	121	uint8_t *side_data = NULL;
122	buffer_size_t side_data_size;	122	size_t side_data_size;
123		123
124	av_assert0(apng->prev_packet);	124	av_assert0(apng->prev_packet);
125		125

libavformat/avformat.h+0−8

  * @return pointer to fresh allocated data or NULL otherwise
  */
 uint8_t *av_stream_new_side_data(AVStream *stream,
-#if FF_API_BUFFER_SIZE_T
-                                 enum AVPacketSideDataType type, int size);
-#else
                                  enum AVPacketSideDataType type, size_t size);
-#endif
 /**
  * Get side information from stream.
  *
  * @return pointer to data if present or NULL otherwise
  */
 uint8_t *av_stream_get_side_data(const AVStream *stream,
-#if FF_API_BUFFER_SIZE_T
-                                 enum AVPacketSideDataType type, int *size);
-#else
                                  enum AVPacketSideDataType type, size_t *size);
-#endif
 AVProgram *av_new_program(AVFormatContext *s, int id);

libavformat/concatdec.c+1−1

@@ -626,7 +626,7 @@ static int concat_read_packet(AVFormatContext avf, AVPacket pkt) · 625 unmodified lines
626	av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),	626	av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),
627	av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &st->time_base));	627	av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &st->time_base));
628	if (cat->cur_file->metadata) {	628	if (cat->cur_file->metadata) {
629	buffer_size_t metadata_len;	629	size_t metadata_len;
630	char* packed_metadata = av_packet_pack_dictionary(cat->cur_file->metadata, &metadata_len);	630	char* packed_metadata = av_packet_pack_dictionary(cat->cur_file->metadata, &metadata_len);
631	if (!packed_metadata)	631	if (!packed_metadata)
632	return AVERROR(ENOMEM);	632	return AVERROR(ENOMEM);

libavformat/dashenc.c+2−2

@@ -1806,7 +1806,7 @@ static int update_stream_extradata(AVFormatContext s, OutputStream os, · 1805 unmodified lines
1806	{	1806	{
1807	AVCodecParameters *par = os->ctx->streams[0]->codecpar;	1807	AVCodecParameters *par = os->ctx->streams[0]->codecpar;
1808	uint8_t *extradata;	1808	uint8_t *extradata;
1809	buffer_size_t extradata_size;	1809	size_t extradata_size;
1810	int ret;	1810	int ret;
1811		1811
1812	if (par->extradata_size)	1812	if (par->extradata_size)
@@ -2022,7 +2022,7 @@ static int dash_parse_prft(DASHContext c, AVPacket pkt) · 209 unmodified lines
2022	{	2022	{
2023	OutputStream *os = &c->streams[pkt->stream_index];	2023	OutputStream *os = &c->streams[pkt->stream_index];
2024	AVProducerReferenceTime *prft;	2024	AVProducerReferenceTime *prft;
2025	buffer_size_t side_data_size;	2025	size_t side_data_size;
2026		2026
2027	prft = (AVProducerReferenceTime *)av_packet_get_side_data(pkt, AV_PKT_DATA_PRFT, &side_data_size);	2027	prft = (AVProducerReferenceTime *)av_packet_get_side_data(pkt, AV_PKT_DATA_PRFT, &side_data_size);
2028	if (!prft \|\| side_data_size != sizeof(AVProducerReferenceTime) \|\| (prft->flags && prft->flags != 24)) {	2028	if (!prft \|\| side_data_size != sizeof(AVProducerReferenceTime) \|\| (prft->flags && prft->flags != 24)) {

libavformat/dump.c+2−2

@@ -491,8 +491,8 @@ static void dump_sidedata(void ctx, const AVStream st, const char *indent) · 490 unmodified lines
491	dump_s12m_timecode(ctx, st, sd);	491	dump_s12m_timecode(ctx, st, sd);
492	break;	492	break;
493	default:	493	default:
494	av_log(ctx, AV_LOG_INFO,	494	av_log(ctx, AV_LOG_INFO, "unknown side data type %d "
495	"unknown side data type %d (%d bytes)", sd->type, sd->size);	495	"(%"SIZE_SPECIFIER" bytes)", sd->type, sd->size);
496	break;	496	break;
497	}	497	}
498		498

libavformat/flacenc.c+1−1

@@ -280,7 +280,7 @@ static int flac_write_audio_packet(struct AVFormatContext s, AVPacket pkt) · 279 unmodified lines
280	{	280	{
281	FlacMuxerContext *c = s->priv_data;	281	FlacMuxerContext *c = s->priv_data;
282	uint8_t *streaminfo;	282	uint8_t *streaminfo;
283	buffer_size_t streaminfo_size;	283	size_t streaminfo_size;
284		284
285	/* check for updated streaminfo */	285	/* check for updated streaminfo */
286	streaminfo = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,	286	streaminfo = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,

libavformat/flvenc.c+1−1

@@ -902,7 +902,7 @@ static int flv_write_packet(AVFormatContext s, AVPacket pkt) · 901 unmodified lines
902		902
903	if (par->codec_id == AV_CODEC_ID_AAC \|\| par->codec_id == AV_CODEC_ID_H264	903	if (par->codec_id == AV_CODEC_ID_AAC \|\| par->codec_id == AV_CODEC_ID_H264
904	\|\| par->codec_id == AV_CODEC_ID_MPEG4) {	904	\|\| par->codec_id == AV_CODEC_ID_MPEG4) {
905	buffer_size_t side_size;	905	size_t side_size;
906	uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);	906	uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
907	if (side && side_size > 0 && (side_size != par->extradata_size \|\| memcmp(side, par->extradata, side_size))) {	907	if (side && side_size > 0 && (side_size != par->extradata_size \|\| memcmp(side, par->extradata, side_size))) {
908	ret = ff_alloc_extradata(par, side_size);	908	ret = ff_alloc_extradata(par, side_size);

libavformat/framecrcenc.c+4−2

@@ -88,7 +88,7 @@ static int framecrc_write_packet(struct AVFormatContext s, AVPacket pkt) · 87 unmodified lines
88	case AV_PKT_DATA_SPHERICAL:	88	case AV_PKT_DATA_SPHERICAL:
89	case AV_PKT_DATA_CONTENT_LIGHT_LEVEL:	89	case AV_PKT_DATA_CONTENT_LIGHT_LEVEL:
90	case AV_PKT_DATA_S12M_TIMECODE:	90	case AV_PKT_DATA_S12M_TIMECODE:
91	for (int j = 0; j < sd->size / 4; j++) {	91	for (size_t j = 0; j < sd->size / 4; j++) {
92	uint8_t buf[4];	92	uint8_t buf[4];
93	AV_WL32(buf, AV_RB32(sd->data + 4 * j));	93	AV_WL32(buf, AV_RB32(sd->data + 4 * j));
94	side_data_crc = av_adler32_update(side_data_crc, buf, 4);	94	side_data_crc = av_adler32_update(side_data_crc, buf, 4);
@@ -119,7 +119,9 @@ static int framecrc_write_packet(struct AVFormatContext s, AVPacket pkt) · 24 unmodified lines
119	default:	119	default:
120	side_data_crc = av_adler32_update(0, data, sd->size);	120	side_data_crc = av_adler32_update(0, data, sd->size);
121	}	121	}
122	av_strlcatf(buf, sizeof(buf), ", %8d, 0x%08"PRIx32, pkt->side_data[i].size, side_data_crc);	122
		123	av_strlcatf(buf, sizeof(buf), ", %8"SIZE_SPECIFIER", 0x%08"PRIx32,
		124	pkt->side_data[i].size, side_data_crc);
123	}	125	}
124	}	126	}
125	av_strlcatf(buf, sizeof(buf), "\n");	127	av_strlcatf(buf, sizeof(buf), "\n");

libavformat/hashenc.c+4−3

     avio_write(s->pb, buf, strlen(buf));
     if (c->format_version > 1 && pkt->side_data_elems) {
-        int i, j;
+        int i;
         avio_printf(s->pb, ", S=%d", pkt->side_data_elems);
         for (i = 0; i < pkt->side_data_elems; i++) {
             av_hash_init(c->hashes[0]);
             if (HAVE_BIGENDIAN && pkt->side_data[i].type == AV_PKT_DATA_PALETTE) {
-                for (j = 0; j < pkt->side_data[i].size; j += sizeof(uint32_t)) {
+                for (size_t j = 0; j < pkt->side_data[i].size; j += sizeof(uint32_t)) {
                     uint32_t data = AV_RL32(pkt->side_data[i].data + j);
                     av_hash_update(c->hashes[0], (uint8_t *)&data, sizeof(uint32_t));
                 }
             } else
                 av_hash_update(c->hashes[0], pkt->side_data[i].data, pkt->side_data[i].size);
-            snprintf(buf, sizeof(buf) - (AV_HASH_MAX_SIZE * 2 + 1), ", %8d, ", pkt->side_data[i].size);
+            snprintf(buf, sizeof(buf) - (AV_HASH_MAX_SIZE * 2 + 1),
+                     ", %8"SIZE_SPECIFIER", ", pkt->side_data[i].size);
             len = strlen(buf);
             av_hash_final_hex(c->hashes[0], buf + len, sizeof(buf) - len);
             avio_write(s->pb, buf, strlen(buf));

libavformat/img2dec.c+1−1

@@ -383,7 +383,7 @@ int ff_img_read_header(AVFormatContext *s1) · 382 unmodified lines
383	static int add_filename_as_pkt_side_data(char filename, AVPacket pkt) {	383	static int add_filename_as_pkt_side_data(char filename, AVPacket pkt) {
384	AVDictionary *d = NULL;	384	AVDictionary *d = NULL;
385	char *packed_metadata = NULL;	385	char *packed_metadata = NULL;
386	buffer_size_t metadata_len;	386	size_t metadata_len;
387	int ret;	387	int ret;
388		388
389	av_dict_set(&d, "lavf.image2dec.source_path", filename, 0);	389	av_dict_set(&d, "lavf.image2dec.source_path", filename, 0);

libavformat/latmenc.c+1−1

@@ -176,7 +176,7 @@ static int latm_write_packet(AVFormatContext s, AVPacket pkt) · 175 unmodified lines
176	return ff_raw_write_packet(s, pkt);	176	return ff_raw_write_packet(s, pkt);
177	else {	177	else {
178	uint8_t *side_data;	178	uint8_t *side_data;
179	buffer_size_t side_data_size;	179	size_t side_data_size;
180	int ret;	180	int ret;
181		181
182	side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,	182	side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,

libavformat/matroskaenc.c+3−3

@@ -2030,7 +2030,7 @@ static int mkv_write_block(AVFormatContext s, AVIOContext pb, · 2029 unmodified lines
2030	AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;	2030	AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
2031	mkv_track *track = &mkv->tracks[pkt->stream_index];	2031	mkv_track *track = &mkv->tracks[pkt->stream_index];
2032	uint8_t data = NULL, side_data = NULL;	2032	uint8_t data = NULL, side_data = NULL;
2033	buffer_size_t side_data_size;	2033	size_t side_data_size;
2034	int err = 0, offset = 0, size = pkt->size;	2034	int err = 0, offset = 0, size = pkt->size;
2035	int64_t ts = track->write_dts ? pkt->dts : pkt->pts;	2035	int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
2036	uint64_t additional_id;	2036	uint64_t additional_id;
@@ -2141,7 +2141,7 @@ static int mkv_write_vtt_blocks(AVFormatContext s, AVIOContext pb, const AVPac · 104 unmodified lines
2141	MatroskaMuxContext *mkv = s->priv_data;	2141	MatroskaMuxContext *mkv = s->priv_data;
2142	mkv_track *track = &mkv->tracks[pkt->stream_index];	2142	mkv_track *track = &mkv->tracks[pkt->stream_index];
2143	ebml_master blockgroup;	2143	ebml_master blockgroup;
2144	buffer_size_t id_size, settings_size;	2144	size_t id_size, settings_size;
2145	int size, id_size_int, settings_size_int;	2145	int size, id_size_int, settings_size_int;
2146	const char id, settings;	2146	const char id, settings;
2147	int64_t ts = track->write_dts ? pkt->dts : pkt->pts;	2147	int64_t ts = track->write_dts ? pkt->dts : pkt->pts;
@@ -2214,7 +2214,7 @@ static int mkv_check_new_extra_data(AVFormatContext s, const AVPacket pkt) · 66 unmodified lines
2214	mkv_track *track = &mkv->tracks[pkt->stream_index];	2214	mkv_track *track = &mkv->tracks[pkt->stream_index];
2215	AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;	2215	AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
2216	uint8_t *side_data;	2216	uint8_t *side_data;
2217	buffer_size_t side_data_size;	2217	size_t side_data_size;
2218	int ret;	2218	int ret;
2219		2219
2220	side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,	2220	side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,

libavformat/mov.c+1−2

@@ -6364,8 +6364,7 @@ static int mov_read_pssh(MOVContext c, AVIOContext pb, MOVAtom atom) · 6363 unmodified lines
6364	uint8_t **key_ids;	6364	uint8_t **key_ids;
6365	AVStream *st;	6365	AVStream *st;
6366	uint8_t side_data, extra_data, *old_side_data;	6366	uint8_t side_data, extra_data, *old_side_data;
6367	size_t side_data_size;	6367	size_t side_data_size, old_side_data_size;
6368	buffer_size_t old_side_data_size;
6369	int ret = 0;	6368	int ret = 0;
6370	unsigned int version, kid_count, extra_data_size, alloc_size = 0;	6369	unsigned int version, kid_count, extra_data_size, alloc_size = 0;
6371		6370

libavformat/movenc.c+5−5

@@ -1992,7 +1992,7 @@ static int mov_write_colr_tag(AVIOContext pb, MOVTrack track, int prefer_icc) · 1991 unmodified lines
1992	// Ref (MP4): ISO/IEC 14496-12:2012	1992	// Ref (MP4): ISO/IEC 14496-12:2012
1993		1993
1994	const uint8_t *icc_profile;	1994	const uint8_t *icc_profile;
1995	buffer_size_t icc_profile_size;	1995	size_t icc_profile_size;
1996		1996
1997	if (prefer_icc) {	1997	if (prefer_icc) {
1998	icc_profile = av_stream_get_side_data(track->st, AV_PKT_DATA_ICC_PROFILE, &icc_profile_size);	1998	icc_profile = av_stream_get_side_data(track->st, AV_PKT_DATA_ICC_PROFILE, &icc_profile_size);
@@ -3046,7 +3046,7 @@ static int mov_write_tkhd_tag(AVIOContext pb, MOVMuxContext mov, · 1047 unmodified lines
3046	int group = 0;	3046	int group = 0;
3047		3047
3048	uint32_t *display_matrix = NULL;	3048	uint32_t *display_matrix = NULL;
3049	buffer_size_t display_matrix_size;	3049	size_t display_matrix_size;
3050	int i;	3050	int i;
3051		3051
3052	if (st) {	3052	if (st) {
@@ -4173,7 +4173,7 @@ static int mov_write_moov_tag(AVIOContext pb, MOVMuxContext mov, · 1120 unmodified lines
4173	track->tref_tag = MKTAG('h','i','n','t');	4173	track->tref_tag = MKTAG('h','i','n','t');
4174	track->tref_id = mov->tracks[track->src_track].track_id;	4174	track->tref_id = mov->tracks[track->src_track].track_id;
4175	} else if (track->par->codec_type == AVMEDIA_TYPE_AUDIO) {	4175	} else if (track->par->codec_type == AVMEDIA_TYPE_AUDIO) {
4176	buffer_size_t size;	4176	size_t size;
4177	int *fallback;	4177	int *fallback;
4178	fallback = (int*)av_stream_get_side_data(track->st,	4178	fallback = (int*)av_stream_get_side_data(track->st,
4179	AV_PKT_DATA_FALLBACK_TRACK,	4179	AV_PKT_DATA_FALLBACK_TRACK,
@@ -5557,7 +5557,7 @@ int ff_mov_write_packet(AVFormatContext s, AVPacket pkt) · 1377 unmodified lines
5557	AVProducerReferenceTime *prft;	5557	AVProducerReferenceTime *prft;
5558	unsigned int samples_in_chunk = 0;	5558	unsigned int samples_in_chunk = 0;
5559	int size = pkt->size, ret = 0, offset = 0;	5559	int size = pkt->size, ret = 0, offset = 0;
5560	buffer_size_t prft_size;	5560	size_t prft_size;
5561	uint8_t *reformatted_data = NULL;	5561	uint8_t *reformatted_data = NULL;
5562		5562
5563	ret = check_pkt(s, pkt);	5563	ret = check_pkt(s, pkt);
@@ -5910,7 +5910,7 @@ static int mov_write_single_packet(AVFormatContext s, AVPacket pkt) · 346 unmodified lines
5910	trk->par->codec_id == AV_CODEC_ID_AAC \|\|	5910	trk->par->codec_id == AV_CODEC_ID_AAC \|\|
5911	trk->par->codec_id == AV_CODEC_ID_AV1 \|\|	5911	trk->par->codec_id == AV_CODEC_ID_AV1 \|\|
5912	trk->par->codec_id == AV_CODEC_ID_FLAC) {	5912	trk->par->codec_id == AV_CODEC_ID_FLAC) {
5913	buffer_size_t side_size;	5913	size_t side_size;
5914	uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);	5914	uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
5915	if (side && side_size > 0 && (side_size != par->extradata_size \|\| memcmp(side, par->extradata, side_size))) {	5915	if (side && side_size > 0 && (side_size != par->extradata_size \|\| memcmp(side, par->extradata, side_size))) {
5916	void *newextra = av_mallocz(side_size + AV_INPUT_BUFFER_PADDING_SIZE);	5916	void *newextra = av_mallocz(side_size + AV_INPUT_BUFFER_PADDING_SIZE);

libavformat/mp3enc.c+2−2

@@ -355,7 +355,7 @@ static int mp3_write_audio_packet(AVFormatContext s, AVPacket pkt) · 354 unmodified lines
355		355
356	if (mp3->xing_offset) {	356	if (mp3->xing_offset) {
357	uint8_t *side_data = NULL;	357	uint8_t *side_data = NULL;
358	buffer_size_t side_data_size;	358	size_t side_data_size;
359		359
360	mp3_xing_add_frame(mp3, pkt);	360	mp3_xing_add_frame(mp3, pkt);
361	mp3->audio_size += pkt->size;	361	mp3->audio_size += pkt->size;
@@ -402,7 +402,7 @@ static void mp3_update_xing(AVFormatContext *s) · 40 unmodified lines
402	AVReplayGain *rg;	402	AVReplayGain *rg;
403	uint16_t tag_crc;	403	uint16_t tag_crc;
404	uint8_t *toc;	404	uint8_t *toc;
405	buffer_size_t rg_size;	405	size_t rg_size;
406	int i;	406	int i;
407	int64_t old_pos = avio_tell(s->pb);	407	int64_t old_pos = avio_tell(s->pb);
408		408

libavformat/mpegtsenc.c+2−2

@@ -1681,7 +1681,7 @@ static int mpegts_write_packet_internal(AVFormatContext s, AVPacket pkt) · 1680 unmodified lines
1681	const int64_t max_audio_delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE) / 2;	1681	const int64_t max_audio_delay = av_rescale(s->max_delay, 90000, AV_TIME_BASE) / 2;
1682	int64_t dts = pkt->dts, pts = pkt->pts;	1682	int64_t dts = pkt->dts, pts = pkt->pts;
1683	int opus_samples = 0;	1683	int opus_samples = 0;
1684	buffer_size_t side_data_size;	1684	size_t side_data_size;
1685	uint8_t *side_data = NULL;	1685	uint8_t *side_data = NULL;
1686	int stream_id = -1;	1686	int stream_id = -1;
1687		1687
@@ -1818,7 +1818,7 @@ static int mpegts_write_packet_internal(AVFormatContext s, AVPacket pkt) · 130 unmodified lines
1818	/* Add Opus control header */	1818	/* Add Opus control header */
1819	if ((AV_RB16(pkt->data) >> 5) != 0x3ff) {	1819	if ((AV_RB16(pkt->data) >> 5) != 0x3ff) {
1820	uint8_t *side_data;	1820	uint8_t *side_data;
1821	buffer_size_t side_data_size;	1821	size_t side_data_size;
1822	int i, n;	1822	int i, n;
1823	int ctrl_header_size;	1823	int ctrl_header_size;
1824	int trim_start = 0, trim_end = 0;	1824	int trim_start = 0, trim_end = 0;

libavformat/oggdec.h+1−1

@@ -87,7 +87,7 @@ struct ogg_stream { · 86 unmodified lines
87	int start_trimming; ///< set the number of packets to drop from the start	87	int start_trimming; ///< set the number of packets to drop from the start
88	int end_trimming; ///< set the number of packets to drop from the end	88	int end_trimming; ///< set the number of packets to drop from the end
89	uint8_t *new_metadata;	89	uint8_t *new_metadata;
90	buffer_size_t new_metadata_size;	90	size_t new_metadata_size;
91	void *private;	91	void *private;
92	};	92	};
93		93

libavformat/rtpenc.c+1−1

@@ -589,7 +589,7 @@ static int rtp_write_packet(AVFormatContext s1, AVPacket pkt) · 588 unmodified lines
589	break;	589	break;
590	case AV_CODEC_ID_H263:	590	case AV_CODEC_ID_H263:
591	if (s->flags & FF_RTP_FLAG_RFC2190) {	591	if (s->flags & FF_RTP_FLAG_RFC2190) {
592	buffer_size_t mb_info_size;	592	size_t mb_info_size;
593	const uint8_t *mb_info =	593	const uint8_t *mb_info =
594	av_packet_get_side_data(pkt, AV_PKT_DATA_H263_MB_INFO,	594	av_packet_get_side_data(pkt, AV_PKT_DATA_H263_MB_INFO,
595	&mb_info_size);	595	&mb_info_size);

libavformat/segment.c+1−1

@@ -856,7 +856,7 @@ static int seg_write_packet(AVFormatContext s, AVPacket pkt) · 855 unmodified lines
856	return AVERROR(EINVAL);	856	return AVERROR(EINVAL);
857		857
858	if (!st->codecpar->extradata_size) {	858	if (!st->codecpar->extradata_size) {
859	buffer_size_t pkt_extradata_size;	859	size_t pkt_extradata_size;
860	uint8_t *pkt_extradata = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &pkt_extradata_size);	860	uint8_t *pkt_extradata = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &pkt_extradata_size);
861	if (pkt_extradata && pkt_extradata_size > 0) {	861	if (pkt_extradata && pkt_extradata_size > 0) {
862	ret = ff_alloc_extradata(st->codecpar, pkt_extradata_size);	862	ret = ff_alloc_extradata(st->codecpar, pkt_extradata_size);

libavformat/srtenc.c+1−1

@@ -61,7 +61,7 @@ static int srt_write_packet(AVFormatContext avf, AVPacket pkt) · 60 unmodified lines
61	SRTContext *srt = avf->priv_data;	61	SRTContext *srt = avf->priv_data;
62		62
63	int64_t s = pkt->pts, e, d = pkt->duration;	63	int64_t s = pkt->pts, e, d = pkt->duration;
64	buffer_size_t size;	64	size_t size;
65	int x1 = -1, y1 = -1, x2 = -1, y2 = -1;	65	int x1 = -1, y1 = -1, x2 = -1, y2 = -1;
66	const uint8_t *p;	66	const uint8_t *p;
67		67

libavformat/utils.c+3−3

@@ -5462,7 +5462,7 @@ int ff_generate_avci_extradata(AVStream *st) · 5461 unmodified lines
5462	}	5462	}
5463		5463
5464	uint8_t av_stream_get_side_data(const AVStream st,	5464	uint8_t av_stream_get_side_data(const AVStream st,
5465	enum AVPacketSideDataType type, buffer_size_t *size)	5465	enum AVPacketSideDataType type, size_t *size)
5466	{	5466	{
5467	int i;	5467	int i;
5468		5468
@@ -5515,7 +5515,7 @@ int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type, · 46 unmodified lines
5515	}	5515	}
5516		5516
5517	uint8_t av_stream_new_side_data(AVStream st, enum AVPacketSideDataType type,	5517	uint8_t av_stream_new_side_data(AVStream st, enum AVPacketSideDataType type,
5518	buffer_size_t size)	5518	size_t size)
5519	{	5519	{
5520	int ret;	5520	int ret;
5521	uint8_t *data = av_malloc(size);	5521	uint8_t *data = av_malloc(size);
@@ -5631,7 +5631,7 @@ int ff_standardize_creation_time(AVFormatContext *s) · 109 unmodified lines
5631	int ff_get_packet_palette(AVFormatContext s, AVPacket pkt, int ret, uint32_t *palette)	5631	int ff_get_packet_palette(AVFormatContext s, AVPacket pkt, int ret, uint32_t *palette)
5632	{	5632	{
5633	uint8_t *side_data;	5633	uint8_t *side_data;
5634	buffer_size_t size;	5634	size_t size;
5635		5635
5636	side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);	5636	side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5637	if (side_data) {	5637	if (side_data) {

libavformat/webvttdec.c+1−1

@@ -78,7 +78,7 @@ static int webvtt_read_header(AVFormatContext *s) · 77 unmodified lines
78	int64_t pos;	78	int64_t pos;
79	AVPacket *sub;	79	AVPacket *sub;
80	const char p, identifier, *settings;	80	const char p, identifier, *settings;
81	int identifier_len, settings_len;	81	size_t identifier_len, settings_len;
82	int64_t ts_start, ts_end;	82	int64_t ts_start, ts_end;
83		83
84	ff_subtitles_read_chunk(s->pb, &cue);	84	ff_subtitles_read_chunk(s->pb, &cue);

libavformat/webvttenc.c+1−1

@@ -64,7 +64,7 @@ static int webvtt_write_header(AVFormatContext *ctx) · 63 unmodified lines
64	static int webvtt_write_packet(AVFormatContext ctx, AVPacket pkt)	64	static int webvtt_write_packet(AVFormatContext ctx, AVPacket pkt)
65	{	65	{
66	AVIOContext *pb = ctx->pb;	66	AVIOContext *pb = ctx->pb;
67	buffer_size_t id_size, settings_size;	67	size_t id_size, settings_size;
68	int id_size_int, settings_size_int;	68	int id_size_int, settings_size_int;
69	uint8_t id, settings;	69	uint8_t id, settings;
70		70

libavutil/buffer.c+7−7

@@ -26,7 +26,7 @@ · 25 unmodified lines
26	#include "mem.h"	26	#include "mem.h"
27	#include "thread.h"	27	#include "thread.h"
28		28
29	AVBufferRef av_buffer_create(uint8_t data, buffer_size_t size,	29	AVBufferRef av_buffer_create(uint8_t data, size_t size,
30	void (free)(void opaque, uint8_t *data),	30	void (free)(void opaque, uint8_t *data),
31	void *opaque, int flags)	31	void *opaque, int flags)
32	{	32	{
@@ -64,7 +64,7 @@ void av_buffer_default_free(void opaque, uint8_t data) · 31 unmodified lines
64	av_free(data);	64	av_free(data);
65	}	65	}
66		66
67	AVBufferRef *av_buffer_alloc(buffer_size_t size)	67	AVBufferRef *av_buffer_alloc(size_t size)
68	{	68	{
69	AVBufferRef *ret = NULL;	69	AVBufferRef *ret = NULL;
70	uint8_t *data = NULL;	70	uint8_t *data = NULL;
@@ -80,7 +80,7 @@ AVBufferRef *av_buffer_alloc(buffer_size_t size) · 9 unmodified lines
80	return ret;	80	return ret;
81	}	81	}
82		82
83	AVBufferRef *av_buffer_allocz(buffer_size_t size)	83	AVBufferRef *av_buffer_allocz(size_t size)
84	{	84	{
85	AVBufferRef *ret = av_buffer_alloc(size);	85	AVBufferRef *ret = av_buffer_alloc(size);
86	if (!ret)	86	if (!ret)
@@ -166,7 +166,7 @@ int av_buffer_make_writable(AVBufferRef **pbuf) · 79 unmodified lines
166	return 0;	166	return 0;
167	}	167	}
168		168
169	int av_buffer_realloc(AVBufferRef **pbuf, buffer_size_t size)	169	int av_buffer_realloc(AVBufferRef **pbuf, size_t size)
170	{	170	{
171	AVBufferRef buf = pbuf;	171	AVBufferRef buf = pbuf;
172	uint8_t *tmp;	172	uint8_t *tmp;
@@ -242,8 +242,8 @@ int av_buffer_replace(AVBufferRef *pdst, AVBufferRef src) · 69 unmodified lines
242	return 0;	242	return 0;
243	}	243	}
244		244
245	AVBufferPool av_buffer_pool_init2(buffer_size_t size, void opaque,	245	AVBufferPool av_buffer_pool_init2(size_t size, void opaque,
246	AVBufferRef* (alloc)(void opaque, buffer_size_t size),	246	AVBufferRef* (alloc)(void opaque, size_t size),
247	void (pool_free)(void opaque))	247	void (pool_free)(void opaque))
248	{	248	{
249	AVBufferPool pool = av_mallocz(sizeof(pool));	249	AVBufferPool pool = av_mallocz(sizeof(pool));
@@ -263,7 +263,7 @@ AVBufferPool av_buffer_pool_init2(buffer_size_t size, void opaque, · 13 unmodified lines
263	return pool;	263	return pool;
264	}	264	}
265		265
266	AVBufferPool av_buffer_pool_init(buffer_size_t size, AVBufferRef (*alloc)(buffer_size_t size))	266	AVBufferPool av_buffer_pool_init(size_t size, AVBufferRef (*alloc)(size_t size))
267	{	267	{
268	AVBufferPool pool = av_mallocz(sizeof(pool));	268	AVBufferPool pool = av_mallocz(sizeof(pool));
269	if (!pool)	269	if (!pool)

libavutil/buffer.h+0−29

     /**
      * Size of data in bytes.
      */
-#if FF_API_BUFFER_SIZE_T
-    int      size;
-#else
     size_t   size;
-#endif
 } AVBufferRef;
 /**
  *
  * @return an AVBufferRef of given size or NULL when out of memory
  */
-#if FF_API_BUFFER_SIZE_T
-AVBufferRef *av_buffer_alloc(int size);
-#else
 AVBufferRef *av_buffer_alloc(size_t size);
-#endif
 /**
  * Same as av_buffer_alloc(), except the returned buffer will be initialized
  * to zero.
  */
-#if FF_API_BUFFER_SIZE_T
-AVBufferRef *av_buffer_allocz(int size);
-#else
 AVBufferRef *av_buffer_allocz(size_t size);
-#endif
 /**
  * Always treat the buffer as read-only, even when it has only one
  *
  * @return an AVBufferRef referring to data on success, NULL on failure.
  */
-#if FF_API_BUFFER_SIZE_T
-AVBufferRef *av_buffer_create(uint8_t *data, int size,
-#else
 AVBufferRef *av_buffer_create(uint8_t *data, size_t size,
-#endif
                               void (*free)(void *opaque, uint8_t *data),
                               void *opaque, int flags);
  * reference to it (i.e. the one passed to this function). In all other cases
  * a new buffer is allocated and the data is copied.
  */
-#if FF_API_BUFFER_SIZE_T
-int av_buffer_realloc(AVBufferRef **buf, int size);
-#else
 int av_buffer_realloc(AVBufferRef **buf, size_t size);
-#endif
 /**
  * Ensure dst refers to the same data as src.
  * (av_buffer_alloc()).
  * @return newly created buffer pool on success, NULL on error.
  */
-#if FF_API_BUFFER_SIZE_T
-AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size));
-#else
 AVBufferPool *av_buffer_pool_init(size_t size, AVBufferRef* (*alloc)(size_t size));
-#endif
 /**
  * Allocate and initialize a buffer pool with a more complex allocator.
  *                  data. May be NULL.
  * @return newly created buffer pool on success, NULL on error.
  */
-#if FF_API_BUFFER_SIZE_T
-AVBufferPool *av_buffer_pool_init2(int size, void *opaque,
-                                   AVBufferRef* (*alloc)(void *opaque, int size),
-#else
 AVBufferPool *av_buffer_pool_init2(size_t size, void *opaque,
                                    AVBufferRef* (*alloc)(void *opaque, size_t size),
-#endif
                                    void (*pool_free)(void *opaque));
 /**

libavutil/buffer_internal.h+4−4

@@ -33,7 +33,7 @@ · 32 unmodified lines
33		33
34	struct AVBuffer {	34	struct AVBuffer {
35	uint8_t data; /< data described by this buffer /	35	uint8_t data; /< data described by this buffer /
36	buffer_size_t size; /*< size of data in bytes /	36	size_t size; /*< size of data in bytes /
37		37
38	/**	38	/**
39	* number of existing AVBufferRef instances referring to this buffer	39	* number of existing AVBufferRef instances referring to this buffer
@@ -90,10 +90,10 @@ struct AVBufferPool { · 50 unmodified lines
90	*/	90	*/
91	atomic_uint refcount;	91	atomic_uint refcount;
92		92
93	buffer_size_t size;	93	size_t size;
94	void *opaque;	94	void *opaque;
95	AVBufferRef* (*alloc)(buffer_size_t size);	95	AVBufferRef* (*alloc)(size_t size);
96	AVBufferRef* (alloc2)(void opaque, buffer_size_t size);	96	AVBufferRef* (alloc2)(void opaque, size_t size);
97	void (pool_free)(void opaque);	97	void (pool_free)(void opaque);
98	};	98	};
99		99

libavutil/detection_bbox.c+0−4

     header = av_detection_bbox_alloc(nb_bboxes, &size);
     if (!header)
         return NULL;
-    if (size > INT_MAX) {
-        av_freep(&header);
-        return NULL;
-    }
     buf = av_buffer_create((uint8_t *)header, size, NULL, NULL, 0);
     if (!buf) {
         av_freep(&header);

libavutil/frame.c+1−1

@@ -603,7 +603,7 @@ AVFrameSideData av_frame_new_side_data_from_buf(AVFrame frame, · 602 unmodified lines
603		603
604	AVFrameSideData av_frame_new_side_data(AVFrame frame,	604	AVFrameSideData av_frame_new_side_data(AVFrame frame,
605	enum AVFrameSideDataType type,	605	enum AVFrameSideDataType type,
606	buffer_size_t size)	606	size_t size)
607	{	607	{
608	AVFrameSideData *ret;	608	AVFrameSideData *ret;
609	AVBufferRef *buf = av_buffer_alloc(size);	609	AVBufferRef *buf = av_buffer_alloc(size);

libavutil/frame.h+0−8

 typedef struct AVFrameSideData {
     enum AVFrameSideDataType type;
     uint8_t *data;
-#if FF_API_BUFFER_SIZE_T
-    int      size;
-#else
     size_t   size;
-#endif
     AVDictionary *metadata;
     AVBufferRef *buf;
 } AVFrameSideData;
  */
 AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
                                         enum AVFrameSideDataType type,
-#if FF_API_BUFFER_SIZE_T
-                                        int size);
-#else
                                         size_t size);
-#endif
 /**
  * Add a new side data to a frame from an existing AVBufferRef

libavutil/hwcontext_cuda.c+1−1

@@ -93,7 +93,7 @@ static void cuda_buffer_free(void opaque, uint8_t data) · 92 unmodified lines
93	CHECK_CU(cu->cuCtxPopCurrent(&dummy));	93	CHECK_CU(cu->cuCtxPopCurrent(&dummy));
94	}	94	}
95		95
96	static AVBufferRef cuda_pool_alloc(void opaque, buffer_size_t size)	96	static AVBufferRef cuda_pool_alloc(void opaque, size_t size)
97	{	97	{
98	AVHWFramesContext *ctx = opaque;	98	AVHWFramesContext *ctx = opaque;
99	AVHWDeviceContext *device_ctx = ctx->device_ctx;	99	AVHWDeviceContext *device_ctx = ctx->device_ctx;

libavutil/hwcontext_d3d11va.c+1−1

@@ -202,7 +202,7 @@ static AVBufferRef d3d11va_alloc_single(AVHWFramesContext ctx) · 201 unmodified lines
202	return wrap_texture_buf(tex, 0);	202	return wrap_texture_buf(tex, 0);
203	}	203	}
204		204
205	static AVBufferRef d3d11va_pool_alloc(void opaque, buffer_size_t size)	205	static AVBufferRef d3d11va_pool_alloc(void opaque, size_t size)
206	{	206	{
207	AVHWFramesContext ctx = (AVHWFramesContext)opaque;	207	AVHWFramesContext ctx = (AVHWFramesContext)opaque;
208	D3D11VAFramesContext *s = ctx->internal->priv;	208	D3D11VAFramesContext *s = ctx->internal->priv;

libavutil/hwcontext_dxva2.c+1−1

@@ -124,7 +124,7 @@ static void dxva2_pool_release_dummy(void opaque, uint8_t data) · 123 unmodified lines
124	// released in dxva2_frames_uninit()	124	// released in dxva2_frames_uninit()
125	}	125	}
126		126
127	static AVBufferRef dxva2_pool_alloc(void opaque, buffer_size_t size)	127	static AVBufferRef dxva2_pool_alloc(void opaque, size_t size)
128	{	128	{
129	AVHWFramesContext ctx = (AVHWFramesContext)opaque;	129	AVHWFramesContext ctx = (AVHWFramesContext)opaque;
130	DXVA2FramesContext *s = ctx->internal->priv;	130	DXVA2FramesContext *s = ctx->internal->priv;

libavutil/hwcontext_opencl.c+1−1

@@ -1617,7 +1617,7 @@ static void opencl_pool_free(void opaque, uint8_t data) · 1616 unmodified lines
1617	av_free(desc);	1617	av_free(desc);
1618	}	1618	}
1619		1619
1620	static AVBufferRef opencl_pool_alloc(void opaque, buffer_size_t size)	1620	static AVBufferRef opencl_pool_alloc(void opaque, size_t size)
1621	{	1621	{
1622	AVHWFramesContext *hwfc = opaque;	1622	AVHWFramesContext *hwfc = opaque;
1623	AVOpenCLDeviceContext *hwctx = hwfc->device_ctx->hwctx;	1623	AVOpenCLDeviceContext *hwctx = hwfc->device_ctx->hwctx;

libavutil/hwcontext_qsv.c+1−1

@@ -194,7 +194,7 @@ static void qsv_pool_release_dummy(void opaque, uint8_t data) · 193 unmodified lines
194	{	194	{
195	}	195	}
196		196
197	static AVBufferRef qsv_pool_alloc(void opaque, buffer_size_t size)	197	static AVBufferRef qsv_pool_alloc(void opaque, size_t size)
198	{	198	{
199	AVHWFramesContext ctx = (AVHWFramesContext)opaque;	199	AVHWFramesContext ctx = (AVHWFramesContext)opaque;
200	QSVFramesContext *s = ctx->internal->priv;	200	QSVFramesContext *s = ctx->internal->priv;

libavutil/hwcontext_vaapi.c+1−1

@@ -464,7 +464,7 @@ static void vaapi_buffer_free(void opaque, uint8_t data) · 463 unmodified lines
464	}	464	}
465	}	465	}
466		466
467	static AVBufferRef vaapi_pool_alloc(void opaque, buffer_size_t size)	467	static AVBufferRef vaapi_pool_alloc(void opaque, size_t size)
468	{	468	{
469	AVHWFramesContext *hwfc = opaque;	469	AVHWFramesContext *hwfc = opaque;
470	VAAPIFramesContext *ctx = hwfc->internal->priv;	470	VAAPIFramesContext *ctx = hwfc->internal->priv;

libavutil/hwcontext_vdpau.c+1−1

@@ -225,7 +225,7 @@ static void vdpau_buffer_free(void opaque, uint8_t data) · 224 unmodified lines
225	device_priv->surf_destroy(surf);	225	device_priv->surf_destroy(surf);
226	}	226	}
227		227
228	static AVBufferRef vdpau_pool_alloc(void opaque, buffer_size_t size)	228	static AVBufferRef vdpau_pool_alloc(void opaque, size_t size)
229	{	229	{
230	AVHWFramesContext *ctx = opaque;	230	AVHWFramesContext *ctx = opaque;
231	VDPAUFramesContext *priv = ctx->internal->priv;	231	VDPAUFramesContext *priv = ctx->internal->priv;

libavutil/hwcontext_vulkan.c+1−1

@@ -1693,7 +1693,7 @@ static void try_export_flags(AVHWFramesContext *hwfc, · 1692 unmodified lines
1693	}	1693	}
1694	}	1694	}
1695		1695
1696	static AVBufferRef vulkan_pool_alloc(void opaque, buffer_size_t size)	1696	static AVBufferRef vulkan_pool_alloc(void opaque, size_t size)
1697	{	1697	{
1698	int err;	1698	int err;
1699	AVVkFrame *f;	1699	AVVkFrame *f;

libavutil/internal.h+0−7

@@ -292,11 +292,4 @@ void ff_check_pixfmt_descriptors(void); · 291 unmodified lines
292	*/	292	*/
293	int avpriv_dict_set_timestamp(AVDictionary *dict, const char key, int64_t timestamp);	293	int avpriv_dict_set_timestamp(AVDictionary *dict, const char key, int64_t timestamp);
294		294
295	// Temporary typedef to simplify porting all AVBufferRef users to size_t
296	#if FF_API_BUFFER_SIZE_T
297	typedef int buffer_size_t;
298	#else
299	typedef size_t buffer_size_t;
300	#endif
301
302	#endif /* AVUTIL_INTERNAL_H */	295	#endif /* AVUTIL_INTERNAL_H */

libavutil/version.h+0−3

 #ifndef FF_API_CHILD_CLASS_NEXT
 #define FF_API_CHILD_CLASS_NEXT         (LIBAVUTIL_VERSION_MAJOR < 57)
 #endif
-#ifndef FF_API_BUFFER_SIZE_T
-#define FF_API_BUFFER_SIZE_T            (LIBAVUTIL_VERSION_MAJOR < 57)
-#endif
 #ifndef FF_API_CPU_FLAGS
 #define FF_API_CPU_FLAGS                (LIBAVUTIL_VERSION_MAJOR < 57)
 #endif

libavutil/video_enc_params.c+0−4

     par = av_video_enc_params_alloc(type, nb_blocks, &size);
     if (!par)
         return NULL;
-    if (size > INT_MAX) {
-        av_free(par);
-        return NULL;
-    }
     buf = av_buffer_create((uint8_t *)par, size, NULL, NULL, 0);
     if (!buf) {
         av_freep(&par);

avutil/buffer: Switch AVBuffer API to size_t

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code