MrBesen
/
ffmpeg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge remote branch 'qatar/master' 

* qatar/master: (37 commits)
  In avcodec_open(), set return code to an error value only when an error occurs instead of unconditionally at the start of the function.
  lavc: remove reference to opt.h from Makefile.
  prefer avio_check() over url_exist()
  avio: remove AVIO_* access symbols in favor of new AVIO_FLAG_* symbols
  lavu: remove misc disabled cruft
  lavu: remove FF_API_OLD_IMAGE_NAMES cruft
NOT PULLED  lavu: remove FF_API_OLD_EVAL_NAMES cruft
  lavc: remove misc disabled cruft.
  lavc: remove the FF_API_INOFFICIAL cruft.
  lavc: remove the FF_API_SET_STRING_OLD cruft.
  lavc: remove the FF_API_USE_LPC cruft.
  lavc: remove the FF_API_SUBTITLE_OLD cruft.
  lavc: remove the FF_API_VIDEO_OLD cruft.
  lavc: remove the FF_API_AUDIO_OLD cruft.
  lavc: remove the FF_API_OPT_SHOW cruft.
  lavc: remove the FF_API_MM_FLAGS cruft.
  lavf: remove misc disabled cruft.
  lavf: remove FF_API_INDEX_BUILT cruft
  lavf: remove FF_API_URL_CLASS cruft.
  lavf: remove FF_API_SYMVER cruft
  ...

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2011-04-20 04:48:23 +02:00
parent f92b0084c0 31d76ec288
commit efb5fa79f5
67 changed files with 150 additions and 1376 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmdutils.c
View File

@ -38,7 +38,7 @@
#include "libavutil/parseutils.h"
#include "libavutil/pixdesc.h"
#include "libavutil/eval.h"
#include "libavcodec/opt.h"
#include "libavutil/opt.h"
#include "cmdutils.h"
#include "version.h"
#if CONFIG_NETWORK

5
doc/APIchanges
View File

@ -12,6 +12,11 @@ libavutil: 2009-03-08
API changes, most recent first:
2011-04-15 - lavc 52.120.0 - avcodec.h
AVPacket structure got additional members for passing side information:
4de339e introduce side information for AVPacket
2d8591c make containers pass palette change in AVPacket
2011-04-12 - lavf 52.107.0 - avio.h
Avio cleanup, part II - deprecate the entire URLContext API:
175389c add avio_check as a replacement for url_exist

8
ffmpeg.c
View File

