sigrid/ffmpeg

doc/APIchanges+11−0

@@ -14,6 +14,17 @@ libavutil: 2017-10-21 · 13 unmodified lines
14		14
15		15
16	API changes, most recent first:	16	API changes, most recent first:
		17
		18	2021-04-27 - xxxxxxxxxx - lavf yyyyyyyyy - avformat.h
		19	Constified the pointers to AVInputFormats and AVOutputFormats
		20	in AVFormatContext, avformat_alloc_output_context2(),
		21	av_find_input_format(), av_probe_input_format(),
		22	av_probe_input_format2(), av_probe_input_format3(),
		23	av_probe_input_buffer2(), av_probe_input_buffer(),
		24	avformat_open_input(), av_guess_format() and av_guess_codec().
		25	Furthermore, constified the AVProbeData in av_probe_input_format(),
		26	av_probe_input_format2() and av_probe_input_format3().
		27
17	2021-04-19 - xxxxxxxxxx - lavu 56.74.100 - tx.h	28	2021-04-19 - xxxxxxxxxx - lavu 56.74.100 - tx.h
18	Add AV_TX_FULL_IMDCT and AV_TX_UNALIGNED.	29	Add AV_TX_FULL_IMDCT and AV_TX_UNALIGNED.
19		30

doc/examples/muxing.c+1−1

 int main(int argc, char **argv)
 {
     OutputStream video_st = { 0 }, audio_st = { 0 };
+    const AVOutputFormat *fmt;
     const char *filename;
-    AVOutputFormat *fmt;
     AVFormatContext *oc;
     AVCodec *audio_codec, *video_codec;
     int ret;

doc/examples/remuxing.c+1−1

@@ -45,7 +45,7 @@ static void log_packet(const AVFormatContext fmt_ctx, const AVPacket pkt, cons · 44 unmodified lines
45		45
46	int main(int argc, char **argv)	46	int main(int argc, char **argv)
47	{	47	{
48	AVOutputFormat *ofmt = NULL;	48	const AVOutputFormat *ofmt = NULL;
49	AVFormatContext ifmt_ctx = NULL, ofmt_ctx = NULL;	49	AVFormatContext ifmt_ctx = NULL, ofmt_ctx = NULL;
50	AVPacket pkt;	50	AVPacket pkt;
51	const char in_filename, out_filename;	51	const char in_filename, out_filename;

fftools/ffmpeg_opt.c+7−5

 {
     InputFile *f;
     AVFormatContext *ic;
-    AVInputFormat *file_iformat = NULL;
+    const AVInputFormat *file_iformat = NULL;
     int err, i, ret;
     int64_t timestamp;
     AVDictionary *unused_opts = NULL;
         av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
     }
     if (o->nb_audio_channels) {
+        const AVClass *priv_class;
         /* because we set audio_channels based on both the "ac" and
          * "channel_layout" options, we need to check that the specified
          * demuxer actually has the "channels" option before setting it */
-        if (file_iformat && file_iformat->priv_class &&
+        if (file_iformat && (priv_class = file_iformat->priv_class) &&
-            av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
+            av_opt_find(&priv_class, "channels", NULL, 0,
                         AV_OPT_SEARCH_FAKE_OBJ)) {
             av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
         }
     }
     if (o->nb_frame_rates) {
+        const AVClass *priv_class;
         /* set the format-level framerate option;
          * this is important for video grabbers, e.g. x11 */
-        if (file_iformat && file_iformat->priv_class &&
+        if (file_iformat && (priv_class = file_iformat->priv_class) &&
-            av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
+            av_opt_find(&priv_class, "framerate", NULL, 0,
                         AV_OPT_SEARCH_FAKE_OBJ)) {
             av_dict_set(&o->g->format_opts, "framerate",
                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);

fftools/ffplay.c+4−3

 typedef struct VideoState {
     SDL_Thread *read_tid;
-    AVInputFormat *iformat;
+    const AVInputFormat *iformat;
     int abort_request;
     int force_refresh;
     int paused;
 } VideoState;
 /* options specified by the user */
-static AVInputFormat *file_iformat;
+static const AVInputFormat *file_iformat;
 static const char *input_filename;
 static const char *window_title;
 static int default_width  = 640;
     return 0;
 }
-static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
+static VideoState *stream_open(const char *filename,
+                               const AVInputFormat *iformat)
 {
     VideoState *is;

fftools/ffprobe.c+1−1

@@ -257,7 +257,7 @@ static const OptionDef *options; · 256 unmodified lines
257	/* FFprobe context */	257	/* FFprobe context */
258	static const char *input_filename;	258	static const char *input_filename;
259	static const char *print_input_filename;	259	static const char *print_input_filename;
260	static AVInputFormat *iformat = NULL;	260	static const AVInputFormat *iformat = NULL;
261		261
262	static struct AVHashContext *hash;	262	static struct AVHashContext *hash;
263		263

libavdevice/internal.h+1−1

@@ -22,7 +22,7 @@ · 21 unmodified lines
22	#include "libavformat/avformat.h"	22	#include "libavformat/avformat.h"
23		23
24	av_warn_unused_result	24	av_warn_unused_result
25	int ff_alloc_input_device_context(struct AVFormatContext *avctx, struct AVInputFormat iformat,	25	int ff_alloc_input_device_context(struct AVFormatContext *avctx, const AVInputFormat iformat,
26	const char *format);	26	const char *format);
27		27
28	#endif	28	#endif

libavdevice/utils.c+1−1

@@ -20,7 +20,7 @@ · 19 unmodified lines
20	#include "libavutil/opt.h"	20	#include "libavutil/opt.h"
21	#include "libavformat/avformat.h"	21	#include "libavformat/avformat.h"
22		22
23	int ff_alloc_input_device_context(AVFormatContext *avctx, AVInputFormat iformat, const char *format)	23	int ff_alloc_input_device_context(AVFormatContext *avctx, const AVInputFormat iformat, const char *format)
24	{	24	{
25	AVFormatContext *s;	25	AVFormatContext *s;
26	int ret = 0;	26	int ret = 0;

libavfilter/lavfutils.c+1−1

@@ -26,7 +26,7 @@ int ff_load_image(uint8_t *data[4], int linesize[4], · 25 unmodified lines
26	int w, int h, enum AVPixelFormat *pix_fmt,	26	int w, int h, enum AVPixelFormat *pix_fmt,
27	const char filename, void log_ctx)	27	const char filename, void log_ctx)
28	{	28	{
29	AVInputFormat *iformat = NULL;	29	const AVInputFormat *iformat = NULL;
30	AVFormatContext *format_ctx = NULL;	30	AVFormatContext *format_ctx = NULL;
31	const AVCodec *codec;	31	const AVCodec *codec;
32	AVCodecContext *codec_ctx = NULL;	32	AVCodecContext *codec_ctx = NULL;

libavfilter/src_movie.c+1−1

@@ -205,7 +205,7 @@ static int guess_channel_layout(MovieStream st, int st_index, void log_ctx) · 204 unmodified lines
205	static av_cold int movie_common_init(AVFilterContext *ctx)	205	static av_cold int movie_common_init(AVFilterContext *ctx)
206	{	206	{
207	MovieContext *movie = ctx->priv;	207	MovieContext *movie = ctx->priv;
208	AVInputFormat *iformat = NULL;	208	const AVInputFormat *iformat = NULL;
209	int64_t timestamp;	209	int64_t timestamp;
210	int nb_streams = 1, ret, i;	210	int nb_streams = 1, ret, i;
211	char default_streams[16], stream_specs, spec, *cursor;	211	char default_streams[16], stream_specs, spec, *cursor;

libavformat/avformat.h+19−25

      * New public fields should be added right above.
      *****************************************************************
      */
-    /**
-     * The ff_const59 define is not part of the public API and will
-     * be removed without further warning.
-     */
-#if FF_API_AVIOFORMAT
-#define ff_const59
-#else
-#define ff_const59 const
-#endif
     /**
      * size of private data so that it can be allocated in the wrapper
      */
      *
      * Demuxing only, set by avformat_open_input().
      */
-    ff_const59 struct AVInputFormat *iformat;
+    const struct AVInputFormat *iformat;
     /**
      * The output container format.
      *
      * Muxing only, must be set by the caller before avformat_write_header().
      */
-    ff_const59 struct AVOutputFormat *oformat;
+    const struct AVOutputFormat *oformat;
     /**
      * Format private data. This is an AVOptions-enabled struct
  * @return >= 0 in case of success, a negative AVERROR code in case of
  * failure
  */
-int avformat_alloc_output_context2(AVFormatContext **ctx, ff_const59 AVOutputFormat *oformat,
+int avformat_alloc_output_context2(AVFormatContext **ctx, const AVOutputFormat *oformat,
                                    const char *format_name, const char *filename);
 /**
 /**
  * Find AVInputFormat based on the short name of the input format.
  */
-ff_const59 AVInputFormat *av_find_input_format(const char *short_name);
+const AVInputFormat *av_find_input_format(const char *short_name);
 /**
  * Guess the file format.
  * @param is_opened Whether the file is already opened; determines whether
  *                  demuxers with or without AVFMT_NOFILE are probed.
  */
-ff_const59 AVInputFormat *av_probe_input_format(ff_const59 AVProbeData *pd, int is_opened);
+const AVInputFormat *av_probe_input_format(const AVProbeData *pd, int is_opened);
 /**
  * Guess the file format.
  *                  If the score is <= AVPROBE_SCORE_MAX / 4 it is recommended
  *                  to retry with a larger probe buffer.
  */
-ff_const59 AVInputFormat *av_probe_input_format2(ff_const59 AVProbeData *pd, int is_opened, int *score_max);
+const AVInputFormat *av_probe_input_format2(const AVProbeData *pd,
+                                            int is_opened, int *score_max);
 /**
  * Guess the file format.
  *                  demuxers with or without AVFMT_NOFILE are probed.
  * @param score_ret The score of the best detection.
  */
-ff_const59 AVInputFormat *av_probe_input_format3(ff_const59 AVProbeData *pd, int is_opened, int *score_ret);
+const AVInputFormat *av_probe_input_format3(const AVProbeData *pd,
+                                            int is_opened, int *score_ret);
 /**
  * Probe a bytestream to determine the input format. Each time a probe returns
  *         the maximal score is AVPROBE_SCORE_MAX
  * AVERROR code otherwise
  */
-int av_probe_input_buffer2(AVIOContext *pb, ff_const59 AVInputFormat **fmt,
+int av_probe_input_buffer2(AVIOContext *pb, const AVInputFormat **fmt,
                            const char *url, void *logctx,
                            unsigned int offset, unsigned int max_probe_size);
 /**
  * Like av_probe_input_buffer2() but returns 0 on success
  */
-int av_probe_input_buffer(AVIOContext *pb, ff_const59 AVInputFormat **fmt,
+int av_probe_input_buffer(AVIOContext *pb, const AVInputFormat **fmt,
                           const char *url, void *logctx,
                           unsigned int offset, unsigned int max_probe_size);
  *
  * @note If you want to use custom IO, preallocate the format context and set its pb field.
  */
-int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options);
+int avformat_open_input(AVFormatContext **ps, const char *url,
+                        const AVInputFormat *fmt, AVDictionary **options);
 #if FF_API_DEMUXER_OPEN
 /**
  * @param mime_type if non-NULL checks if mime_type matches with the
  * MIME type of the registered formats
  */
-ff_const59 AVOutputFormat *av_guess_format(const char *short_name,
+const AVOutputFormat *av_guess_format(const char *short_name,
-                                const char *filename,
+                                      const char *filename,
-                                const char *mime_type);
+                                      const char *mime_type);
 /**
  * Guess the codec ID based upon muxer and filename.
  */
-enum AVCodecID av_guess_codec(ff_const59 AVOutputFormat *fmt, const char *short_name,
+enum AVCodecID av_guess_codec(const AVOutputFormat *fmt, const char *short_name,
-                            const char *filename, const char *mime_type,
+                              const char *filename, const char *mime_type,
-                            enum AVMediaType type);
+                              enum AVMediaType type);
 /**
  * Get timing information for the data currently output.

libavformat/avidec.c+1−1

@@ -1092,7 +1092,7 @@ static int read_gab2_sub(AVFormatContext s, AVStream st, AVPacket *pkt) · 1091 unmodified lines
1092	uint8_t desc[256];	1092	uint8_t desc[256];
1093	int score = AVPROBE_SCORE_EXTENSION, ret;	1093	int score = AVPROBE_SCORE_EXTENSION, ret;
1094	AVIStream *ast = st->priv_data;	1094	AVIStream *ast = st->priv_data;
1095	ff_const59 AVInputFormat *sub_demuxer;	1095	const AVInputFormat *sub_demuxer;
1096	AVRational time_base;	1096	AVRational time_base;
1097	int size;	1097	int size;
1098	AVProbeData pd;	1098	AVProbeData pd;

libavformat/dashdec.c+1−1

@@ -1879,7 +1879,7 @@ static void close_demux_for_component(struct representation *pls) · 1878 unmodified lines
1879	static int reopen_demux_for_component(AVFormatContext s, struct representation pls)	1879	static int reopen_demux_for_component(AVFormatContext s, struct representation pls)
1880	{	1880	{
1881	DASHContext *c = s->priv_data;	1881	DASHContext *c = s->priv_data;
1882	ff_const59 AVInputFormat *in_fmt = NULL;	1882	const AVInputFormat *in_fmt = NULL;
1883	AVDictionary *in_fmt_opts = NULL;	1883	AVDictionary *in_fmt_opts = NULL;
1884	uint8_t *avio_ctx_buffer = NULL;	1884	uint8_t *avio_ctx_buffer = NULL;
1885	int ret = 0, i;	1885	int ret = 0, i;

libavformat/fifo.c+2−2

@@ -469,7 +469,7 @@ static void fifo_consumer_thread(void data) · 468 unmodified lines
469	return NULL;	469	return NULL;
470	}	470	}
471		471
472	static int fifo_mux_init(AVFormatContext avf, ff_const59 AVOutputFormat oformat,	472	static int fifo_mux_init(AVFormatContext avf, const AVOutputFormat oformat,
473	const char *filename)	473	const char *filename)
474	{	474	{
475	FifoContext *fifo = avf->priv_data;	475	FifoContext *fifo = avf->priv_data;
@@ -508,7 +508,7 @@ static int fifo_mux_init(AVFormatContext avf, ff_const59 AVOutputFormat oforma · 32 unmodified lines
508	static int fifo_init(AVFormatContext *avf)	508	static int fifo_init(AVFormatContext *avf)
509	{	509	{
510	FifoContext *fifo = avf->priv_data;	510	FifoContext *fifo = avf->priv_data;
511	ff_const59 AVOutputFormat *oformat;	511	const AVOutputFormat *oformat;
512	int ret = 0;	512	int ret = 0;
513		513
514	if (fifo->recovery_wait_streamtime && !fifo->drop_pkts_on_overflow) {	514	if (fifo->recovery_wait_streamtime && !fifo->drop_pkts_on_overflow) {

libavformat/format.c+17−16

     return 0;
 }
-ff_const59 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
+const AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
-                                const char *mime_type)
+                                      const char *mime_type)
 {
     const AVOutputFormat *fmt = NULL;
     AVOutputFormat *fmt_found = NULL;
     return fmt_found;
 }
-enum AVCodecID av_guess_codec(ff_const59 AVOutputFormat *fmt, const char *short_name,
+enum AVCodecID av_guess_codec(const AVOutputFormat *fmt, const char *short_name,
                               const char *filename, const char *mime_type,
                               enum AVMediaType type)
 {
     if (av_match_name("segment", fmt->name) || av_match_name("ssegment", fmt->name)) {
-        ff_const59 AVOutputFormat *fmt2 = av_guess_format(NULL, filename, NULL);
+        const AVOutputFormat *fmt2 = av_guess_format(NULL, filename, NULL);
         if (fmt2)
             fmt = fmt2;
     }
         return AV_CODEC_ID_NONE;
 }
-ff_const59 AVInputFormat *av_find_input_format(const char *short_name)
+const AVInputFormat *av_find_input_format(const char *short_name)
 {
     const AVInputFormat *fmt = NULL;
     void *i = 0;
     return NULL;
 }
-ff_const59 AVInputFormat *av_probe_input_format3(ff_const59 AVProbeData *pd, int is_opened,
+const AVInputFormat *av_probe_input_format3(const AVProbeData *pd,
-                                      int *score_ret)
+                                            int is_opened, int *score_ret)
 {
     AVProbeData lpd = *pd;
     const AVInputFormat *fmt1 = NULL;
-    ff_const59 AVInputFormat *fmt = NULL;
+    const AVInputFormat *fmt = NULL;
     int score, score_max = 0;
     void *i = 0;
     const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
         }
         if (score > score_max) {
             score_max = score;
-            fmt       = (AVInputFormat*)fmt1;
+            fmt       = fmt1;
         } else if (score == score_max)
             fmt = NULL;
     }
     return fmt;
 }
-ff_const59 AVInputFormat *av_probe_input_format2(ff_const59 AVProbeData *pd, int is_opened, int *score_max)
+const AVInputFormat *av_probe_input_format2(const AVProbeData *pd,
+                                            int is_opened, int *score_max)
 {
     int score_ret;
-    ff_const59 AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
+    const AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
     if (score_ret > *score_max) {
         *score_max = score_ret;
         return fmt;
         return NULL;
 }
-ff_const59 AVInputFormat *av_probe_input_format(ff_const59 AVProbeData *pd, int is_opened)
+const AVInputFormat *av_probe_input_format(const AVProbeData *pd, int is_opened)
 {
     int score = 0;
     return av_probe_input_format2(pd, is_opened, &score);
 }
-int av_probe_input_buffer2(AVIOContext *pb, ff_const59 AVInputFormat **fmt,
+int av_probe_input_buffer2(AVIOContext *pb, const AVInputFormat **fmt,
-                          const char *filename, void *logctx,
+                           const char *filename, void *logctx,
-                          unsigned int offset, unsigned int max_probe_size)
+                           unsigned int offset, unsigned int max_probe_size)
 {
     AVProbeData pd = { filename ? filename : "" };
     uint8_t *buf = NULL;
     return ret < 0 ? ret : score;
 }
-int av_probe_input_buffer(AVIOContext *pb, ff_const59 AVInputFormat **fmt,
+int av_probe_input_buffer(AVIOContext *pb, const AVInputFormat **fmt,
                           const char *filename, void *logctx,
                           unsigned int offset, unsigned int max_probe_size)
 {

libavformat/hdsenc.c+1−1

 static int hds_write_header(AVFormatContext *s)
 {
     HDSContext *c = s->priv_data;
+    const AVOutputFormat *oformat;
     int ret = 0, i;
-    ff_const59 AVOutputFormat *oformat;
     if (mkdir(s->url, 0777) == -1 && errno != EEXIST) {
         av_log(s, AV_LOG_ERROR , "Failed to create directory %s\n", s->url);

libavformat/hls.c+1−1

     /* Open the demuxer for each playlist */
     for (i = 0; i < c->n_playlists; i++) {
         struct playlist *pls = c->playlists[i];
+        const AVInputFormat *in_fmt = NULL;
         char *url;
-        ff_const59 AVInputFormat *in_fmt = NULL;
         if (!(pls->ctx = avformat_alloc_context())) {
             ret = AVERROR(ENOMEM);

libavformat/hlsenc.c+2−2

@@ -119,8 +119,8 @@ typedef struct VariantStream { · 118 unmodified lines
119	unsigned var_stream_idx;	119	unsigned var_stream_idx;
120	unsigned number;	120	unsigned number;
121	int64_t sequence;	121	int64_t sequence;
122	ff_const59 AVOutputFormat *oformat;	122	const AVOutputFormat *oformat;
123	ff_const59 AVOutputFormat *vtt_oformat;	123	const AVOutputFormat *vtt_oformat;
124	AVIOContext *out;	124	AVIOContext *out;
125	AVIOContext *out_single_file;	125	AVIOContext *out_single_file;
126	int packets_written;	126	int packets_written;

libavformat/mpeg.c+1−1

 {
     int i, ret = 0, header_parsed = 0, langidx = 0;
     VobSubDemuxContext *vobsub = s->priv_data;
+    const AVInputFormat *iformat;
     size_t fname_len;
     AVBPrint header;
     int64_t delay = 0;
     int stream_id = -1;
     char id[64] = {0};
     char alt[MAX_LINE_SIZE] = {0};
-    ff_const59 AVInputFormat *iformat;
     if (!vobsub->sub_name) {
         char *ext;

libavformat/mux.c+1−1

@@ -133,7 +133,7 @@ enum AVChromaLocation ff_choose_chroma_location(AVFormatContext s, AVStream st · 132 unmodified lines
133		133
134	}	134	}
135		135
136	int avformat_alloc_output_context2(AVFormatContext *avctx, ff_const59 AVOutputFormat oformat,	136	int avformat_alloc_output_context2(AVFormatContext *avctx, const AVOutputFormat oformat,
137	const char format, const char filename)	137	const char format, const char filename)
138	{	138	{
139	AVFormatContext *s = avformat_alloc_context();	139	AVFormatContext *s = avformat_alloc_context();

libavformat/rtpdec_asf.c+1−1

@@ -106,7 +106,7 @@ int ff_wms_parse_sdp_a_line(AVFormatContext s, const char p) · 105 unmodified lines
106	AVDictionary *opts = NULL;	106	AVDictionary *opts = NULL;
107	int len = strlen(p) * 6 / 8;	107	int len = strlen(p) * 6 / 8;
108	char *buf = av_mallocz(len);	108	char *buf = av_mallocz(len);
109	ff_const59 AVInputFormat *iformat;	109	const AVInputFormat *iformat;
110		110
111	if (!buf)	111	if (!buf)
112	return AVERROR(ENOMEM);	112	return AVERROR(ENOMEM);

libavformat/rtpenc_chain.c+1−1

@@ -31,7 +31,7 @@ int ff_rtp_chain_mux_open(AVFormatContext *out, AVFormatContext s, · 30 unmodified lines
31	{	31	{
32	AVFormatContext *rtpctx = NULL;	32	AVFormatContext *rtpctx = NULL;
33	int ret;	33	int ret;
34	ff_const59 AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);	34	const AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
35	uint8_t *rtpflags;	35	uint8_t *rtpflags;
36	AVDictionary *opts = NULL;	36	AVDictionary *opts = NULL;
37		37

libavformat/rtpenc_mpegts.c+2−2

@@ -56,8 +56,8 @@ static int rtp_mpegts_write_header(AVFormatContext *s) · 55 unmodified lines
56	{	56	{
57	MuxChain *chain = s->priv_data;	57	MuxChain *chain = s->priv_data;
58	AVFormatContext mpegts_ctx = NULL, rtp_ctx = NULL;	58	AVFormatContext mpegts_ctx = NULL, rtp_ctx = NULL;
59	ff_const59 AVOutputFormat *mpegts_format = av_guess_format("mpegts", NULL, NULL);	59	const AVOutputFormat *mpegts_format = av_guess_format("mpegts", NULL, NULL);
60	ff_const59 AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);	60	const AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
61	int i, ret = AVERROR(ENOMEM);	61	int i, ret = AVERROR(ENOMEM);
62	AVStream *st;	62	AVStream *st;
63	AVDictionary *mpegts_muxer_options = NULL;	63	AVDictionary *mpegts_muxer_options = NULL;

libavformat/sapdec.c+1−1

     struct SAPState *sap = s->priv_data;
     char host[1024], path[1024], url[1024];
     uint8_t recvbuf[RTP_MAX_PACKET_LENGTH];
+    const AVInputFormat *infmt;
     int port;
     int ret, i;
-    ff_const59 AVInputFormat* infmt;
     if (!ff_network_init())
         return AVERROR(EIO);

libavformat/segment.c+1−1

@@ -72,7 +72,7 @@ typedef struct SegmentContext { · 71 unmodified lines
72	int segment_idx_wrap; ///< number after which the index wraps	72	int segment_idx_wrap; ///< number after which the index wraps
73	int segment_idx_wrap_nb; ///< number of time the index has wraped	73	int segment_idx_wrap_nb; ///< number of time the index has wraped
74	int segment_count; ///< number of segment files already written	74	int segment_count; ///< number of segment files already written
75	ff_const59 AVOutputFormat *oformat;	75	const AVOutputFormat *oformat;
76	AVFormatContext *avf;	76	AVFormatContext *avf;
77	char *format; ///< format to use for output segment files	77	char *format; ///< format to use for output segment files
78	AVDictionary *format_options;	78	AVDictionary *format_options;

libavformat/smoothstreamingenc.c+1−1

@@ -283,7 +283,7 @@ static int ism_write_header(AVFormatContext *s) · 282 unmodified lines
283	{	283	{
284	SmoothStreamingContext *c = s->priv_data;	284	SmoothStreamingContext *c = s->priv_data;
285	int ret = 0, i;	285	int ret = 0, i;
286	ff_const59 AVOutputFormat *oformat;	286	const AVOutputFormat *oformat;
287		287
288	if (mkdir(s->url, 0777) == -1 && errno != EEXIST) {	288	if (mkdir(s->url, 0777) == -1 && errno != EEXIST) {
289	av_log(s, AV_LOG_ERROR, "mkdir failed\n");	289	av_log(s, AV_LOG_ERROR, "mkdir failed\n");

libavformat/utils.c+1−1

@@ -545,7 +545,7 @@ FF_ENABLE_DEPRECATION_WARNINGS · 544 unmodified lines
545		545
546		546
547	int avformat_open_input(AVFormatContext *ps, const char filename,	547	int avformat_open_input(AVFormatContext *ps, const char filename,
548	ff_const59 AVInputFormat fmt, AVDictionary *options)	548	const AVInputFormat fmt, AVDictionary *options)
549	{	549	{
550	AVFormatContext s = ps;	550	AVFormatContext s = ps;
551	int i, ret = 0;	551	int i, ret = 0;

libavformat/version.h+0−3

 #ifndef FF_API_LAVF_MP4A_LATM
 #define FF_API_LAVF_MP4A_LATM           (LIBAVFORMAT_VERSION_MAJOR < 59)
 #endif
-#ifndef FF_API_AVIOFORMAT
-#define FF_API_AVIOFORMAT               (LIBAVFORMAT_VERSION_MAJOR < 59)
-#endif
 #ifndef FF_API_DEMUXER_OPEN
 #define FF_API_DEMUXER_OPEN             (LIBAVFORMAT_VERSION_MAJOR < 59)
 #endif

libavformat/webm_chunk.c+1−1

@@ -50,7 +50,7 @@ typedef struct WebMChunkContext { · 49 unmodified lines
50	static int webm_chunk_init(AVFormatContext *s)	50	static int webm_chunk_init(AVFormatContext *s)
51	{	51	{
52	WebMChunkContext *wc = s->priv_data;	52	WebMChunkContext *wc = s->priv_data;
53	ff_const59 AVOutputFormat *oformat;	53	const AVOutputFormat *oformat;
54	AVFormatContext *oc;	54	AVFormatContext *oc;
55	AVStream st, ost = s->streams[0];	55	AVStream st, ost = s->streams[0];
56	AVDictionary *dict = NULL;	56	AVDictionary *dict = NULL;

avformat: Constify the API wrt AV(In|Out)putFormat

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code