@ -34,7 +34,7 @@
#include "libavformat/avformat.h"
#include "libavdevice/avdevice.h"
#include "libswscale/swscale.h"
#include "libavcodec/opt.h"
#include "libavutil/opt.h"
#include "libavcodec/audioconvert.h"
#include "libavutil/audioconvert.h"
#include "libavutil/parseutils.h"
@ -113,9 +113,7 @@ typedef struct AVChapterMap {
static const OptionDef options[];
#define MAX_FILES 100
#if !FF_API_MAX_STREAMS
#define MAX_STREAMS 1024 /* arbitrary sanity check value */
#endif
static const char *last_asked_format = NULL;
static AVFormatContext *input_files[MAX_FILES];
@ -3869,7 +3867,7 @@ static void opt_output_file(const char *filename)
(strchr(filename, ':') == NULL ||
filename[1] == ':' ||
av_strstart(filename, "file:", NULL))) {
if (url_exist(filename)) {
if (avio_check(filename, 0) == 0) {
if (!using_stdin) {
fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
fflush(stderr);
@ -3886,7 +3884,7 @@ static void opt_output_file(const char *filename)
}
/* open the file */
if ((err = avio_open(&oc->pb, filename, AVIO_WRONLY)) < 0) {
if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
print_error(filename, err);
ffmpeg_exit(1);
}

2
ffplay.c
View File

@ -36,7 +36,7 @@
#include "libavdevice/avdevice.h"
#include "libswscale/swscale.h"
#include "libavcodec/audioconvert.h"
#include "libavcodec/opt.h"
#include "libavutil/opt.h"
#include "libavcodec/avfft.h"
#if CONFIG_AVFILTER

2
ffprobe.c
View File

@ -23,7 +23,7 @@
#include "libavformat/avformat.h"
#include "libavcodec/avcodec.h"
#include "libavcodec/opt.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "libavdevice/avdevice.h"
#include "cmdutils.h"

16
ffserver.c
View File

@ -40,7 +40,7 @@
#include "libavutil/lfg.h"
#include "libavutil/random_seed.h"
#include "libavutil/parseutils.h"
#include "libavcodec/opt.h"
#include "libavutil/opt.h"
#include <stdarg.h>
#include <unistd.h>
#include <fcntl.h>
@ -95,9 +95,7 @@ static const char *http_state[] = {
"RTSP_SEND_PACKET",
};
#if !FF_API_MAX_STREAMS
#define MAX_STREAMS 20
#endif
#define IOBUFFER_INIT_SIZE 8192
@ -2944,11 +2942,9 @@ static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
snprintf(avc->filename, 1024, "rtp://0.0.0.0");
}
#if !FF_API_MAX_STREAMS
if (avc->nb_streams >= INT_MAX/sizeof(*avc->streams) ||
!(avc->streams = av_malloc(avc->nb_streams * sizeof(*avc->streams))))
goto sdp_done;
#endif
if (avc->nb_streams >= INT_MAX/sizeof(*avs) ||
!(avs = av_malloc(avc->nb_streams * sizeof(*avs))))
goto sdp_done;
@ -2961,9 +2957,7 @@ static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
av_sdp_create(&avc, 1, *pbuffer, 2048);
sdp_done:
#if !FF_API_MAX_STREAMS
av_free(avc->streams);
#endif
av_metadata_free(&avc->metadata);
av_free(avc);
av_free(avs);
@ -3428,7 +3422,7 @@ static int rtp_new_av_stream(HTTPContext *c,
"rtp://%s:%d", ipaddr, ntohs(dest_addr->sin_port));
}
if (url_open(&h, ctx->filename, AVIO_WRONLY) < 0)
if (url_open(&h, ctx->filename, AVIO_FLAG_WRITE) < 0)
goto fail;
c->rtp_handles[stream_index] = h;
max_packet_size = url_get_max_packet_size(h);
@ -3685,7 +3679,7 @@ static void build_feed_streams(void)
for(feed = first_feed; feed != NULL; feed = feed->next_feed) {
int fd;
if (url_exist(feed->feed_filename)) {
if (avio_check(feed->feed_filename, AVIO_FLAG_READ) > 0) {
/* See if it matches */
AVFormatContext *s;
int matches = 0;
@ -3758,7 +3752,7 @@ static void build_feed_streams(void)
unlink(feed->feed_filename);
}
}
if (!url_exist(feed->feed_filename)) {
if (avio_check(feed->feed_filename, AVIO_FLAG_WRITE) <= 0) {
AVFormatContext s1 = {0}, *s = &s1;
if (feed->readonly) {
@ -3768,7 +3762,7 @@ static void build_feed_streams(void)
}
/* only write the header of the ffm file */
if (avio_open(&s->pb, feed->feed_filename, AVIO_WRONLY) < 0) {
if (avio_open(&s->pb, feed->feed_filename, AVIO_FLAG_WRITE) < 0) {
http_log("Could not open output feed file '%s'\n",
feed->feed_filename);
exit(1);

3
libavcodec/Makefile
View File

@ -3,7 +3,7 @@ include $(SUBDIR)../config.mak
NAME = avcodec
FFLIBS = avutil
HEADERS = avcodec.h avfft.h dxva2.h opt.h vaapi.h vdpau.h version.h xvmc.h
HEADERS = avcodec.h avfft.h dxva2.h vaapi.h vdpau.h version.h xvmc.h
OBJS = allcodecs.o \
audioconvert.o \
@ -15,7 +15,6 @@ OBJS = allcodecs.o \
fmtconvert.o \
imgconvert.o \
jrevdct.o \
opt.o \
options.o \
parser.o \
raw.o \

201
libavcodec/avcodec.h
View File

@ -33,12 +33,6 @@
#include "libavcodec/version.h"
#if LIBAVCODEC_VERSION_MAJOR < 53
# define FF_INTERNALC_MEM_TYPE unsigned int
#else
# define FF_INTERNALC_MEM_TYPE size_t
#endif
/**
* Identify the syntax and semantics of the bitstream.
* The principle is roughly:
@ -117,9 +111,6 @@ enum CodecID {
CODEC_ID_QDRAW,
CODEC_ID_VIXL,
CODEC_ID_QPEG,
#if LIBAVCODEC_VERSION_MAJOR < 53
CODEC_ID_XVID,
#endif
CODEC_ID_PNG,
CODEC_ID_PPM,
CODEC_ID_PBM,
@ -366,18 +357,6 @@ enum CodecID {
CODEC_ID_FFMETADATA=0x21000, ///< Dummy codec for streams containing only metadata information.
};
#if LIBAVCODEC_VERSION_MAJOR < 53
#define CodecType AVMediaType
#define CODEC_TYPE_UNKNOWN AVMEDIA_TYPE_UNKNOWN
#define CODEC_TYPE_VIDEO AVMEDIA_TYPE_VIDEO
#define CODEC_TYPE_AUDIO AVMEDIA_TYPE_AUDIO
#define CODEC_TYPE_DATA AVMEDIA_TYPE_DATA
#define CODEC_TYPE_SUBTITLE AVMEDIA_TYPE_SUBTITLE
#define CODEC_TYPE_ATTACHMENT AVMEDIA_TYPE_ATTACHMENT
#define CODEC_TYPE_NB AVMEDIA_TYPE_NB
#endif
#if FF_API_OLD_SAMPLE_FMT
#define SampleFormat AVSampleFormat
@ -1112,9 +1091,6 @@ typedef struct AVPacket {
int64_t convergence_duration;
} AVPacket;
#define AV_PKT_FLAG_KEY 0x0001
#if LIBAVCODEC_VERSION_MAJOR < 53
#define PKT_FLAG_KEY AV_PKT_FLAG_KEY
#endif
/**
* Audio Video Frame.
@ -1289,9 +1265,6 @@ typedef struct AVCodecContext {
*/
int frame_size;
int frame_number; ///< audio or video frame number
#if LIBAVCODEC_VERSION_MAJOR < 53
int real_pict_num; ///< Returns the real picture number of previous encoded frame.
#endif
/**
* Number of frames the decoded output will be delayed relative to
@ -1476,9 +1449,6 @@ typedef struct AVCodecContext {
#define FF_COMPLIANCE_VERY_STRICT 2 ///< Strictly conform to an older more strict version of the spec or reference software.
#define FF_COMPLIANCE_STRICT 1 ///< Strictly conform to all the things in the spec no matter what consequences.
#define FF_COMPLIANCE_NORMAL 0
#if FF_API_INOFFICIAL
#define FF_COMPLIANCE_INOFFICIAL -1 ///< Allow inofficial extensions (deprecated - use FF_COMPLIANCE_UNOFFICIAL instead).
#endif
#define FF_COMPLIANCE_UNOFFICIAL -1 ///< Allow unofficial extensions
#define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things.
@ -1752,25 +1722,6 @@ typedef struct AVCodecContext {
*/
unsigned dsp_mask;
#if FF_API_MM_FLAGS
#define FF_MM_FORCE AV_CPU_FLAG_FORCE
#define FF_MM_MMX AV_CPU_FLAG_MMX
#define FF_MM_3DNOW AV_CPU_FLAG_3DNOW
#define FF_MM_MMXEXT AV_CPU_FLAG_MMX2
#define FF_MM_MMX2 AV_CPU_FLAG_MMX2
#define FF_MM_SSE AV_CPU_FLAG_SSE
#define FF_MM_SSE2 AV_CPU_FLAG_SSE2
#define FF_MM_SSE2SLOW AV_CPU_FLAG_SSE2SLOW
#define FF_MM_3DNOWEXT AV_CPU_FLAG_3DNOWEXT
#define FF_MM_SSE3 AV_CPU_FLAG_SSE3
#define FF_MM_SSE3SLOW AV_CPU_FLAG_SSE3SLOW
#define FF_MM_SSSE3 AV_CPU_FLAG_SSSE3
#define FF_MM_SSE4 AV_CPU_FLAG_SSE4
#define FF_MM_SSE42 AV_CPU_FLAG_SSE42
#define FF_MM_IWMMXT AV_CPU_FLAG_IWMMXT
#define FF_MM_ALTIVEC AV_CPU_FLAG_ALTIVEC
#endif
/**
* bits per sample/pixel from the demuxer (needed for huffyuv).
* - encoding: Set by libavcodec.
@ -2562,16 +2513,6 @@ typedef struct AVCodecContext {
int compression_level;
#define FF_COMPRESSION_DEFAULT -1
#if FF_API_USE_LPC
/**
* Sets whether to use LPC mode - used by FLAC encoder.
* - encoding: Set by user.
* - decoding: unused
* @deprecated Deprecated in favor of lpc_type and lpc_passes.
*/
int use_lpc;
#endif
/**
* LPC coefficient precision - used by FLAC encoder
* - encoding: Set by user.
@ -3269,14 +3210,6 @@ struct AVResampleContext;
typedef struct ReSampleContext ReSampleContext;
#if FF_API_AUDIO_OLD
/**
* @deprecated Use av_audio_resample_init() instead.
*/
attribute_deprecated ReSampleContext *audio_resample_init(int output_channels, int input_channels,
int output_rate, int input_rate);
#endif
/**
* Initialize audio resampling context.
*
@ -3436,23 +3369,6 @@ const char *avcodec_get_pix_fmt_name(enum PixelFormat pix_fmt);
void avcodec_set_dimensions(AVCodecContext *s, int width, int height);
#if LIBAVCODEC_VERSION_MAJOR < 53
/**
* Return the pixel format corresponding to the name name.
*
* If there is no pixel format with name name, then look for a
* pixel format with the name corresponding to the native endian
* format of name.
* For example in a little-endian system, first look for "gray16",
* then for "gray16le".
*
* Finally if no pixel format has been found, return PIX_FMT_NONE.
*
* @deprecated Deprecated in favor of av_get_pix_fmt().
*/
attribute_deprecated enum PixelFormat avcodec_get_pix_fmt(const char* name);
#endif
/**
* Return a value representing the fourCC code associated to the
* pixel format pix_fmt, or 0 if no associated fourCC code can be
@ -3521,14 +3437,6 @@ int avcodec_get_pix_fmt_loss(enum PixelFormat dst_pix_fmt, enum PixelFormat src_
enum PixelFormat avcodec_find_best_pix_fmt(int64_t pix_fmt_mask, enum PixelFormat src_pix_fmt,
int has_alpha, int *loss_ptr);
#if LIBAVCODEC_VERSION_MAJOR < 53
/**
* @deprecated Use av_get_pix_fmt_string() instead.
*/
attribute_deprecated
void avcodec_pix_fmt_string (char *buf, int buf_size, enum PixelFormat pix_fmt);
#endif
#define FF_ALPHA_TRANSP 0x0001 /* image has some totally transparent pixels */
#define FF_ALPHA_SEMI_TRANSP 0x0002 /* image has some transparent pixels */
@ -3579,13 +3487,6 @@ const char *avcodec_license(void);
*/
void avcodec_init(void);
#if LIBAVCODEC_VERSION_MAJOR < 53
/**
* @deprecated Deprecated in favor of avcodec_register().
*/
attribute_deprecated void register_avcodec(AVCodec *codec);
#endif
/**
* Register the codec codec and initialize libavcodec.
*
@ -3730,24 +3631,8 @@ void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height);
void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
int linesize_align[4]);
#if LIBAVCODEC_VERSION_MAJOR < 53
/**
* @deprecated Deprecated in favor of av_check_image_size().
*/
attribute_deprecated
int avcodec_check_dimensions(void *av_log_ctx, unsigned int w, unsigned int h);
#endif
enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat * fmt);
#if LIBAVCODEC_VERSION_MAJOR < 53
/**
* @deprecated Set s->thread_count before calling avcodec_open() instead of calling this.
*/
attribute_deprecated
int avcodec_thread_init(AVCodecContext *s, int thread_count);
void avcodec_thread_free(AVCodecContext *s);
#endif
int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size);
int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int, int),void *arg, int *ret, int count);
//FIXME func typedef
@ -3781,25 +3666,6 @@ int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2,
*/
int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
#if FF_API_AUDIO_OLD
/**
* Decode an audio frame from buf into samples.
* Wrapper function which calls avcodec_decode_audio3.
*
* @deprecated Use avcodec_decode_audio3 instead.
* @param avctx the codec context
* @param[out] samples the output buffer
* @param[in,out] frame_size_ptr the output buffer size in bytes
* @param[in] buf the input buffer
* @param[in] buf_size the input buffer size in bytes
* @return On error a negative value is returned, otherwise the number of bytes
* used or zero if no frame could be decompressed.
*/
attribute_deprecated int avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples,
int *frame_size_ptr,
const uint8_t *buf, int buf_size);
#endif
/**
* Decode the audio frame of size avpkt->size from avpkt->data into samples.
* Some decoders may support multiple frames in a single AVPacket, such
@ -3843,25 +3709,6 @@ int avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,
int *frame_size_ptr,
AVPacket *avpkt);
#if FF_API_VIDEO_OLD
/**
* Decode a video frame from buf into picture.
* Wrapper function which calls avcodec_decode_video2.
*
* @deprecated Use avcodec_decode_video2 instead.
* @param avctx the codec context
* @param[out] picture The AVFrame in which the decoded video frame will be stored.
* @param[in] buf the input buffer
* @param[in] buf_size the size of the input buffer in bytes
* @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is nonzero.
* @return On error a negative value is returned, otherwise the number of bytes
* used or zero if no frame could be decompressed.
*/
attribute_deprecated int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture,
int *got_picture_ptr,
const uint8_t *buf, int buf_size);
#endif
/**
* Decode the video frame of size avpkt->size from avpkt->data into picture.
* Some decoders may support multiple frames in a single AVPacket, such
@ -3906,15 +3753,6 @@ int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
int *got_picture_ptr,
AVPacket *avpkt);
#if FF_API_SUBTITLE_OLD
/* Decode a subtitle message. Return -1 if error, otherwise return the
* number of bytes used. If no subtitle could be decompressed,
* got_sub_ptr is zero. Otherwise, the subtitle is stored in *sub. */
attribute_deprecated int avcodec_decode_subtitle(AVCodecContext *avctx, AVSubtitle *sub,
int *got_sub_ptr,
const uint8_t *buf, int buf_size);
#endif
/**
* Decode a subtitle message.
* Return a negative value on error, otherwise return the number of bytes used.
@ -4179,15 +4017,6 @@ AVCodecParser *av_parser_next(AVCodecParser *c);
void av_register_codec_parser(AVCodecParser *parser);
AVCodecParserContext *av_parser_init(int codec_id);
#if LIBAVCODEC_VERSION_MAJOR < 53
attribute_deprecated
int av_parser_parse(AVCodecParserContext *s,
AVCodecContext *avctx,
uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size,
int64_t pts, int64_t dts);
#endif
/**
* Parse a packet.
*
@ -4266,7 +4095,7 @@ AVBitStreamFilter *av_bitstream_filter_next(AVBitStreamFilter *f);
*
* @see av_realloc
*/
void *av_fast_realloc(void *ptr, unsigned int *size, FF_INTERNALC_MEM_TYPE min_size);
void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size);
/**
* Allocate a buffer, reusing the given one if large enough.
@ -4280,17 +4109,7 @@ void *av_fast_realloc(void *ptr, unsigned int *size, FF_INTERNALC_MEM_TYPE min_s
* @param min_size minimum size of *ptr buffer after returning, *ptr will be NULL and
* *size 0 if an error occurred.
*/
void av_fast_malloc(void *ptr, unsigned int *size, FF_INTERNALC_MEM_TYPE min_size);
#if LIBAVCODEC_VERSION_MAJOR < 53
/**
* @deprecated Deprecated in favor of av_image_copy().
*/
attribute_deprecated
void av_picture_data_copy(uint8_t *dst_data[4], int dst_linesize[4],
uint8_t *src_data[4], int src_linesize[4],
enum PixelFormat pix_fmt, int width, int height);
#endif
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size);
/**
* Copy image src to dst. Wraps av_picture_data_copy() above.
@ -4319,22 +4138,6 @@ int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width,
*/
unsigned int av_xiphlacing(unsigned char *s, unsigned int v);
#if LIBAVCODEC_VERSION_MAJOR < 53
/**
* Parse str and put in width_ptr and height_ptr the detected values.
*
* @deprecated Deprecated in favor of av_parse_video_size().
*/
attribute_deprecated int av_parse_video_frame_size(int *width_ptr, int *height_ptr, const char *str);
/**
* Parse str and store the detected values in *frame_rate.
*
* @deprecated Deprecated in favor of av_parse_video_rate().
*/
attribute_deprecated int av_parse_video_frame_rate(AVRational *frame_rate, const char *str);
#endif
/**
* Logs a generic warning message about a missing feature. This function is
* intended to be used internally by FFmpeg (libavcodec, libavformat, etc.)

8
libavcodec/dsputil.h
View File

@ -120,14 +120,6 @@ void ff_bink_idct_put_c(uint8_t *dest, int linesize, DCTELEM *block);
void ff_ea_idct_put_c(uint8_t *dest, int linesize, DCTELEM *block);
/* 1/2^n downscaling functions from imgconvert.c */
#if LIBAVCODEC_VERSION_MAJOR < 53
/**
* @deprecated Use av_image_copy_plane() instead.
*/
attribute_deprecated
void ff_img_copy_plane(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
#endif
void ff_shrink22(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
void ff_shrink44(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
void ff_shrink88(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);

11
libavcodec/flacenc.c
View File

@ -285,17 +285,6 @@ static av_cold int flac_encode_init(AVCodecContext *avctx)
s->options.max_partition_order = ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level];
/* set compression option overrides from AVCodecContext */
#if FF_API_USE_LPC
/* for compatibility with deprecated AVCodecContext.use_lpc */
if (avctx->use_lpc == 0) {
s->options.lpc_type = AV_LPC_TYPE_FIXED;
} else if (avctx->use_lpc == 1) {
s->options.lpc_type = AV_LPC_TYPE_LEVINSON;
} else if (avctx->use_lpc > 1) {
s->options.lpc_type = AV_LPC_TYPE_CHOLESKY;
s->options.lpc_passes = avctx->use_lpc - 1;
}
#endif
if (avctx->lpc_type > AV_LPC_TYPE_DEFAULT) {
if (avctx->lpc_type > AV_LPC_TYPE_CHOLESKY) {
av_log(avctx, AV_LOG_ERROR, "unknown lpc type: %d\n", avctx->lpc_type);

51
libavcodec/imgconvert.c
View File

@ -425,40 +425,11 @@ const char *avcodec_get_pix_fmt_name(enum PixelFormat pix_fmt)
return av_pix_fmt_descriptors[pix_fmt].name;
}
#if LIBAVCODEC_VERSION_MAJOR < 53
enum PixelFormat avcodec_get_pix_fmt(const char *name)
{
return av_get_pix_fmt(name);
}
void avcodec_pix_fmt_string (char *buf, int buf_size, enum PixelFormat pix_fmt)
{
av_get_pix_fmt_string(buf, buf_size, pix_fmt);
}
#endif
int ff_is_hwaccel_pix_fmt(enum PixelFormat pix_fmt)
{
return av_pix_fmt_descriptors[pix_fmt].flags & PIX_FMT_HWACCEL;
}
#if LIBAVCODEC_VERSION_MAJOR < 53
int ff_set_systematic_pal(uint32_t pal[256], enum PixelFormat pix_fmt){
return ff_set_systematic_pal2(pal, pix_fmt);
}
int ff_fill_linesize(AVPicture *picture, enum PixelFormat pix_fmt, int width)
{
return av_image_fill_linesizes(picture->linesize, pix_fmt, width);
}
int ff_fill_pointer(AVPicture *picture, uint8_t *ptr, enum PixelFormat pix_fmt,
int height)
{
return av_image_fill_pointers(picture->data, pix_fmt, height, ptr, picture->linesize);
}
#endif
int avpicture_fill(AVPicture *picture, uint8_t *ptr,
enum PixelFormat pix_fmt, int width, int height)
{
@ -693,28 +664,6 @@ enum PixelFormat avcodec_find_best_pix_fmt(int64_t pix_fmt_mask, enum PixelForma
return dst_pix_fmt;
}
#if LIBAVCODEC_VERSION_MAJOR < 53
void ff_img_copy_plane(uint8_t *dst, int dst_wrap,
const uint8_t *src, int src_wrap,
int width, int height)
{
av_image_copy_plane(dst, dst_wrap, src, src_wrap, width, height);
}
int ff_get_plane_bytewidth(enum PixelFormat pix_fmt, int width, int plane)
{
return av_image_get_linesize(pix_fmt, width, plane);
}
void av_picture_data_copy(uint8_t *dst_data[4], int dst_linesize[4],
uint8_t *src_data[4], int src_linesize[4],
enum PixelFormat pix_fmt, int width, int height)
{
av_image_copy(dst_data, dst_linesize, src_data, src_linesize,
pix_fmt, width, height);
}
#endif
void av_picture_copy(AVPicture *dst, const AVPicture *src,
enum PixelFormat pix_fmt, int width, int height)
{

8
libavcodec/libvo-aacenc.c
View File

@ -59,7 +59,7 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
if (s->codec_api.SetParam(s->handle, VO_PID_AAC_ENCPARAM, &params)
!= VO_ERR_NONE) {
av_log(avctx, AV_LOG_ERROR, "Unable to set encoding parameters\n");
return AVERROR_UNKNOWN;
return AVERROR(EINVAL);
}
for (index = 0; index < 16; index++)
@ -68,7 +68,7 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
if (index == 16) {
av_log(avctx, AV_LOG_ERROR, "Unsupported sample rate %d\n",
avctx->sample_rate);
return AVERROR_NOTSUPP;
return AVERROR(ENOSYS);
}
if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {
avctx->extradata_size = 2;
@ -110,14 +110,14 @@ static int aac_encode_frame(AVCodecContext *avctx,
if (s->codec_api.GetOutputData(s->handle, &output, &output_info)
!= VO_ERR_NONE) {
av_log(avctx, AV_LOG_ERROR, "Unable to encode frame\n");
return AVERROR_UNKNOWN;
return AVERROR(EINVAL);
}
return output.Length;
}
AVCodec ff_libvo_aacenc_encoder = {
"libvo_aacenc",
CODEC_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC,
sizeof(AACContext),
aac_encode_init,

2
libavcodec/libvo-amrwbenc.c
View File

@ -119,7 +119,7 @@ static int amr_wb_encode_frame(AVCodecContext *avctx,
AVCodec ff_libvo_amrwbenc_encoder = {
"libvo_amrwbenc",
CODEC_TYPE_AUDIO,
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_WB,
sizeof(AMRWBContext),
amr_wb_encode_init,

89
libavcodec/opt.c
View File

@ -1,89 +0,0 @@
/*
* AVOptions ABI compatibility wrapper
* Copyright (c) 2010 Michael Niedermayer <michaelni@gmx.at>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "avcodec.h"
#include "opt.h"
#if LIBAVCODEC_VERSION_MAJOR < 53 && CONFIG_SHARED && HAVE_SYMVER
FF_SYMVER(const AVOption *, av_find_opt, (void *obj, const char *name, const char *unit, int mask, int flags), "LIBAVCODEC_52"){
return av_find_opt(obj, name, unit, mask, flags);
}
FF_SYMVER(int, av_set_string3, (void *obj, const char *name, const char *val, int alloc, const AVOption **o_out), "LIBAVCODEC_52"){
return av_set_string3(obj, name, val, alloc, o_out);
}
FF_SYMVER(const AVOption *, av_set_double, (void *obj, const char *name, double n), "LIBAVCODEC_52"){
return av_set_double(obj, name, n);
}
FF_SYMVER(const AVOption *, av_set_q, (void *obj, const char *name, AVRational n), "LIBAVCODEC_52"){
return av_set_q(obj, name, n);
}
FF_SYMVER(const AVOption *, av_set_int, (void *obj, const char *name, int64_t n), "LIBAVCODEC_52"){
return av_set_int(obj, name, n);
}
FF_SYMVER(double, av_get_double, (void *obj, const char *name, const AVOption **o_out), "LIBAVCODEC_52"){
return av_get_double(obj, name, o_out);
}
FF_SYMVER(AVRational, av_get_q, (void *obj, const char *name, const AVOption **o_out), "LIBAVCODEC_52"){
return av_get_q(obj, name, o_out);
}
FF_SYMVER(int64_t, av_get_int, (void *obj, const char *name, const AVOption **o_out), "LIBAVCODEC_52"){
return av_get_int(obj, name, o_out);
}
FF_SYMVER(const char *, av_get_string, (void *obj, const char *name, const AVOption **o_out, char *buf, int buf_len), "LIBAVCODEC_52"){
return av_get_string(obj, name, o_out, buf, buf_len);
}
FF_SYMVER(const AVOption *, av_next_option, (void *obj, const AVOption *last), "LIBAVCODEC_52"){
return av_next_option(obj, last);
}
FF_SYMVER(int, av_opt_show2, (void *obj, void *av_log_obj, int req_flags, int rej_flags), "LIBAVCODEC_52"){
return av_opt_show2(obj, av_log_obj, req_flags, rej_flags);
}
FF_SYMVER(void, av_opt_set_defaults, (void *s), "LIBAVCODEC_52"){
return av_opt_set_defaults(s);
}
FF_SYMVER(void, av_opt_set_defaults2, (void *s, int mask, int flags), "LIBAVCODEC_52"){
return av_opt_set_defaults2(s, mask, flags);
}
#endif
#if FF_API_SET_STRING_OLD
const AVOption *av_set_string2(void *obj, const char *name, const char *val, int alloc){
const AVOption *o;
if (av_set_string3(obj, name, val, alloc, &o) < 0)
return NULL;
return o;
}
const AVOption *av_set_string(void *obj, const char *name, const char *val){
const AVOption *o;
if (av_set_string3(obj, name, val, 0, &o) < 0)
return NULL;
return o;
}
#endif
#if FF_API_OPT_SHOW
int av_opt_show(void *obj, void *av_log_obj){
return av_opt_show2(obj, av_log_obj,
AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
}
#endif

55
libavcodec/opt.h
View File

@ -1,55 +0,0 @@
/*
* AVOptions
* copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVCODEC_OPT_H
#define AVCODEC_OPT_H
/**
* @file
* AVOptions
*/
#include "libavutil/rational.h"
#include "avcodec.h"
#include "libavutil/opt.h"
#if FF_API_SET_STRING_OLD
/**
* @see av_set_string2()
*/
attribute_deprecated const AVOption *av_set_string(void *obj, const char *name, const char *val);
/**
* @return a pointer to the AVOption corresponding to the field set or
* NULL if no matching AVOption exists, or if the value val is not
* valid
* @see av_set_string3()
*/
attribute_deprecated const AVOption *av_set_string2(void *obj, const char *name, const char *val, int alloc);
#endif
#if FF_API_OPT_SHOW
/**
* @deprecated Use av_opt_show2() instead.
*/
attribute_deprecated int av_opt_show(void *obj, void *av_log_obj);
#endif
#endif /* AVCODEC_OPT_H */

9
libavcodec/options.c
View File

@ -113,9 +113,6 @@ static const AVOption options[]={
{"cutoff", "set cutoff bandwidth", OFFSET(cutoff), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, A|E},
{"frame_size", NULL, OFFSET(frame_size), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, A|E},
{"frame_number", NULL, OFFSET(frame_number), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
#if LIBAVCODEC_VERSION_MAJOR < 53
{"real_pict_num", NULL, OFFSET(real_pict_num), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
#endif
{"delay", NULL, OFFSET(delay), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX},
{"qcomp", "video quantizer scale compression (VBR)", OFFSET(qcompress), FF_OPT_TYPE_FLOAT, 0.5, -FLT_MAX, FLT_MAX, V|E},
{"qblur", "video quantizer scale blur (VBR)", OFFSET(qblur), FF_OPT_TYPE_FLOAT, 0.5, 0, FLT_MAX, V|E},
@ -164,9 +161,6 @@ static const AVOption options[]={
{"very", "strictly conform to a older more strict version of the spec or reference software", 0, FF_OPT_TYPE_CONST, FF_COMPLIANCE_VERY_STRICT, INT_MIN, INT_MAX, V|D|E, "strict"},
{"strict", "strictly conform to all the things in the spec no matter what consequences", 0, FF_OPT_TYPE_CONST, FF_COMPLIANCE_STRICT, INT_MIN, INT_MAX, V|D|E, "strict"},
{"normal", NULL, 0, FF_OPT_TYPE_CONST, FF_COMPLIANCE_NORMAL, INT_MIN, INT_MAX, V|D|E, "strict"},
#if FF_API_INOFFICIAL
{"inofficial", "allow unofficial extensions (deprecated - use unofficial)", 0, FF_OPT_TYPE_CONST, FF_COMPLIANCE_UNOFFICIAL, INT_MIN, INT_MAX, V|D|E, "strict"},
#endif
{"unofficial", "allow unofficial extensions", 0, FF_OPT_TYPE_CONST, FF_COMPLIANCE_UNOFFICIAL, INT_MIN, INT_MAX, V|D|E, "strict"},
{"experimental", "allow non standardized experimental things", 0, FF_OPT_TYPE_CONST, FF_COMPLIANCE_EXPERIMENTAL, INT_MIN, INT_MAX, V|D|E, "strict"},
{"b_qoffset", "qp offset between P and B frames", OFFSET(b_quant_offset), FF_OPT_TYPE_FLOAT, 1.25, -FLT_MAX, FLT_MAX, V|E},
@ -396,9 +390,6 @@ static const AVOption options[]={
{"ivlc", "intra vlc table", 0, FF_OPT_TYPE_CONST, CODEC_FLAG2_INTRA_VLC, INT_MIN, INT_MAX, V|E, "flags2"},
{"b_sensitivity", "adjusts sensitivity of b_frame_strategy 1", OFFSET(b_sensitivity), FF_OPT_TYPE_INT, 40, 1, INT_MAX, V|E},
{"compression_level", NULL, OFFSET(compression_level), FF_OPT_TYPE_INT, FF_COMPRESSION_DEFAULT, INT_MIN, INT_MAX, V|A|E},
#if FF_API_USE_LPC
{"use_lpc", "sets whether to use LPC mode (FLAC)", OFFSET(use_lpc), FF_OPT_TYPE_INT, -1, INT_MIN, INT_MAX, A|E},
#endif
{"lpc_coeff_precision", "LPC coefficient precision (FLAC)", OFFSET(lpc_coeff_precision), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, A|E},
{"min_prediction_order", NULL, OFFSET(min_prediction_order), FF_OPT_TYPE_INT, -1, INT_MIN, INT_MAX, A|E},
{"max_prediction_order", NULL, OFFSET(max_prediction_order), FF_OPT_TYPE_INT, -1, INT_MIN, INT_MAX, A|E},

37
libavcodec/parser.c
View File

@ -105,43 +105,6 @@ void ff_fetch_timestamp(AVCodecParserContext *s, int off, int remove){
}
}
#if LIBAVCODEC_VERSION_MAJOR < 53
/**
*
* @param buf input
* @param buf_size input length, to signal EOF, this should be 0 (so that the last frame can be output)
* @param pts input presentation timestamp
* @param dts input decoding timestamp
* @param poutbuf will contain a pointer to the first byte of the output frame
* @param poutbuf_size will contain the length of the output frame
* @return the number of bytes of the input bitstream used
*
* Example:
* @code
* while(in_len){
* len = av_parser_parse(myparser, AVCodecContext, &data, &size,
* in_data, in_len,
* pts, dts);
* in_data += len;
* in_len -= len;
*
* if(size)
* decode_frame(data, size);
* }
* @endcode
*
* @deprecated Use av_parser_parse2() instead.
*/
int av_parser_parse(AVCodecParserContext *s,
AVCodecContext *avctx,
uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size,
int64_t pts, int64_t dts)
{
return av_parser_parse2(s, avctx, poutbuf, poutbuf_size, buf, buf_size, pts, dts, AV_NOPTS_VALUE);
}
#endif
int av_parser_parse2(AVCodecParserContext *s,
AVCodecContext *avctx,
uint8_t **poutbuf, int *poutbuf_size,

2
libavcodec/pcm.c
View File

@ -71,7 +71,7 @@ static av_cold int pcm_encode_close(AVCodecContext *avctx)
* @param offset Sample value offset
*/
#define ENCODE(type, endian, src, dst, n, shift, offset) \
samples_##type = (type*)src; \
samples_##type = (const type*) src; \
for(;n>0;n--) { \
register type v = (*samples_##type++ >> shift) + offset; \
bytestream_put_##endian(&dst, v); \

11
libavcodec/resample.c
View File

@ -218,17 +218,6 @@ ReSampleContext *av_audio_resample_init(int output_channels, int input_channels,
return s;
}
#if FF_API_AUDIO_OLD
ReSampleContext *audio_resample_init(int output_channels, int input_channels,
int output_rate, int input_rate)
{
return av_audio_resample_init(output_channels, input_channels,
output_rate, input_rate,
AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16,
TAPS, 10, 0, 0.8);
}
#endif
/* resample audio. 'nb_samples' is the number of input samples */
/* XXX: optimize it ! */
int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples)

86
libavcodec/utils.c
View File

@ -48,7 +48,7 @@ static int volatile entangled_thread_counter=0;
static int (*ff_lockmgr_cb)(void **mutex, enum AVLockOp op);
static void *codec_mutex;
void *av_fast_realloc(void *ptr, unsigned int *size, FF_INTERNALC_MEM_TYPE min_size)
void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
{
if(min_size < *size)
return ptr;
@ -64,7 +64,7 @@ void *av_fast_realloc(void *ptr, unsigned int *size, FF_INTERNALC_MEM_TYPE min_s
return ptr;
}
void av_fast_malloc(void *ptr, unsigned int *size, FF_INTERNALC_MEM_TYPE min_size)
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
{
void **p = ptr;
if (min_size < *size)
@ -94,13 +94,6 @@ void avcodec_register(AVCodec *codec)
codec->next = NULL;
}
#if LIBAVCODEC_VERSION_MAJOR < 53
void register_avcodec(AVCodec *codec)
{
avcodec_register(codec);
}
#endif
unsigned avcodec_get_edge_width(void)
{
return EDGE_WIDTH;
@ -224,12 +217,6 @@ void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height){
*width=FFALIGN(*width, align);
}
#if LIBAVCODEC_VERSION_MAJOR < 53
int avcodec_check_dimensions(void *av_log_ctx, unsigned int w, unsigned int h){
return av_image_check_size(w, h, 0, av_log_ctx);
}
#endif
int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){
int i;
int w= s->width;
@ -482,7 +469,7 @@ static void avcodec_get_subtitle_defaults(AVSubtitle *sub)
int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec)
{
int ret= -1;
int ret = 0;
/* If there is a user-supplied mutex locking routine, call it. */
if (ff_lockmgr_cb) {
@ -493,11 +480,14 @@ int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec)
entangled_thread_counter++;
if(entangled_thread_counter != 1){
av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
ret = -1;
goto end;
}
if(avctx->codec || !codec)
if(avctx->codec || !codec) {
ret = AVERROR(EINVAL);
goto end;
}
if (codec->priv_data_size > 0) {
if(!avctx->priv_data){
@ -547,6 +537,7 @@ int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec)
if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
&& avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
av_log(avctx, AV_LOG_ERROR, "codec type or id mismatches\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
avctx->frame_number = 0;
@ -561,6 +552,7 @@ int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec)
if (avctx->codec->max_lowres < avctx->lowres) {
av_log(avctx, AV_LOG_ERROR, "The maximum value for lowres supported by the decoder is %d\n",
avctx->codec->max_lowres);
ret = AVERROR(EINVAL);
goto free_and_end;
}
if (avctx->codec->sample_fmts && avctx->codec->encode) {
@ -570,6 +562,7 @@ int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec)
break;
if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
av_log(avctx, AV_LOG_ERROR, "Specified sample_fmt is not supported.\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
@ -736,20 +729,6 @@ int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *pi
return ret;
}
#if FF_API_AUDIO_OLD
int attribute_align_arg avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples,
int *frame_size_ptr,
const uint8_t *buf, int buf_size)
{
AVPacket avpkt;
av_init_packet(&avpkt);
avpkt.data = buf;
avpkt.size = buf_size;
return avcodec_decode_audio3(avctx, samples, frame_size_ptr, &avpkt);
}
#endif
int attribute_align_arg avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,
int *frame_size_ptr,
AVPacket *avpkt)
@ -779,20 +758,6 @@ int attribute_align_arg avcodec_decode_audio3(AVCodecContext *avctx, int16_t *sa
return ret;
}
#if FF_API_SUBTITLE_OLD
int avcodec_decode_subtitle(AVCodecContext *avctx, AVSubtitle *sub,
int *got_sub_ptr,
const uint8_t *buf, int buf_size)
{
AVPacket avpkt;
av_init_packet(&avpkt);
avpkt.data = buf;
avpkt.size = buf_size;
return avcodec_decode_subtitle2(avctx, sub, got_sub_ptr, &avpkt);
}
#endif
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
int *got_sub_ptr,
AVPacket *avpkt)
@ -1225,20 +1190,6 @@ unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
return n;
}
#if LIBAVCODEC_VERSION_MAJOR < 53
#include "libavutil/parseutils.h"
int av_parse_video_frame_size(int *width_ptr, int *height_ptr, const char *str)
{
return av_parse_video_size(width_ptr, height_ptr, str);
}
int av_parse_video_frame_rate(AVRational *frame_rate, const char *arg)
{
return av_parse_video_rate(frame_rate, arg);
}
#endif
int ff_match_2uint16(const uint16_t (*tab)[2], int size, int a, int b){
int i;
for(i=0; i<size && !(tab[i][0]==a && tab[i][1]==b); i++);
@ -1344,20 +1295,3 @@ void ff_thread_await_progress(AVFrame *f, int progress, int field)
}
#endif
#if LIBAVCODEC_VERSION_MAJOR < 53
int avcodec_thread_init(AVCodecContext *s, int thread_count)
{
s->thread_count = thread_count;
return ff_thread_init(s);
}
void avcodec_thread_free(AVCodecContext *s)
{
#if HAVE_THREADS
ff_thread_free(s);
#endif
}
#endif

28
libavcodec/version.h
View File

@ -20,8 +20,8 @@
#ifndef AVCODEC_VERSION_H
#define AVCODEC_VERSION_H
#define LIBAVCODEC_VERSION_MAJOR 52
#define LIBAVCODEC_VERSION_MINOR 120
#define LIBAVCODEC_VERSION_MAJOR 53
#define LIBAVCODEC_VERSION_MINOR 0
#define LIBAVCODEC_VERSION_MICRO 0
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
@ -41,30 +41,6 @@
#ifndef FF_API_PALETTE_CONTROL
#define FF_API_PALETTE_CONTROL (LIBAVCODEC_VERSION_MAJOR < 54)
#endif
#ifndef FF_API_MM_FLAGS
#define FF_API_MM_FLAGS (LIBAVCODEC_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_OPT_SHOW
#define FF_API_OPT_SHOW (LIBAVCODEC_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_AUDIO_OLD
#define FF_API_AUDIO_OLD (LIBAVCODEC_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_VIDEO_OLD
#define FF_API_VIDEO_OLD (LIBAVCODEC_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_SUBTITLE_OLD
#define FF_API_SUBTITLE_OLD (LIBAVCODEC_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_USE_LPC
#define FF_API_USE_LPC (LIBAVCODEC_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_SET_STRING_OLD
#define FF_API_SET_STRING_OLD (LIBAVCODEC_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_INOFFICIAL
#define FF_API_INOFFICIAL (LIBAVCODEC_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_OLD_SAMPLE_FMT
#define FF_API_OLD_SAMPLE_FMT (LIBAVCODEC_VERSION_MAJOR < 54)
#endif

21
libavcodec/xvmc.h
View File

@ -25,11 +25,6 @@
#include "avcodec.h"
#if LIBAVCODEC_VERSION_MAJOR < 53
#define AV_XVMC_STATE_DISPLAY_PENDING 1 /** the surface should be shown, the video driver manipulates this */
#define AV_XVMC_STATE_PREDICTION 2 /** the surface is needed for prediction, the codec manipulates this */
#define AV_XVMC_STATE_OSD_SOURCE 4 /** the surface is needed for subpicture rendering */
#endif
#define AV_XVMC_ID 0x1DC711C0 /**< special value to ensure that regular pixel routines haven't corrupted the struct
the number is 1337 speak for the letters IDCT MCo (motion compensation) */
@ -151,22 +146,6 @@ struct xvmc_pix_fmt {
of coded blocks it contains.
*/
int next_free_data_block_num;
/** extensions may be placed here */
#if LIBAVCODEC_VERSION_MAJOR < 53
//@{
/** State flags used to work around limitations in the MPlayer video system.
0 - Surface is not used.
1 - Surface is still held in application to be displayed or is
still visible.
2 - Surface is still held in libavcodec buffer for prediction.
*/
int state;
/** pointer to the surface where the subpicture is rendered */
void* p_osd_target_surface_render;
//}@
#endif
};
#endif /* AVCODEC_XVMC_H */

4
libavdevice/avdevice.h
View File

@ -21,8 +21,8 @@
#include "libavutil/avutil.h"
#define LIBAVDEVICE_VERSION_MAJOR 52
#define LIBAVDEVICE_VERSION_MINOR 4
#define LIBAVDEVICE_VERSION_MAJOR 53
#define LIBAVDEVICE_VERSION_MINOR 0
#define LIBAVDEVICE_VERSION_MICRO 0
#define LIBAVDEVICE_VERSION_INT AV_VERSION_INT(LIBAVDEVICE_VERSION_MAJOR, \

6
libavfilter/avfilter.h
View File

@ -25,9 +25,9 @@
#include "libavutil/avutil.h"
#include "libavutil/samplefmt.h"
#define LIBAVFILTER_VERSION_MAJOR 1
#define LIBAVFILTER_VERSION_MINOR 79
#define LIBAVFILTER_VERSION_MICRO 1
#define LIBAVFILTER_VERSION_MAJOR 2
#define LIBAVFILTER_VERSION_MINOR 0
#define LIBAVFILTER_VERSION_MICRO 0
#define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
LIBAVFILTER_VERSION_MINOR, \

1
libavformat/Makefile
View File

@ -10,7 +10,6 @@ OBJS = allformats.o \
id3v1.o \
id3v2.o \
metadata.o \
metadata_compat.o \
options.o \
os_support.o \
sdp.o \

4
libavformat/applehttp.c
View File

@ -170,7 +170,7 @@ static int parse_playlist(AppleHTTPContext *c, const char *url,
if (!in) {
close_in = 1;
if ((ret = avio_open(&in, url, AVIO_RDONLY)) < 0)
if ((ret = avio_open(&in, url, AVIO_FLAG_READ)) < 0)
return ret;
}
@ -293,7 +293,7 @@ reload:
ret = ffurl_open(&v->input,
v->segments[v->cur_seq_no - v->start_seq_no]->url,
AVIO_RDONLY);
AVIO_FLAG_READ);
if (ret < 0)
return ret;
}

6
libavformat/applehttpproto.c
View File

@ -115,7 +115,7 @@ static int parse_playlist(URLContext *h, const char *url)
char line[1024];
const char *ptr;
if ((ret = avio_open(&in, url, AVIO_RDONLY)) < 0)
if ((ret = avio_open(&in, url, AVIO_FLAG_READ)) < 0)
return ret;
read_chomp_line(in, line, sizeof(line));
@ -180,7 +180,7 @@ static int applehttp_open(URLContext *h, const char *uri, int flags)
int ret, i;
const char *nested_url;
if (flags & (AVIO_WRONLY | AVIO_RDWR))
if (flags & AVIO_FLAG_WRITE)
return AVERROR(ENOSYS);
s = av_mallocz(sizeof(AppleHTTPContext));
@ -275,7 +275,7 @@ retry:
}
url = s->segments[s->cur_seq_no - s->start_seq_no]->url,
av_log(NULL, AV_LOG_DEBUG, "opening %s\n", url);
ret = ffurl_open(&s->seg_hd, url, AVIO_RDONLY);
ret = ffurl_open(&s->seg_hd, url, AVIO_FLAG_READ);
if (ret < 0) {
if (url_interrupt_cb())
return AVERROR_EXIT;

103
libavformat/avformat.h
View File

@ -133,20 +133,6 @@ typedef struct AVMetadataConv AVMetadataConv;
AVMetadataTag *
av_metadata_get(AVMetadata *m, const char *key, const AVMetadataTag *prev, int flags);
#if FF_API_OLD_METADATA
/**
* Set the given tag in *pm, overwriting an existing tag.
*
* @param pm pointer to a pointer to a metadata struct. If *pm is NULL
* a metadata struct is allocated and put in *pm.
* @param key tag key to add to *pm (will be av_strduped)
* @param value tag value to add to *pm (will be av_strduped)
* @return >= 0 on success otherwise an error code <0
* @deprecated Use av_metadata_set2() instead.
*/
attribute_deprecated int av_metadata_set(AVMetadata **pm, const char *key, const char *value);
#endif
/**
* Set the given tag in *pm, overwriting an existing tag.
*
@ -256,10 +242,6 @@ typedef struct AVFormatParameters {
unsigned int initial_pause:1; /**< Do not begin to play the stream
immediately (RTSP only). */
unsigned int prealloced_context:1;
#if FF_API_PARAMETERS_CODEC_ID
attribute_deprecated enum CodecID video_codec_id;
attribute_deprecated enum CodecID audio_codec_id;
#endif
} AVFormatParameters;
//! Demuxer will use avio_open, no opened file should be provided by the caller.
@ -546,10 +528,6 @@ typedef struct AVStream {
*/
int64_t duration;
#if FF_API_OLD_METADATA
attribute_deprecated char language[4]; /**< ISO 639-2/B 3-letter language code (empty string if undefined) */
#endif
/* av_read_frame() support */
enum AVStreamParseType need_parsing;
struct AVCodecParserContext *parser;
@ -565,14 +543,6 @@ typedef struct AVStream {
int64_t nb_frames; ///< number of frames in this stream if known or 0
#if FF_API_LAVF_UNUSED
attribute_deprecated int64_t unused[4+1];
#endif
#if FF_API_OLD_METADATA
attribute_deprecated char *filename; /**< source filename of the stream */
#endif
int disposition; /**< AV_DISPOSITION_* bit field */
AVProbeData probe_data;
@ -656,10 +626,6 @@ typedef struct AVStream {
*/
typedef struct AVProgram {
int id;
#if FF_API_OLD_METADATA
attribute_deprecated char *provider_name; ///< network name for DVB streams
attribute_deprecated char *name; ///< service name for DVB streams
#endif
int flags;
enum AVDiscard discard; ///< selects which program to discard and which to feed to the caller
unsigned int *stream_index;
@ -674,16 +640,9 @@ typedef struct AVChapter {
int id; ///< unique ID to identify the chapter
AVRational time_base; ///< time base in which the start/end timestamps are specified
int64_t start, end; ///< chapter start/end time in time_base units
#if FF_API_OLD_METADATA
attribute_deprecated char *title; ///< chapter title
#endif
AVMetadata *metadata;
} AVChapter;
#if FF_API_MAX_STREAMS
#define MAX_STREAMS 20
#endif
/**
* Format I/O context.
* New fields can be added to the end with minor version bumps.
@ -699,24 +658,10 @@ typedef struct AVFormatContext {
void *priv_data;
AVIOContext *pb;
unsigned int nb_streams;
#if FF_API_MAX_STREAMS
AVStream *streams[MAX_STREAMS];
#else
AVStream **streams;
#endif
char filename[1024]; /**< input or output filename */
/* stream info */
int64_t timestamp;
#if FF_API_OLD_METADATA
attribute_deprecated char title[512];
attribute_deprecated char author[512];
attribute_deprecated char copyright[512];
attribute_deprecated char comment[512];
attribute_deprecated char album[512];
attribute_deprecated int year; /**< ID3 year, 0 if none */
attribute_deprecated int track; /**< track number, 0 if none */
attribute_deprecated char genre[32]; /**< ID3 genre */
#endif
int ctx_flags; /**< Format-specific flags, see AVFMTCTX_xx */
/* private data for pts handling (do not modify directly). */
@ -756,17 +701,9 @@ typedef struct AVFormatContext {
/* av_read_frame() support */
AVStream *cur_st;
#if FF_API_LAVF_UNUSED
const uint8_t *cur_ptr_deprecated;
int cur_len_deprecated;
AVPacket cur_pkt_deprecated;
#endif
/* av_seek_frame() support */
int64_t data_offset; /**< offset of the first packet */
#if FF_API_INDEX_BUILT
attribute_deprecated int index_built;
#endif
int mux_rate;
unsigned int packet_size;
@ -888,11 +825,6 @@ typedef struct AVPacketList {
struct AVPacketList *next;
} AVPacketList;
#if FF_API_FIRST_FORMAT
attribute_deprecated extern AVInputFormat *first_iformat;
attribute_deprecated extern AVOutputFormat *first_oformat;
#endif
/**
* If f is NULL, returns the first registered input format,
* if f is non-NULL, returns the next registered input format after f
@ -917,18 +849,6 @@ attribute_deprecated enum CodecID av_guess_image2_codec(const char *filename);
/* utils.c */
void av_register_input_format(AVInputFormat *format);
void av_register_output_format(AVOutputFormat *format);
#if FF_API_GUESS_FORMAT
attribute_deprecated AVOutputFormat *guess_stream_format(const char *short_name,
const char *filename,
const char *mime_type);
/**
* @deprecated Use av_guess_format() instead.
*/
attribute_deprecated AVOutputFormat *guess_format(const char *short_name,
const char *filename,
const char *mime_type);
#endif
/**
* Return the output format in the list of registered output formats
@ -1119,13 +1039,6 @@ int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
int buf_size,
AVFormatParameters *ap);
#if FF_API_ALLOC_FORMAT_CONTEXT
/**
* @deprecated Use avformat_alloc_context() instead.
*/
attribute_deprecated AVFormatContext *av_alloc_format_context(void);
#endif
/**
* Allocate an AVFormatContext.
* avformat_free_context() can be used to free the context and everything
@ -1492,22 +1405,6 @@ void av_dump_format(AVFormatContext *ic,
const char *url,
int is_output);
#if FF_API_PARSE_FRAME_PARAM
/**
* Parse width and height out of string str.
* @deprecated Use av_parse_video_frame_size instead.
*/
attribute_deprecated int parse_image_size(int *width_ptr, int *height_ptr,
const char *str);
/**
* Convert framerate from a string to a fraction.
* @deprecated Use av_parse_video_frame_rate instead.
*/
attribute_deprecated int parse_frame_rate(int *frame_rate, int *frame_rate_base,
const char *arg);
#endif
#if FF_API_PARSE_DATE
/**
* Parse datestr and return a corresponding number of microseconds.

37
libavformat/avio.c
View File

@ -31,7 +31,6 @@
#endif
#include "url.h"
#if FF_API_URL_CLASS
/** @name Logging context. */
/*@{*/
static const char *urlcontext_to_name(void *ptr)
@ -44,7 +43,6 @@ static const AVOption options[] = {{NULL}};
static const AVClass urlcontext_class =
{ "URLContext", urlcontext_to_name, options, LIBAVUTIL_VERSION_INT };
/*@}*/
#endif
static int default_interrupt_cb(void);
@ -82,29 +80,6 @@ int ffurl_register_protocol(URLProtocol *protocol, int size)
return 0;
}
#if FF_API_REGISTER_PROTOCOL
/* The layout of URLProtocol as of when major was bumped to 52 */
struct URLProtocol_compat {
const char *name;
int (*url_open)(URLContext *h, const char *filename, int flags);
int (*url_read)(URLContext *h, unsigned char *buf, int size);
int (*url_write)(URLContext *h, unsigned char *buf, int size);
int64_t (*url_seek)(URLContext *h, int64_t pos, int whence);
int (*url_close)(URLContext *h);
struct URLProtocol *next;
};
int av_register_protocol(URLProtocol *protocol)
{
return ffurl_register_protocol(protocol, sizeof(struct URLProtocol_compat));
}
int register_protocol(URLProtocol *protocol)
{
return ffurl_register_protocol(protocol, sizeof(struct URLProtocol_compat));
}
#endif
static int url_alloc_for_protocol (URLContext **puc, struct URLProtocol *up,
const char *filename, int flags)
{
@ -120,9 +95,7 @@ static int url_alloc_for_protocol (URLContext **puc, struct URLProtocol *up,
err = AVERROR(ENOMEM);
goto fail;
}
#if FF_API_URL_CLASS
uc->av_class = &urlcontext_class;
#endif
uc->filename = (char *) &uc[1];
strcpy(uc->filename, filename);
uc->prot = up;
@ -154,7 +127,7 @@ int ffurl_connect(URLContext* uc)
return err;
uc->is_connected = 1;
//We must be careful here as ffurl_seek() could be slow, for example for http
if( (uc->flags & (AVIO_WRONLY | AVIO_RDWR))
if( (uc->flags & AVIO_FLAG_WRITE)
|| !strcmp(uc->prot->name, "file"))
if(!uc->is_streamed && ffurl_seek(uc, 0, SEEK_SET) < 0)
uc->is_streamed= 1;
@ -314,21 +287,21 @@ static inline int retry_transfer_wrapper(URLContext *h, unsigned char *buf, int
int ffurl_read(URLContext *h, unsigned char *buf, int size)
{
if (h->flags & AVIO_WRONLY)
if (h->flags & AVIO_FLAG_WRITE)
return AVERROR(EIO);
return retry_transfer_wrapper(h, buf, size, 1, h->prot->url_read);
}
int ffurl_read_complete(URLContext *h, unsigned char *buf, int size)
{
if (h->flags & AVIO_WRONLY)
if (h->flags & AVIO_FLAG_WRITE)
return AVERROR(EIO);
return retry_transfer_wrapper(h, buf, size, size, h->prot->url_read);
}
int ffurl_write(URLContext *h, const unsigned char *buf, int size)
{
if (!(h->flags & (AVIO_WRONLY | AVIO_RDWR)))
if (!(h->flags & AVIO_FLAG_WRITE))
return AVERROR(EIO);
/* avoid sending too big packets */
if (h->max_packet_size && size > h->max_packet_size)
@ -367,7 +340,7 @@ int ffurl_close(URLContext *h)
int url_exist(const char *filename)
{
URLContext *h;
if (ffurl_open(&h, filename, AVIO_RDONLY) < 0)
if (ffurl_open(&h, filename, AVIO_FLAG_READ) < 0)
return 0;
ffurl_close(h);
return 1;

51
libavformat/avio.h
View File

@ -101,9 +101,7 @@ typedef struct {
* @deprecated This struct will be made private
*/
typedef struct URLContext {
#if FF_API_URL_CLASS
const AVClass *av_class; ///< information for av_log(). Set by url_open().
#endif
struct URLProtocol *prot;
int flags;
int is_streamed; /**< true if streamed (no seek possible), default = false */
@ -346,7 +344,7 @@ attribute_deprecated int url_exist(const char *url);
#endif // FF_API_OLD_AVIO
/**
* Return AVIO_* access flags corresponding to the access permissions
* Return AVIO_FLAG_* access flags corresponding to the access permissions
* of the resource in url, or a negative value corresponding to an
* AVERROR code in case of failure. The returned access flags are
* masked by the value in flags.
@ -356,9 +354,6 @@ attribute_deprecated int url_exist(const char *url);
* one call to another. Thus you should not trust the returned value,
* unless you are sure that no other processes are accessing the
* checked resource.
*
* @note This function is slightly broken until next major bump
* because of AVIO_RDONLY == 0. Don't use it until then.
*/
int avio_check(const char *url, int flags);
@ -370,22 +365,6 @@ int avio_check(const char *url, int flags);
*/
void avio_set_interrupt_cb(int (*interrupt_cb)(void));
#if FF_API_REGISTER_PROTOCOL
extern URLProtocol *first_protocol;
#endif
#if FF_API_REGISTER_PROTOCOL
/**
* @deprecated Use av_register_protocol() instead.
*/
attribute_deprecated int register_protocol(URLProtocol *protocol);
/**
* @deprecated Use av_register_protocol2() instead.
*/
attribute_deprecated int av_register_protocol(URLProtocol *protocol);
#endif
/**
* Allocate and initialize an AVIOContext for buffered I/O. It must be later
* freed with av_free().
@ -542,29 +521,15 @@ int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen);
int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen);
#if FF_API_URL_RESETBUF
/** Reset the buffer for reading or writing.
* @note Will drop any data currently in the buffer without transmitting it.
* @param flags URL_RDONLY to set up the buffer for reading, or URL_WRONLY
* to set up the buffer for writing. */
int url_resetbuf(AVIOContext *s, int flags);
#endif
/**
* @defgroup open_modes URL open modes
* The flags argument to avio_open must be one of the following
* constants, optionally ORed with other flags.
* @{
*/
#if LIBAVFORMAT_VERSION_MAJOR < 53
#define AVIO_RDONLY 0 /**< read-only */
#define AVIO_WRONLY 1 /**< write-only */
#define AVIO_RDWR 2 /**< read-write */
#else
#define AVIO_RDONLY 1 /**< read-only */
#define AVIO_WRONLY 2 /**< write-only */
#define AVIO_RDWR 4 /**< read-write */
#endif
#define AVIO_FLAG_READ 1 /**< read-only */
#define AVIO_FLAG_WRITE 2 /**< write-only */
#define AVIO_FLAG_READ_WRITE (AVIO_FLAG_READ|AVIO_FLAG_WRITE) /**< read-write pseudo flag */
/**
* @}
*/
@ -581,11 +546,7 @@ int url_resetbuf(AVIOContext *s, int flags);
* Warning: non-blocking protocols is work-in-progress; this flag may be
* silently ignored.
*/
#if LIBAVFORMAT_VERSION_MAJOR < 53
#define AVIO_FLAG_NONBLOCK 4
#else
#define AVIO_FLAG_NONBLOCK 8
#endif
/**
* Create and initialize a AVIOContext for accessing the
@ -629,10 +590,6 @@ int avio_open_dyn_buf(AVIOContext **s);
*/
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
#if FF_API_UDP_GET_FILE
int udp_get_file_handle(URLContext *h);
#endif
/**
* Iterate through names of available protocols.
* @note it is recommanded to use av_protocol_next() instead of this

23
libavformat/aviobuf.c
View File

@ -38,9 +38,7 @@
#define SHORT_SEEK_THRESHOLD 4096
static void fill_buffer(AVIOContext *s);
#if !FF_API_URL_RESETBUF
static int url_resetbuf(AVIOContext *s, int flags);
#endif
int ffio_init_context(AVIOContext *s,
unsigned char *buffer,
@ -55,7 +53,7 @@ int ffio_init_context(AVIOContext *s,
s->buffer_size = buffer_size;
s->buf_ptr = buffer;
s->opaque = opaque;
url_resetbuf(s, write_flag ? AVIO_WRONLY : AVIO_RDONLY);
url_resetbuf(s, write_flag ? AVIO_FLAG_WRITE : AVIO_FLAG_READ);
s->write_packet = write_packet;
s->read_packet = read_packet;
s->seek = seek;
@ -854,7 +852,7 @@ int ffio_fdopen(AVIOContext **s, URLContext *h)
}
if (ffio_init_context(*s, buffer, buffer_size,
(h->flags & AVIO_WRONLY || h->flags & AVIO_RDWR), h,
h->flags & AVIO_FLAG_WRITE, h,
ffurl_read, ffurl_write, ffurl_seek) < 0) {
av_free(buffer);
av_freep(s);
@ -883,24 +881,15 @@ int ffio_set_buf_size(AVIOContext *s, int buf_size)
s->buffer = buffer;
s->buffer_size = buf_size;
s->buf_ptr = buffer;
url_resetbuf(s, s->write_flag ? AVIO_WRONLY : AVIO_RDONLY);
url_resetbuf(s, s->write_flag ? AVIO_FLAG_WRITE : AVIO_FLAG_READ);
return 0;
}
#if FF_API_URL_RESETBUF
int url_resetbuf(AVIOContext *s, int flags)
#else
static int url_resetbuf(AVIOContext *s, int flags)
#endif
{
#if FF_API_URL_RESETBUF
if (flags & AVIO_RDWR)
return AVERROR(EINVAL);
#else
assert(flags == AVIO_WRONLY || flags == AVIO_RDONLY);
#endif
assert(flags == AVIO_FLAG_WRITE || flags == AVIO_FLAG_READ);
if (flags & AVIO_WRONLY) {
if (flags & AVIO_FLAG_WRITE) {
s->buf_end = s->buffer + s->buffer_size;
s->write_flag = 1;
} else {
@ -1058,7 +1047,7 @@ int url_open_buf(AVIOContext **s, uint8_t *buf, int buf_size, int flags)
if(!*s)
return AVERROR(ENOMEM);
ret = ffio_init_context(*s, buf, buf_size,
(flags & AVIO_WRONLY || flags & AVIO_RDWR),
flags & AVIO_FLAG_WRITE,
NULL, NULL, NULL, NULL);
if(ret != 0)
av_freep(s);

11
libavformat/file.c
View File

@ -60,9 +60,9 @@ static int file_open(URLContext *h, const char *filename, int flags)
av_strstart(filename, "file:", &filename);
if (flags & AVIO_RDWR) {
if (flags & AVIO_FLAG_WRITE && flags & AVIO_FLAG_READ) {
access = O_CREAT | O_TRUNC | O_RDWR;
} else if (flags & AVIO_WRONLY) {
} else if (flags & AVIO_FLAG_WRITE) {
access = O_CREAT | O_TRUNC | O_WRONLY;
} else {
access = O_RDONLY;
@ -102,9 +102,8 @@ static int file_check(URLContext *h, int mask)
if (ret < 0)
return AVERROR(errno);
ret |= st.st_mode&S_IRUSR ? mask&AVIO_RDONLY : 0;
ret |= st.st_mode&S_IWUSR ? mask&AVIO_WRONLY : 0;
ret |= st.st_mode&S_IWUSR && st.st_mode&S_IRUSR ? mask&AVIO_RDWR : 0;
ret |= st.st_mode&S_IRUSR ? mask&AVIO_FLAG_READ : 0;
ret |= st.st_mode&S_IWUSR ? mask&AVIO_FLAG_WRITE : 0;
return ret;
}
@ -132,7 +131,7 @@ static int pipe_open(URLContext *h, const char *filename, int flags)
fd = strtol(filename, &final, 10);
if((filename == final) || *final ) {/* No digits found, or something like 10ab */
if (flags & AVIO_WRONLY) {
if (flags & AVIO_FLAG_WRITE) {
fd = 1;
} else {
fd = 0;

2
libavformat/gopher.c
View File

@ -100,7 +100,7 @@ static int gopher_open(URLContext *h, const char *uri, int flags)
ff_url_join(buf, sizeof(buf), "tcp", NULL, hostname, port, NULL);
s->hd = NULL;
err = ffurl_open(&s->hd, buf, AVIO_RDWR);
err = ffurl_open(&s->hd, buf, AVIO_FLAG_READ_WRITE);
if (err < 0)
goto fail;

6
libavformat/http.c
View File

@ -124,7 +124,7 @@ static int http_open_cnx(URLContext *h)
port = 80;
ff_url_join(buf, sizeof(buf), "tcp", NULL, hostname, port, NULL);
err = ffurl_open(&hd, buf, AVIO_RDWR);
err = ffurl_open(&hd, buf, AVIO_FLAG_READ_WRITE);
if (err < 0)
goto fail;
@ -296,7 +296,7 @@ static int http_connect(URLContext *h, const char *path, const char *hoststr,
/* send http header */
post = h->flags & AVIO_WRONLY;
post = h->flags & AVIO_FLAG_WRITE;
authstr = ff_http_auth_create_response(&s->auth_state, auth, path,
post ? "POST" : "GET");
@ -451,7 +451,7 @@ static int http_close(URLContext *h)
HTTPContext *s = h->priv_data;
/* signal end of chunked encoding if used */
if ((h->flags & AVIO_WRONLY) && s->chunksize != -1) {
if ((h->flags & AVIO_FLAG_WRITE) && s->chunksize != -1) {
ret = ffurl_write(s->hd, footer, sizeof(footer) - 1);
ret = ret > 0 ? 0 : ret;
}

10
libavformat/img2.c
View File

@ -133,11 +133,11 @@ static int find_image_range(int *pfirst_index, int *plast_index,
if (av_get_frame_filename(buf, sizeof(buf), path, first_index) < 0){
*pfirst_index =
*plast_index = 1;
if(url_exist(buf))
if (avio_check(buf, AVIO_FLAG_READ) > 0)
return 0;
return -1;
}
if (url_exist(buf))
if (avio_check(buf, AVIO_FLAG_READ) > 0)
break;
}
if (first_index == 5)
@ -155,7 +155,7 @@ static int find_image_range(int *pfirst_index, int *plast_index,
if (av_get_frame_filename(buf, sizeof(buf), path,
last_index + range1) < 0)
goto fail;
if (!url_exist(buf))
if (avio_check(buf, AVIO_FLAG_READ) <= 0)
break;
range = range1;
/* just in case... */
@ -282,7 +282,7 @@ static int read_packet(AVFormatContext *s1, AVPacket *pkt)
s->path, s->img_number)<0 && s->img_number > 1)
return AVERROR(EIO);
for(i=0; i<3; i++){
if (avio_open(&f[i], filename, AVIO_RDONLY) < 0) {
if (avio_open(&f[i], filename, AVIO_FLAG_READ) < 0) {
if(i==1)
break;
av_log(s1, AV_LOG_ERROR, "Could not open file : %s\n",filename);
@ -369,7 +369,7 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
return AVERROR(EIO);
}
for(i=0; i<3; i++){
if (avio_open(&pb[i], filename, AVIO_WRONLY) < 0) {
if (avio_open(&pb[i], filename, AVIO_FLAG_WRITE) < 0) {
av_log(s, AV_LOG_ERROR, "Could not open file : %s\n",filename);
return AVERROR(EIO);
}

12
libavformat/internal.h
View File

@ -79,18 +79,6 @@ void ff_read_frame_flush(AVFormatContext *s);
/** Get the current time since NTP epoch in microseconds. */
uint64_t ff_ntp_time(void);
#if FF_API_URL_SPLIT
/**
* @deprecated use av_url_split() instead
*/
void ff_url_split(char *proto, int proto_size,
char *authorization, int authorization_size,
char *hostname, int hostname_size,
int *port_ptr,
char *path, int path_size,
const char *url);
#endif
/**
* Assemble a URL string from components. This is the reverse operation
* of av_url_split.

2
libavformat/librtmp.c
View File

@ -94,7 +94,7 @@ static int rtmp_open(URLContext *s, const char *uri, int flags)
goto fail;
}
if (flags & AVIO_WRONLY)
if (flags & AVIO_FLAG_WRITE)
RTMP_EnableWrite(r);
if (!RTMP_Connect(r, NULL) || !RTMP_ConnectStream(r, 0)) {

2
libavformat/matroskadec.c
View File

@ -1334,7 +1334,7 @@ static int matroska_read_header(AVFormatContext *s, AVFormatParameters *ap)
&& track->codec_priv.data != NULL) {
int ret;
ffio_init_context(&b, track->codec_priv.data, track->codec_priv.size,
AVIO_RDONLY, NULL, NULL, NULL, NULL);
AVIO_FLAG_READ, NULL, NULL, NULL, NULL);
ret = ff_get_wav_header(&b, st->codec, track->codec_priv.size);
if (ret < 0)
return ret;

4
libavformat/md5proto.c
View File

@ -36,7 +36,7 @@ static int md5_open(URLContext *h, const char *filename, int flags)
return -1;
}
if (flags != AVIO_WRONLY)
if (!flags & AVIO_FLAG_WRITE)
return AVERROR(EINVAL);
av_md5_init(h->priv_data);
@ -65,7 +65,7 @@ static int md5_close(URLContext *h)
av_strstart(filename, "md5:", &filename);
if (*filename) {
err = ffurl_open(&out, filename, AVIO_WRONLY);
err = ffurl_open(&out, filename, AVIO_FLAG_WRITE);
if (err)
return err;
err = ffurl_write(out, buf, i*2+1);

7
libavformat/metadata.c
View File

@ -86,13 +86,6 @@ int av_metadata_set2(AVMetadata **pm, const char *key, const char *value, int fl
return 0;
}
#if FF_API_OLD_METADATA
int av_metadata_set(AVMetadata **pm, const char *key, const char *value)
{
return av_metadata_set2(pm, key, value, 0);
}
#endif
#if FF_API_OLD_METADATA2
void av_metadata_conv(AVFormatContext *ctx, const AVMetadataConv *d_conv,
const AVMetadataConv *s_conv)

5
libavformat/metadata.h
View File

@ -43,11 +43,6 @@ struct AVMetadataConv{
typedef struct AVMetadataConv AVMetadataConv;
#endif
#if FF_API_OLD_METADATA
void ff_metadata_demux_compat(AVFormatContext *s);
void ff_metadata_mux_compat(AVFormatContext *s);
#endif
void ff_metadata_conv(AVMetadata **pm, const AVMetadataConv *d_conv,
const AVMetadataConv *s_conv);
void ff_metadata_conv_ctx(AVFormatContext *ctx, const AVMetadataConv *d_conv,

148
libavformat/metadata_compat.c
View File

@ -1,148 +0,0 @@
/*
* Copyright (c) 2009 Aurelien Jacobs <aurel@gnuage.org>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <strings.h>
#include "avformat.h"
#include "metadata.h"
#include "libavutil/avstring.h"
#if FF_API_OLD_METADATA
#define SIZE_OFFSET(x) sizeof(((AVFormatContext*)0)->x),offsetof(AVFormatContext,x)
static const struct {
const char name[16];
int size;
int offset;
} compat_tab[] = {
{ "title", SIZE_OFFSET(title) },
{ "author", SIZE_OFFSET(author) },
{ "copyright", SIZE_OFFSET(copyright) },
{ "comment", SIZE_OFFSET(comment) },
{ "album", SIZE_OFFSET(album) },
{ "year", SIZE_OFFSET(year) },
{ "track", SIZE_OFFSET(track) },
{ "genre", SIZE_OFFSET(genre) },
{ "artist", SIZE_OFFSET(author) },
{ "creator", SIZE_OFFSET(author) },
{ "written_by", SIZE_OFFSET(author) },
{ "lead_performer", SIZE_OFFSET(author) },
{ "composer", SIZE_OFFSET(author) },
{ "performer", SIZE_OFFSET(author) },
{ "description", SIZE_OFFSET(comment) },
{ "albumtitle", SIZE_OFFSET(album) },
{ "date", SIZE_OFFSET(year) },
{ "date_written", SIZE_OFFSET(year) },
{ "date_released", SIZE_OFFSET(year) },
{ "tracknumber", SIZE_OFFSET(track) },
{ "part_number", SIZE_OFFSET(track) },
};
void ff_metadata_demux_compat(AVFormatContext *ctx)
{
AVMetadata *m;
int i, j;
if ((m = ctx->metadata))
for (j=0; j<m->count; j++)
for (i=0; i<FF_ARRAY_ELEMS(compat_tab); i++)
if (!strcasecmp(m->elems[j].key, compat_tab[i].name)) {
int *ptr = (int *)((char *)ctx+compat_tab[i].offset);
if (*ptr) continue;
if (compat_tab[i].size > sizeof(int))
av_strlcpy((char *)ptr, m->elems[j].value, compat_tab[i].size);
else
*ptr = atoi(m->elems[j].value);
}
for (i=0; i<ctx->nb_chapters; i++)
if ((m = ctx->chapters[i]->metadata))
for (j=0; j<m->count; j++)
if (!strcasecmp(m->elems[j].key, "title")) {
av_free(ctx->chapters[i]->title);
ctx->chapters[i]->title = av_strdup(m->elems[j].value);
}
for (i=0; i<ctx->nb_programs; i++)
if ((m = ctx->programs[i]->metadata))
for (j=0; j<m->count; j++) {
if (!strcasecmp(m->elems[j].key, "name")) {
av_free(ctx->programs[i]->name);
ctx->programs[i]->name = av_strdup(m->elems[j].value);
}
if (!strcasecmp(m->elems[j].key, "provider_name")) {
av_free(ctx->programs[i]->provider_name);
ctx->programs[i]->provider_name = av_strdup(m->elems[j].value);
}
}
for (i=0; i<ctx->nb_streams; i++)
if ((m = ctx->streams[i]->metadata))
for (j=0; j<m->count; j++) {
if (!strcasecmp(m->elems[j].key, "language"))
av_strlcpy(ctx->streams[i]->language, m->elems[j].value, 4);
if (!strcasecmp(m->elems[j].key, "filename")) {
av_free(ctx->streams[i]->filename);
ctx->streams[i]->filename= av_strdup(m->elems[j].value);
}
}
}
#define FILL_METADATA(s, key, value) { \
if (!av_metadata_get(s->metadata, #key, NULL, 0)) \
av_metadata_set2(&s->metadata, #key, value, 0); \
}
#define FILL_METADATA_STR(s, key) { \
if (s->key && *s->key) FILL_METADATA(s, key, s->key); }
#define FILL_METADATA_INT(s, key) { \
char number[10]; \
snprintf(number, sizeof(number), "%d", s->key); \
if(s->key) FILL_METADATA(s, key, number) }
void ff_metadata_mux_compat(AVFormatContext *ctx)
{
int i;
if (ctx->metadata && ctx->metadata->count > 0)
return;
FILL_METADATA_STR(ctx, title);
FILL_METADATA_STR(ctx, author);
FILL_METADATA_STR(ctx, copyright);
FILL_METADATA_STR(ctx, comment);
FILL_METADATA_STR(ctx, album);
FILL_METADATA_INT(ctx, year);
FILL_METADATA_INT(ctx, track);
FILL_METADATA_STR(ctx, genre);
for (i=0; i<ctx->nb_chapters; i++)
FILL_METADATA_STR(ctx->chapters[i], title);
for (i=0; i<ctx->nb_programs; i++) {
FILL_METADATA_STR(ctx->programs[i], name);
FILL_METADATA_STR(ctx->programs[i], provider_name);
}
for (i=0; i<ctx->nb_streams; i++) {
FILL_METADATA_STR(ctx->streams[i], language);
FILL_METADATA_STR(ctx->streams[i], filename);
}
}
#endif /* FF_API_OLD_METADATA */

4
libavformat/mms.c
View File

@ -24,11 +24,7 @@
#include "asf.h"
#include "libavutil/intreadwrite.h"
#if FF_API_MAX_STREAMS
#define MMS_MAX_STREAMS MAX_STREAMS
#else
#define MMS_MAX_STREAMS 256 /**< arbitrary sanity check value */
#endif
int ff_mms_read_header(MMSContext *mms, uint8_t *buf, const int size)
{

4
libavformat/mmsh.c
View File

@ -233,7 +233,7 @@ static int mmsh_open(URLContext *h, const char *uri, int flags)
port = 80; // default mmsh protocol port
ff_url_join(httpname, sizeof(httpname), "http", NULL, host, port, path);
if (ffurl_alloc(&mms->mms_hd, httpname, AVIO_RDONLY) < 0) {
if (ffurl_alloc(&mms->mms_hd, httpname, AVIO_FLAG_READ) < 0) {
return AVERROR(EIO);
}
@ -261,7 +261,7 @@ static int mmsh_open(URLContext *h, const char *uri, int flags)
// close the socket and then reopen it for sending the second play request.
ffurl_close(mms->mms_hd);
memset(headers, 0, sizeof(headers));
if (ffurl_alloc(&mms->mms_hd, httpname, AVIO_RDONLY) < 0) {
if (ffurl_alloc(&mms->mms_hd, httpname, AVIO_FLAG_READ) < 0) {
return AVERROR(EIO);
}
stream_selection = av_mallocz(mms->stream_num * 19 + 1);

2
libavformat/mmst.c
View File

@ -523,7 +523,7 @@ static int mms_open(URLContext *h, const char *uri, int flags)
// establish tcp connection.
ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, mmst->host, port, NULL);
err = ffurl_open(&mms->mms_hd, tcpname, AVIO_RDWR);
err = ffurl_open(&mms->mms_hd, tcpname, AVIO_FLAG_READ_WRITE);
if (err)
goto fail;

2
libavformat/mov.c
View File

@ -1721,7 +1721,7 @@ static int mov_open_dref(AVIOContext **pb, char *src, MOVDref *ref)
av_strlcat(filename, ref->path + l + 1, 1024);
if (!avio_open(pb, filename, AVIO_RDONLY))
if (!avio_open(pb, filename, AVIO_FLAG_READ))
return 0;
}
}

5
libavformat/mpegts.c
View File

@ -676,11 +676,6 @@ static int mpegts_push_data(MpegTSFilter *filter,
code == 0x1be) /* padding_stream */
goto skip;
#if FF_API_MAX_STREAMS
if (!pes->st && pes->stream->nb_streams == MAX_STREAMS)
goto skip;
#endif
/* stream not present in PMT */
if (!pes->st) {
pes->st = av_new_stream(ts->stream, pes->pid);

4
libavformat/nutdec.c
View File

@ -30,11 +30,7 @@
#undef NDEBUG
#include <assert.h>
#if FF_API_MAX_STREAMS
#define NUT_MAX_STREAMS MAX_STREAMS
#else
#define NUT_MAX_STREAMS 256 /* arbitrary sanity check value */
#endif
static int get_str(AVIOContext *bc, char *string, unsigned int maxlen){
unsigned int len= ffio_read_varlen(bc);

11
libavformat/options.c
View File

@ -50,10 +50,6 @@ static const AVOption options[]={
{"noparse", "disable AVParsers, this needs nofillin too", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_NOPARSE, INT_MIN, INT_MAX, D, "fflags"},
{"igndts", "ignore dts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNDTS, INT_MIN, INT_MAX, D, "fflags"},
{"rtphint", "add rtp hinting", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_RTP_HINT, INT_MIN, INT_MAX, E, "fflags"},
#if FF_API_OLD_METADATA
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
#endif
{"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 5*AV_TIME_BASE, 0, INT_MAX, D},
{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
@ -88,10 +84,3 @@ AVFormatContext *avformat_alloc_context(void)
ic->av_class = &av_format_context_class;
return ic;
}
#if FF_API_ALLOC_FORMAT_CONTEXT
AVFormatContext *av_alloc_format_context(void)
{
return avformat_alloc_context();
}
#endif

2
libavformat/output-example.c
View File

@ -492,7 +492,7 @@ int main(int argc, char **argv)
/* open the output file, if needed */
if (!(fmt->flags & AVFMT_NOFILE)) {
if (avio_open(&oc->pb, filename, AVIO_WRONLY) < 0) {
if (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0) {
fprintf(stderr, "Could not open '%s'\n", filename);
exit(1);
}

63
libavformat/rtmpproto.c
View File

@ -38,13 +38,6 @@
#include "rtmppkt.h"
#include "url.h"
/* we can't use av_log() with URLContext yet... */
#if FF_API_URL_CLASS
#define LOG_CONTEXT s
#else
#define LOG_CONTEXT NULL
#endif
//#define DEBUG
/** RTMP protocol handler state */
@ -166,7 +159,7 @@ static void gen_release_stream(URLContext *s, RTMPContext *rt)
ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE, 0,
29 + strlen(rt->playpath));
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Releasing stream...\n");
av_log(s, AV_LOG_DEBUG, "Releasing stream...\n");
p = pkt.data;
ff_amf_write_string(&p, "releaseStream");
ff_amf_write_number(&p, 2.0);
@ -189,7 +182,7 @@ static void gen_fcpublish_stream(URLContext *s, RTMPContext *rt)
ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE, 0,
25 + strlen(rt->playpath));
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "FCPublish stream...\n");
av_log(s, AV_LOG_DEBUG, "FCPublish stream...\n");
p = pkt.data;
ff_amf_write_string(&p, "FCPublish");
ff_amf_write_number(&p, 3.0);
@ -212,7 +205,7 @@ static void gen_fcunpublish_stream(URLContext *s, RTMPContext *rt)
ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE, 0,
27 + strlen(rt->playpath));
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "UnPublishing stream...\n");
av_log(s, AV_LOG_DEBUG, "UnPublishing stream...\n");
p = pkt.data;
ff_amf_write_string(&p, "FCUnpublish");
ff_amf_write_number(&p, 5.0);
@ -232,7 +225,7 @@ static void gen_create_stream(URLContext *s, RTMPContext *rt)
RTMPPacket pkt;
uint8_t *p;
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Creating stream...\n");
av_log(s, AV_LOG_DEBUG, "Creating stream...\n");
ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE, 0, 25);
p = pkt.data;
@ -254,7 +247,7 @@ static void gen_delete_stream(URLContext *s, RTMPContext *rt)
RTMPPacket pkt;
uint8_t *p;
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Deleting stream...\n");
av_log(s, AV_LOG_DEBUG, "Deleting stream...\n");
ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE, 0, 34);
p = pkt.data;
@ -276,7 +269,7 @@ static void gen_play(URLContext *s, RTMPContext *rt)
RTMPPacket pkt;
uint8_t *p;
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Sending play command for '%s'\n", rt->playpath);
av_log(s, AV_LOG_DEBUG, "Sending play command for '%s'\n", rt->playpath);
ff_rtmp_packet_create(&pkt, RTMP_VIDEO_CHANNEL, RTMP_PT_INVOKE, 0,
20 + strlen(rt->playpath));
pkt.extra = rt->main_channel_id;
@ -310,7 +303,7 @@ static void gen_publish(URLContext *s, RTMPContext *rt)
RTMPPacket pkt;
uint8_t *p;
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Sending publish command for '%s'\n", rt->playpath);
av_log(s, AV_LOG_DEBUG, "Sending publish command for '%s'\n", rt->playpath);
ff_rtmp_packet_create(&pkt, RTMP_SOURCE_CHANNEL, RTMP_PT_INVOKE, 0,
30 + strlen(rt->playpath));
pkt.extra = rt->main_channel_id;
@ -478,7 +471,7 @@ static int rtmp_handshake(URLContext *s, RTMPContext *rt)
int server_pos, client_pos;
uint8_t digest[32];
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Handshaking...\n");
av_log(s, AV_LOG_DEBUG, "Handshaking...\n");
av_lfg_init(&rnd, 0xDEADC0DE);
// generate handshake packet - 1536 bytes of pseudorandom data
@ -489,16 +482,16 @@ static int rtmp_handshake(URLContext *s, RTMPContext *rt)
ffurl_write(rt->stream, tosend, RTMP_HANDSHAKE_PACKET_SIZE + 1);
i = ffurl_read_complete(rt->stream, serverdata, RTMP_HANDSHAKE_PACKET_SIZE + 1);
if (i != RTMP_HANDSHAKE_PACKET_SIZE + 1) {
av_log(LOG_CONTEXT, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
av_log(s, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
return -1;
}
i = ffurl_read_complete(rt->stream, clientdata, RTMP_HANDSHAKE_PACKET_SIZE);
if (i != RTMP_HANDSHAKE_PACKET_SIZE) {
av_log(LOG_CONTEXT, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
av_log(s, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
return -1;
}
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Server version %d.%d.%d.%d\n",
av_log(s, AV_LOG_DEBUG, "Server version %d.%d.%d.%d\n",
serverdata[5], serverdata[6], serverdata[7], serverdata[8]);
if (rt->is_input && serverdata[5] >= 3) {
@ -506,7 +499,7 @@ static int rtmp_handshake(URLContext *s, RTMPContext *rt)
if (!server_pos) {
server_pos = rtmp_validate_digest(serverdata + 1, 8);
if (!server_pos) {
av_log(LOG_CONTEXT, AV_LOG_ERROR, "Server response validating failed\n");
av_log(s, AV_LOG_ERROR, "Server response validating failed\n");
return -1;
}
}
@ -518,7 +511,7 @@ static int rtmp_handshake(URLContext *s, RTMPContext *rt)
digest, 32,
digest);
if (memcmp(digest, clientdata + RTMP_HANDSHAKE_PACKET_SIZE - 32, 32)) {
av_log(LOG_CONTEXT, AV_LOG_ERROR, "Signature mismatch\n");
av_log(s, AV_LOG_ERROR, "Signature mismatch\n");
return -1;
}
@ -552,13 +545,13 @@ static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
const uint8_t *data_end = pkt->data + pkt->data_size;
#ifdef DEBUG
ff_rtmp_packet_dump(LOG_CONTEXT, pkt);
ff_rtmp_packet_dump(s, pkt);
#endif
switch (pkt->type) {
case RTMP_PT_CHUNK_SIZE:
if (pkt->data_size != 4) {
av_log(LOG_CONTEXT, AV_LOG_ERROR,
av_log(s, AV_LOG_ERROR,
"Chunk size change packet is not 4 bytes long (%d)\n", pkt->data_size);
return -1;
}
@ -566,10 +559,10 @@ static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
ff_rtmp_packet_write(rt->stream, pkt, rt->chunk_size, rt->prev_pkt[1]);
rt->chunk_size = AV_RB32(pkt->data);
if (rt->chunk_size <= 0) {
av_log(LOG_CONTEXT, AV_LOG_ERROR, "Incorrect chunk size %d\n", rt->chunk_size);
av_log(s, AV_LOG_ERROR, "Incorrect chunk size %d\n", rt->chunk_size);
return -1;
}
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "New chunk size = %d\n", rt->chunk_size);
av_log(s, AV_LOG_DEBUG, "New chunk size = %d\n", rt->chunk_size);
break;
case RTMP_PT_PING:
t = AV_RB16(pkt->data);
@ -578,12 +571,12 @@ static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
break;
case RTMP_PT_CLIENT_BW:
if (pkt->data_size < 4) {
av_log(LOG_CONTEXT, AV_LOG_ERROR,
av_log(s, AV_LOG_ERROR,
"Client bandwidth report packet is less than 4 bytes long (%d)\n",
pkt->data_size);
return -1;
}
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Client bandwidth = %d\n", AV_RB32(pkt->data));
av_log(s, AV_LOG_DEBUG, "Client bandwidth = %d\n", AV_RB32(pkt->data));
rt->client_report_size = AV_RB32(pkt->data) >> 1;
break;
case RTMP_PT_INVOKE:
@ -593,7 +586,7 @@ static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
if (!ff_amf_get_field_value(pkt->data + 9, data_end,
"description", tmpstr, sizeof(tmpstr)))
av_log(LOG_CONTEXT, AV_LOG_ERROR, "Server error: %s\n",tmpstr);
av_log(s, AV_LOG_ERROR, "Server error: %s\n",tmpstr);
return -1;
} else if (!memcmp(pkt->data, "\002\000\007_result", 10)) {
switch (rt->state) {
@ -624,7 +617,7 @@ static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
case STATE_CONNECTING:
//extract a number from the result
if (pkt->data[10] || pkt->data[19] != 5 || pkt->data[20]) {
av_log(LOG_CONTEXT, AV_LOG_WARNING, "Unexpected reply on connect()\n");
av_log(s, AV_LOG_WARNING, "Unexpected reply on connect()\n");
} else {
rt->main_channel_id = (int) av_int2dbl(AV_RB64(pkt->data + 21));
}
@ -651,7 +644,7 @@ static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
if (!t && !strcmp(tmpstr, "error")) {
if (!ff_amf_get_field_value(ptr, data_end,
"description", tmpstr, sizeof(tmpstr)))
av_log(LOG_CONTEXT, AV_LOG_ERROR, "Server error: %s\n",tmpstr);
av_log(s, AV_LOG_ERROR, "Server error: %s\n",tmpstr);
return -1;
}
t = ff_amf_get_field_value(ptr, data_end,
@ -701,7 +694,7 @@ static int get_packet(URLContext *s, int for_header)
}
rt->bytes_read += ret;
if (rt->bytes_read > rt->last_bytes_read + rt->client_report_size) {
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Sending bytes read report\n");
av_log(s, AV_LOG_DEBUG, "Sending bytes read report\n");
gen_bytes_read(s, rt, rpkt.timestamp + 1);
rt->last_bytes_read = rt->bytes_read;
}
@ -812,7 +805,7 @@ static int rtmp_open(URLContext *s, const char *uri, int flags)
if (!rt)
return AVERROR(ENOMEM);
s->priv_data = rt;
rt->is_input = !(flags & AVIO_WRONLY);
rt->is_input = !(flags & AVIO_FLAG_WRITE);
av_url_split(proto, sizeof(proto), NULL, 0, hostname, sizeof(hostname), &port,
path, sizeof(path), s->filename);
@ -821,8 +814,8 @@ static int rtmp_open(URLContext *s, const char *uri, int flags)
port = RTMP_DEFAULT_PORT;
ff_url_join(buf, sizeof(buf), "tcp", NULL, hostname, port, NULL);
if (ffurl_open(&rt->stream, buf, AVIO_RDWR) < 0) {
av_log(LOG_CONTEXT, AV_LOG_ERROR, "Cannot open connection %s\n", buf);
if (ffurl_open(&rt->stream, buf, AVIO_FLAG_READ_WRITE) < 0) {
av_log(s , AV_LOG_ERROR, "Cannot open connection %s\n", buf);
goto fail;
}
@ -866,7 +859,7 @@ static int rtmp_open(URLContext *s, const char *uri, int flags)
rt->bytes_read = 0;
rt->last_bytes_read = 0;
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Proto = %s, path = %s, app = %s, fname = %s\n",
av_log(s, AV_LOG_DEBUG, "Proto = %s, path = %s, app = %s, fname = %s\n",
proto, path, rt->app, rt->playpath);
gen_connect(s, rt, proto, hostname, port);
@ -933,7 +926,7 @@ static int rtmp_write(URLContext *s, const uint8_t *buf, int size)
const uint8_t *buf_temp = buf;
if (size < 11) {
av_log(LOG_CONTEXT, AV_LOG_DEBUG, "FLV packet too small %d\n", size);
av_log(s, AV_LOG_DEBUG, "FLV packet too small %d\n", size);
return 0;
}

2
libavformat/rtpproto.c
View File

@ -145,7 +145,7 @@ static int rtp_open(URLContext *h, const char *uri, int flags)
char path[1024];
const char *p;
is_output = (flags & AVIO_WRONLY);
is_output = (flags & AVIO_FLAG_WRITE);
s = av_mallocz(sizeof(RTPContext));
if (!s)

16
libavformat/rtsp.c
View File

@ -1116,14 +1116,14 @@ int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port,
"?localport=%d", j);
/* we will use two ports per rtp stream (rtp and rtcp) */
j += 2;
if (ffurl_open(&rtsp_st->rtp_handle, buf, AVIO_RDWR) == 0)
if (ffurl_open(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE) == 0)
goto rtp_opened;
}
}
#if 0
/* then try on any port */
if (ffurl_open(&rtsp_st->rtp_handle, "rtp://", AVIO_RDONLY) < 0) {
if (ffurl_open(&rtsp_st->rtp_handle, "rtp://", AVIO_FLAG_READ) < 0) {
err = AVERROR_INVALIDDATA;
goto fail;
}
@ -1269,7 +1269,7 @@ int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port,
namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
port, "?ttl=%d", ttl);
if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_RDWR) < 0) {
if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE) < 0) {
err = AVERROR_INVALIDDATA;
goto fail;
}
@ -1396,7 +1396,7 @@ redirect:
av_get_random_seed(), av_get_random_seed());
/* GET requests */
if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_RDONLY) < 0) {
if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ) < 0) {
err = AVERROR(EIO);
goto fail;
}
@ -1417,7 +1417,7 @@ redirect:
}
/* POST requests */
if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_WRONLY) < 0 ) {
if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE) < 0 ) {
err = AVERROR(EIO);
goto fail;
}
@ -1460,7 +1460,7 @@ redirect:
} else {
/* open the tcp connection */
ff_url_join(tcpname, sizeof(tcpname), "tcp", NULL, host, port, NULL);
if (ffurl_open(&rt->rtsp_hd, tcpname, AVIO_RDWR) < 0) {
if (ffurl_open(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE) < 0) {
err = AVERROR(EIO);
goto fail;
}
@ -1807,7 +1807,7 @@ static int sdp_read_header(AVFormatContext *s, AVFormatParameters *ap)
namebuf, rtsp_st->sdp_port,
"?localport=%d&ttl=%d", rtsp_st->sdp_port,
rtsp_st->sdp_ttl);
if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_RDWR) < 0) {
if (ffurl_open(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE) < 0) {
err = AVERROR_INVALIDDATA;
goto fail;
}
@ -1863,7 +1863,7 @@ static int rtp_read_header(AVFormatContext *s,
if (!ff_network_init())
return AVERROR(EIO);
ret = ffurl_open(&in, s->filename, AVIO_RDONLY);
ret = ffurl_open(&in, s->filename, AVIO_FLAG_READ);
if (ret)
goto fail;

2
libavformat/sapdec.c
View File

@ -85,7 +85,7 @@ static int sap_read_header(AVFormatContext *s,
ff_url_join(url, sizeof(url), "udp", NULL, host, port, "?localport=%d",
port);
ret = ffurl_open(&sap->ann_fd, url, AVIO_RDONLY);
ret = ffurl_open(&sap->ann_fd, url, AVIO_FLAG_READ);
if (ret)
goto fail;

4
libavformat/sapenc.c
View File

@ -146,7 +146,7 @@ static int sap_write_header(AVFormatContext *s)
"?ttl=%d", ttl);
if (!same_port)
base_port += 2;
ret = ffurl_open(&fd, url, AVIO_WRONLY);
ret = ffurl_open(&fd, url, AVIO_FLAG_WRITE);
if (ret) {
ret = AVERROR(EIO);
goto fail;
@ -158,7 +158,7 @@ static int sap_write_header(AVFormatContext *s)
ff_url_join(url, sizeof(url), "udp", NULL, announce_addr, port,
"?ttl=%d&connect=1", ttl);
ret = ffurl_open(&sap->ann_fd, url, AVIO_WRONLY);
ret = ffurl_open(&sap->ann_fd, url, AVIO_FLAG_WRITE);
if (ret) {
ret = AVERROR(EIO);
goto fail;

17
libavformat/udp.c
View File

@ -292,10 +292,7 @@ int ff_udp_get_local_port(URLContext *h)
* streams at the same time.
* @param h media file context
*/
#if !FF_API_UDP_GET_FILE
static
#endif
int udp_get_file_handle(URLContext *h)
static int udp_get_file_handle(URLContext *h)
{
UDPContext *s = h->priv_data;
return s->udp_fd;
@ -318,7 +315,7 @@ static int udp_open(URLContext *h, const char *uri, int flags)
h->is_streamed = 1;
h->max_packet_size = 1472;
is_output = (flags & AVIO_WRONLY);
is_output = (flags & AVIO_FLAG_WRITE);
s = av_mallocz(sizeof(UDPContext));
if (!s)
@ -361,14 +358,14 @@ static int udp_open(URLContext *h, const char *uri, int flags)
/* XXX: fix av_url_split */
if (hostname[0] == '\0' || hostname[0] == '?') {
/* only accepts null hostname if input */
if (flags & AVIO_WRONLY)
if (flags & AVIO_FLAG_WRITE)
goto fail;
} else {
if (ff_udp_set_remote_url(h, uri) < 0)
goto fail;
}
if (s->is_multicast && !(h->flags & AVIO_WRONLY))
if (s->is_multicast && !(h->flags & AVIO_FLAG_WRITE))
s->local_port = port;
udp_fd = udp_socket_create(s, &my_addr, &len);
if (udp_fd < 0)
@ -385,7 +382,7 @@ static int udp_open(URLContext *h, const char *uri, int flags)
/* the bind is needed to give a port to the socket now */
/* if multicast, try the multicast address bind first */
if (s->is_multicast && !(h->flags & AVIO_WRONLY)) {
if (s->is_multicast && !(h->flags & AVIO_FLAG_WRITE)) {
bind_ret = bind(udp_fd,(struct sockaddr *)&s->dest_addr, len);
}
/* bind to the local address if not multicast or if the multicast
@ -398,7 +395,7 @@ static int udp_open(URLContext *h, const char *uri, int flags)
s->local_port = udp_port(&my_addr, len);
if (s->is_multicast) {
if (h->flags & AVIO_WRONLY) {
if (h->flags & AVIO_FLAG_WRITE) {
/* output */
if (udp_set_multicast_ttl(udp_fd, s->ttl, (struct sockaddr *)&s->dest_addr) < 0)
goto fail;
@ -481,7 +478,7 @@ static int udp_close(URLContext *h)
{
UDPContext *s = h->priv_data;
if (s->is_multicast && !(h->flags & AVIO_WRONLY))
if (s->is_multicast && !(h->flags & AVIO_FLAG_WRITE))
udp_leave_multicast_group(s->udp_fd, (struct sockaddr *)&s->dest_addr);
closesocket(s->udp_fd);
av_free(s);

138
libavformat/utils.c
View File

@ -116,15 +116,9 @@ static void av_frac_add(AVFrac *f, int64_t incr)
}
/** head of registered input format linked list */
#if !FF_API_FIRST_FORMAT
static
#endif
AVInputFormat *first_iformat = NULL;
static AVInputFormat *first_iformat = NULL;
/** head of registered output format linked list */
#if !FF_API_FIRST_FORMAT
static
#endif
AVOutputFormat *first_oformat = NULL;
static AVOutputFormat *first_oformat = NULL;
AVInputFormat *av_iformat_next(AVInputFormat *f)
{
@ -201,14 +195,6 @@ static int match_format(const char *name, const char *names)
return !strcasecmp(name, names);
}
#if FF_API_GUESS_FORMAT
AVOutputFormat *guess_format(const char *short_name, const char *filename,
const char *mime_type)
{
return av_guess_format(short_name, filename, mime_type);
}
#endif
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
const char *mime_type)
{
@ -244,27 +230,6 @@ AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
return fmt_found;
}
#if FF_API_GUESS_FORMAT
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
const char *mime_type)
{
AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
if (fmt) {
AVOutputFormat *stream_fmt;
char stream_format_name[64];
snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
if (stream_fmt)
fmt = stream_fmt;
}
return fmt;
}
#endif
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
const char *filename, const char *mime_type, enum AVMediaType type){
if(type == AVMEDIA_TYPE_VIDEO){
@ -296,38 +261,6 @@ AVInputFormat *av_find_input_format(const char *short_name)
return NULL;
}
#if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
{
av_destruct_packet_nofree(pkt);
}
FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
{
av_destruct_packet(pkt);
}
FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
{
return av_new_packet(pkt, size);
}
FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
{
return av_dup_packet(pkt);
}
FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
{
av_free_packet(pkt);
}
FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
{
av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
av_init_packet(pkt);
}
#endif
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
{
@ -513,10 +446,6 @@ int av_open_input_stream(AVFormatContext **ic_ptr,
if (pb && !ic->data_offset)
ic->data_offset = avio_tell(ic->pb);
#if FF_API_OLD_METADATA
ff_metadata_demux_compat(ic);
#endif
ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
*ic_ptr = ic;
@ -637,7 +566,7 @@ int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
hack needed to handle RTSP/TCP */
if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
/* if no file needed do not try to open one */
if ((err=avio_open(&pb, filename, AVIO_RDONLY)) < 0) {
if ((err=avio_open(&pb, filename, AVIO_FLAG_READ)) < 0) {
goto fail;
}
if (buf_size > 0) {
@ -2639,18 +2568,11 @@ void avformat_free_context(AVFormatContext *s)
av_free(st->codec->extradata);
av_free(st->codec->subtitle_header);
av_free(st->codec);
#if FF_API_OLD_METADATA
av_free(st->filename);
#endif
av_free(st->priv_data);
av_free(st->info);
av_free(st);
}
for(i=s->nb_programs-1; i>=0; i--) {
#if FF_API_OLD_METADATA
av_freep(&s->programs[i]->provider_name);
av_freep(&s->programs[i]->name);
#endif
av_metadata_free(&s->programs[i]->metadata);
av_freep(&s->programs[i]->stream_index);
av_freep(&s->programs[i]);
@ -2658,9 +2580,6 @@ void avformat_free_context(AVFormatContext *s)
av_freep(&s->programs);
av_freep(&s->priv_data);
while(s->nb_chapters--) {
#if FF_API_OLD_METADATA
av_free(s->chapters[s->nb_chapters]->title);
#endif
av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
av_free(s->chapters[s->nb_chapters]);
}
@ -2682,13 +2601,6 @@ AVStream *av_new_stream(AVFormatContext *s, int id)
{
AVStream *st;
int i;
#if FF_API_MAX_STREAMS
if (s->nb_streams >= MAX_STREAMS){
av_log(s, AV_LOG_ERROR, "Too many streams\n");
return NULL;
}
#else
AVStream **streams;
if (s->nb_streams >= INT_MAX/sizeof(*streams))
@ -2697,7 +2609,6 @@ AVStream *av_new_stream(AVFormatContext *s, int id)
if (!streams)
return NULL;
s->streams = streams;
#endif
st = av_mallocz(sizeof(AVStream));
if (!st)
@ -2777,9 +2688,6 @@ AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int6
return NULL;
dynarray_add(&s->chapters, &s->nb_chapters, chapter);
}
#if FF_API_OLD_METADATA
av_free(chapter->title);
#endif
av_metadata_set2(&chapter->metadata, "title", title, 0);
chapter->id = id;
chapter->time_base= time_base;
@ -2917,10 +2825,6 @@ int av_write_header(AVFormatContext *s)
return AVERROR(ENOMEM);
}
#if FF_API_OLD_METADATA
ff_metadata_mux_compat(s);
#endif
/* set muxer identification string */
if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
@ -3408,24 +3312,6 @@ void av_dump_format(AVFormatContext *ic,
av_free(printed);
}
#if FF_API_PARSE_FRAME_PARAM
#include "libavutil/parseutils.h"
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
{
return av_parse_video_size(width_ptr, height_ptr, str);
}
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
{
AVRational frame_rate;
int ret = av_parse_video_rate(&frame_rate, arg);
*frame_rate_num= frame_rate.num;
*frame_rate_den= frame_rate.den;
return ret;
}
#endif
int64_t av_gettime(void)
{
struct timeval tv;
@ -3605,24 +3491,6 @@ void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
}
#if FF_API_URL_SPLIT
attribute_deprecated
void ff_url_split(char *proto, int proto_size,
char *authorization, int authorization_size,
char *hostname, int hostname_size,
int *port_ptr,
char *path, int path_size,
const char *url)
{
av_url_split(proto, proto_size,
authorization, authorization_size,
hostname, hostname_size,
port_ptr,
path, path_size,
url);
}
#endif
void av_url_split(char *proto, int proto_size,
char *authorization, int authorization_size,
char *hostname, int hostname_size,

49
libavformat/version.h
View File

@ -23,8 +23,8 @@
#include "libavutil/avutil.h"
#define LIBAVFORMAT_VERSION_MAJOR 52
#define LIBAVFORMAT_VERSION_MINOR 108
#define LIBAVFORMAT_VERSION_MAJOR 53
#define LIBAVFORMAT_VERSION_MINOR 0
#define LIBAVFORMAT_VERSION_MICRO 0
#define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
@ -41,60 +41,15 @@
* Those FF_API_* defines are not part of public API.
* They may change, break or disappear at any time.
*/
#ifndef FF_API_MAX_STREAMS
#define FF_API_MAX_STREAMS (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_OLD_METADATA
#define FF_API_OLD_METADATA (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_OLD_METADATA2
#define FF_API_OLD_METADATA2 (LIBAVFORMAT_VERSION_MAJOR < 54)
#endif
#ifndef FF_API_URL_CLASS
#define FF_API_URL_CLASS (LIBAVFORMAT_VERSION_MAJOR >= 53)
#endif
#ifndef FF_API_URL_RESETBUF
#define FF_API_URL_RESETBUF (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_REGISTER_PROTOCOL
#define FF_API_REGISTER_PROTOCOL (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_GUESS_FORMAT
#define FF_API_GUESS_FORMAT (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_UDP_GET_FILE
#define FF_API_UDP_GET_FILE (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_URL_SPLIT
#define FF_API_URL_SPLIT (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_ALLOC_FORMAT_CONTEXT
#define FF_API_ALLOC_FORMAT_CONTEXT (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_PARSE_FRAME_PARAM
#define FF_API_PARSE_FRAME_PARAM (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_READ_SEEK
#define FF_API_READ_SEEK (LIBAVFORMAT_VERSION_MAJOR < 54)
#endif
#ifndef FF_API_LAVF_UNUSED
#define FF_API_LAVF_UNUSED (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_PARAMETERS_CODEC_ID
#define FF_API_PARAMETERS_CODEC_ID (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_FIRST_FORMAT
#define FF_API_FIRST_FORMAT (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_SYMVER
#define FF_API_SYMVER (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_OLD_AVIO
#define FF_API_OLD_AVIO (LIBAVFORMAT_VERSION_MAJOR < 54)
#endif
#ifndef FF_API_INDEX_BUILT
#define FF_API_INDEX_BUILT (LIBAVFORMAT_VERSION_MAJOR < 53)
#endif
#ifndef FF_API_DUMP_FORMAT
#define FF_API_DUMP_FORMAT (LIBAVFORMAT_VERSION_MAJOR < 54)
#endif

16
libavutil/avutil.h
View File

@ -39,9 +39,9 @@
#define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c
#define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
#define LIBAVUTIL_VERSION_MAJOR 50
#define LIBAVUTIL_VERSION_MINOR 40
#define LIBAVUTIL_VERSION_MICRO 1
#define LIBAVUTIL_VERSION_MAJOR 51
#define LIBAVUTIL_VERSION_MINOR 0
#define LIBAVUTIL_VERSION_MICRO 0
#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
LIBAVUTIL_VERSION_MINOR, \
@ -58,7 +58,7 @@
* They may change, break or disappear at any time.
*/
#ifndef FF_API_OLD_EVAL_NAMES
#define FF_API_OLD_EVAL_NAMES (LIBAVUTIL_VERSION_MAJOR < 51)
#define FF_API_OLD_EVAL_NAMES (LIBAVUTIL_VERSION_MAJOR < 52)
#endif
/**
@ -97,14 +97,6 @@ enum AVMediaType {
#define AV_TIME_BASE 1000000
#define AV_TIME_BASE_Q (AVRational){1, AV_TIME_BASE}
/**
* Those FF_API_* defines are not part of public API.
* They may change, break or disappear at any time.
*/
#ifndef FF_API_OLD_IMAGE_NAMES
#define FF_API_OLD_IMAGE_NAMES (LIBAVUTIL_VERSION_MAJOR < 51)
#endif
#include "common.h"
#include "error.h"
#include "mathematics.h"

6
libavutil/error.h
View File

@ -37,25 +37,19 @@
#define AVUNERROR(e) (e)
#endif
#if LIBAVUTIL_VERSION_MAJOR < 51
#define AVERROR_INVALIDDATA AVERROR(EINVAL) ///< Invalid data found when processing input
#define AVERROR_IO AVERROR(EIO) ///< I/O error
#define AVERROR_NOENT AVERROR(ENOENT) ///< No such file or directory
#define AVERROR_NOFMT AVERROR(EILSEQ) ///< Unknown format
#define AVERROR_NOMEM AVERROR(ENOMEM) ///< Not enough memory
#define AVERROR_NOTSUPP AVERROR(ENOSYS) ///< Operation not supported
#define AVERROR_NUMEXPECTED AVERROR(EDOM) ///< Number syntax expected in filename
#define AVERROR_UNKNOWN AVERROR(EINVAL) ///< Unknown error
#endif
#define AVERROR_EOF AVERROR(EPIPE) ///< End of file
#define AVERROR_PATCHWELCOME (-MKTAG('P','A','W','E')) ///< Not yet implemented in FFmpeg, patches welcome
#if LIBAVUTIL_VERSION_MAJOR > 50
#define AVERROR_INVALIDDATA (-MKTAG('I','N','D','A')) ///< Invalid data found when processing input
#define AVERROR_NUMEXPECTED (-MKTAG('N','U','E','X')) ///< Number syntax expected in filename
#endif
#define AVERROR_DEMUXER_NOT_FOUND (-MKTAG(0xF8,'D','E','M')) ///< Demuxer not found
#define AVERROR_MUXER_NOT_FOUND (-MKTAG(0xF8,'M','U','X')) ///< Muxer not found

3
libavutil/file.c
View File

@ -47,7 +47,6 @@ int av_file_map(const char *filename, uint8_t **bufptr, size_t *size,
av_unused void *ptr;
off_t off_size;
char errbuf[128];
size_t max_size = HAVE_MMAP ? SIZE_MAX : FF_INTERNAL_MEM_TYPE_MAX_VALUE;
*bufptr = NULL;
if (fd < 0) {
@ -66,7 +65,7 @@ int av_file_map(const char *filename, uint8_t **bufptr, size_t *size,
}
off_size = st.st_size;
if (off_size > max_size) {
if (off_size > SIZE_MAX) {
av_log(&file_log_ctx, AV_LOG_ERROR,
"File size for file '%s' is too big\n", filename);
close(fd);

29
libavutil/imgutils.c
View File

@ -266,32 +266,3 @@ void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
}
}
}
#if FF_API_OLD_IMAGE_NAMES
void av_fill_image_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4],
const AVPixFmtDescriptor *pixdesc)
{
av_image_fill_max_pixsteps(max_pixsteps, max_pixstep_comps, pixdesc);
}
int av_get_image_linesize(enum PixelFormat pix_fmt, int width, int plane)
{
return av_image_get_linesize(pix_fmt, width, plane);
}
int av_fill_image_linesizes(int linesizes[4], enum PixelFormat pix_fmt, int width)
{
return av_image_fill_linesizes(linesizes, pix_fmt, width);
}
int av_fill_image_pointers(uint8_t *data[4], enum PixelFormat pix_fmt, int height,
uint8_t *ptr, const int linesizes[4])
{
return av_image_fill_pointers(data, pix_fmt, height, ptr, linesizes);
}
int av_check_image_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
{
return av_image_check_size(w, h, log_offset, log_ctx);
}
#endif

19
libavutil/imgutils.h
View File

@ -127,23 +127,4 @@ int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *lo
int ff_set_systematic_pal2(uint32_t pal[256], enum PixelFormat pix_fmt);
#if FF_API_OLD_IMAGE_NAMES
attribute_deprecated
void av_fill_image_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4],
const AVPixFmtDescriptor *pixdesc);
attribute_deprecated
int av_get_image_linesize(enum PixelFormat pix_fmt, int width, int plane);
attribute_deprecated
int av_fill_image_linesizes(int linesizes[4], enum PixelFormat pix_fmt, int width);
attribute_deprecated
int av_fill_image_pointers(uint8_t *data[4], enum PixelFormat pix_fmt, int height,
uint8_t *ptr, const int linesizes[4]);
attribute_deprecated
int av_check_image_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx);
#endif
#endif /* AVUTIL_IMGUTILS_H */

5
libavutil/log.c
View File

@ -29,10 +29,7 @@
#include "avutil.h"
#include "log.h"
#if LIBAVUTIL_VERSION_MAJOR > 50
static
#endif
int av_log_level = AV_LOG_INFO;
static int av_log_level = AV_LOG_INFO;
static int flags;
#if defined(_WIN32) && !defined(__MINGW32CE__)

6
libavutil/mem.c
View File

@ -61,7 +61,7 @@ void free(void *ptr);
memory allocator. You do not need to suppress this file because the
linker will do it automatically. */
void *av_malloc(FF_INTERNAL_MEM_TYPE size)
void *av_malloc(size_t size)
{
void *ptr = NULL;
#if CONFIG_MEMALIGN_HACK
@ -116,7 +116,7 @@ void *av_malloc(FF_INTERNAL_MEM_TYPE size)
return ptr;
}
void *av_realloc(void *ptr, FF_INTERNAL_MEM_TYPE size)
void *av_realloc(void *ptr, size_t size)
{
#if CONFIG_MEMALIGN_HACK
int diff;
@ -153,7 +153,7 @@ void av_freep(void *arg)
*ptr = NULL;
}
void *av_mallocz(FF_INTERNAL_MEM_TYPE size)
void *av_mallocz(size_t size)
{
void *ptr = av_malloc(size);
if (ptr)

14
libavutil/mem.h
View File

@ -62,14 +62,6 @@
#define av_alloc_size(n)
#endif
#if LIBAVUTIL_VERSION_MAJOR < 51
# define FF_INTERNAL_MEM_TYPE unsigned int
# define FF_INTERNAL_MEM_TYPE_MAX_VALUE UINT_MAX
#else
# define FF_INTERNAL_MEM_TYPE size_t
# define FF_INTERNAL_MEM_TYPE_MAX_VALUE SIZE_MAX
#endif
/**
* Allocate a block of size bytes with alignment suitable for all
* memory accesses (including vectors if available on the CPU).
@ -78,7 +70,7 @@
* be allocated.
* @see av_mallocz()
*/
void *av_malloc(FF_INTERNAL_MEM_TYPE size) av_malloc_attrib av_alloc_size(1);
void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1);
/**
* Allocate or reallocate a block of memory.
@ -92,7 +84,7 @@ void *av_malloc(FF_INTERNAL_MEM_TYPE size) av_malloc_attrib av_alloc_size(1);
* cannot be reallocated or the function is used to free the memory block.
* @see av_fast_realloc()
*/
void *av_realloc(void *ptr, FF_INTERNAL_MEM_TYPE size) av_alloc_size(2);
void *av_realloc(void *ptr, size_t size) av_alloc_size(2);
/**
* Free a memory block which has been allocated with av_malloc(z)() or
@ -112,7 +104,7 @@ void av_free(void *ptr);
* @return Pointer to the allocated block, NULL if it cannot be allocated.
* @see av_malloc()
*/
void *av_mallocz(FF_INTERNAL_MEM_TYPE size) av_malloc_attrib av_alloc_size(1);
void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1);
/**
* Duplicate the string s.

2
libswscale/options.c
View File

@ -20,7 +20,7 @@
#include "libavutil/avutil.h"
#include "libavutil/pixfmt.h"
#include "libavcodec/opt.h"
#include "libavutil/opt.h"
#include "swscale.h"
#include "swscale_internal.h"