sigrid/ffmpeg

avconv.c+3−2

         av_init_packet(&pkt);
         pkt.stream_index= ost->index;
-        if (s->oformat->flags & AVFMT_RAWPICTURE) {
+        if (s->oformat->flags & AVFMT_RAWPICTURE &&
+            enc->codec->id == CODEC_ID_RAWVIDEO) {
             /* raw pictures are written as AVPicture structure to
                avoid any copies. We support temporarily the older
                method. */
         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
             continue;
-        if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
+        if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
             continue;
         for(;;) {

doc/APIchanges+13−0

@@ -22,6 +22,19 @@ API changes, most recent first: · 21 unmodified lines
22	2011-10-20 - b35e9e1 - lavu 51.22.0	22	2011-10-20 - b35e9e1 - lavu 51.22.0
23	Add av_strtok() to avstring.h.	23	Add av_strtok() to avstring.h.
24		24
		25	2011-xx-xx - xxxxxxx - lavc 53.25.0
		26	Add nb_samples and extended_data fields to AVFrame.
		27	Deprecate AVCODEC_MAX_AUDIO_FRAME_SIZE.
		28	Deprecate avcodec_decode_audio3() in favor of avcodec_decode_audio4().
		29	avcodec_decode_audio4() writes output samples to an AVFrame, which allows
		30	audio decoders to use get_buffer().
		31
		32	2011-xx-xx - xxxxxxx - lavc 53.24.0
		33	Change AVFrame.data[4]/base[4]/linesize[4]/error[4] to [8] at next major bump.
		34	Change AVPicture.data[4]/linesize[4] to [8] at next major bump.
		35	Change AVCodecContext.error[4] to [8] at next major bump.
		36	Add AV_NUM_DATA_POINTERS to simplify the bump transition.
		37
25	2011-11-23 - bbb46f3 - lavu 51.18.0	38	2011-11-23 - bbb46f3 - lavu 51.18.0
26	Add av_samples_get_buffer_size(), av_samples_fill_arrays(), and	39	Add av_samples_get_buffer_size(), av_samples_fill_arrays(), and
27	av_samples_alloc(), to samplefmt.h.	40	av_samples_alloc(), to samplefmt.h.

doc/developer.texi+68−32

@@ -53,48 +53,26 @@ and should try to fix issues their commit causes. · 52 unmodified lines
53	@anchor{Coding Rules}	53	@anchor{Coding Rules}
54	@section Coding Rules	54	@section Coding Rules
55		55
56	FFmpeg is programmed in the ISO C90 language with a few additional	56	@subsection Code formatting conventions
57	features from ISO C99, namely:
58	@itemize @bullet
59	@item
60	the @samp{inline} keyword;
61	@item
62	@samp{//} comments;
63	@item
64	designated struct initializers (@samp{struct s x = @{ .i = 17 @};})
65	@item
66	compound literals (@samp{x = (struct s) @{ 17, 23 @};})
67	@end itemize
68
69	These features are supported by all compilers we care about, so we will not
70	accept patches to remove their use unless they absolutely do not impair
71	clarity and performance.
72		57
73	All code must compile with recent versions of GCC and a number of other	58	There are the following guidelines regarding the indentation in files:
74	currently supported compilers. To ensure compatibility, please do not use
75	additional C99 features or GCC extensions. Especially watch out for:
76	@itemize @bullet	59	@itemize @bullet
77	@item	60	@item
78	mixing statements and declarations;
79	@item
80	@samp{long long} (use @samp{int64_t} instead);
81	@item
82	@samp{__attribute__} not protected by @samp{#ifdef __GNUC__} or similar;
83	@item
84	GCC statement expressions (@samp{(x = (@{ int y = 4; y; @})}).
85	@end itemize
86
87	Indent size is 4.	61	Indent size is 4.
88	The presentation is one inspired by 'indent -i4 -kr -nut'.	62	@item
89	The TAB character is forbidden outside of Makefiles as is any	63	The TAB character is forbidden outside of Makefiles as is any
90	form of trailing whitespace. Commits containing either will be	64	form of trailing whitespace. Commits containing either will be
91	rejected by the git repository.	65	rejected by the git repository.
		66	@item
		67	You should try to limit your code lines to 80 characters; however, do so if and only if this improves readability.
		68	@end itemize
		69	The presentation is one inspired by 'indent -i4 -kr -nut'.
92		70
93	The main priority in FFmpeg is simplicity and small code size in order to	71	The main priority in FFmpeg is simplicity and small code size in order to
94	minimize the bug count.	72	minimize the bug count.
95		73
96	Comments: Use the JavaDoc/Doxygen	74	@subsection Comments
97	format (see examples below) so that code documentation	75	Use the JavaDoc/Doxygen format (see examples below) so that code documentation
98	can be generated automatically. All nontrivial functions should have a comment	76	can be generated automatically. All nontrivial functions should have a comment
99	above them explaining what the function does, even if it is just one sentence.	77	above them explaining what the function does, even if it is just one sentence.
100	All structures and their member variables should be documented, too.	78	All structures and their member variables should be documented, too.
@@ -128,11 +106,69 @@ int myfunc(int my_parameter) · 27 unmodified lines
128	...	106	...
129	@end example	107	@end example
130		108
		109	@subsection C language features
		110
		111	FFmpeg is programmed in the ISO C90 language with a few additional
		112	features from ISO C99, namely:
		113	@itemize @bullet
		114	@item
		115	the @samp{inline} keyword;
		116	@item
		117	@samp{//} comments;
		118	@item
		119	designated struct initializers (@samp{struct s x = @{ .i = 17 @};})
		120	@item
		121	compound literals (@samp{x = (struct s) @{ 17, 23 @};})
		122	@end itemize
		123
		124	These features are supported by all compilers we care about, so we will not
		125	accept patches to remove their use unless they absolutely do not impair
		126	clarity and performance.
		127
		128	All code must compile with recent versions of GCC and a number of other
		129	currently supported compilers. To ensure compatibility, please do not use
		130	additional C99 features or GCC extensions. Especially watch out for:
		131	@itemize @bullet
		132	@item
		133	mixing statements and declarations;
		134	@item
		135	@samp{long long} (use @samp{int64_t} instead);
		136	@item
		137	@samp{__attribute__} not protected by @samp{#ifdef __GNUC__} or similar;
		138	@item
		139	GCC statement expressions (@samp{(x = (@{ int y = 4; y; @})}).
		140	@end itemize
		141
		142	@subsection Naming conventions
		143	All names are using underscores (_), not CamelCase. For example, @samp{avfilter_get_video_buffer} is
		144	a valid function name and @samp{AVFilterGetVideo} is not. The only exception from this are structure names;
		145	they should always be in the CamelCase
		146
		147	There are following conventions for naming variables and functions:
		148	@itemize @bullet
		149	@item
		150	For local variables no prefix is required.
		151	@item
		152	For variables and functions declared as @code{static} no prefixes are required.
		153	@item
		154	For variables and functions used internally by the library, @code{ff_} prefix should be used.
		155	For example, @samp{ff_w64_demuxer}.
		156	@item
		157	For variables and functions used internally across multiple libraries, use @code{avpriv_}. For example,
		158	@samp{avpriv_aac_parse_header}.
		159	@item
		160	For exported names, each library has its own prefixes. Just check the existing code and name accordingly.
		161	@end itemize
		162
		163	@subsection Miscellanous conventions
		164	@itemize @bullet
		165	@item
131	fprintf and printf are forbidden in libavformat and libavcodec,	166	fprintf and printf are forbidden in libavformat and libavcodec,
132	please use av_log() instead.	167	please use av_log() instead.
133		168	@item
134	Casts should be used only when necessary. Unneeded parentheses	169	Casts should be used only when necessary. Unneeded parentheses
135	should also be avoided if they don't make the code easier to understand.	170	should also be avoided if they don't make the code easier to understand.
		171	@end itemize
136		172
137	@section Development Policy	173	@section Development Policy
138		174

doc/general.texi+11−2

 bash ./configure
 @end example
-@subsection Darwin (MacOS X, iPhone)
+@anchor{Darwin}
+@subsection Darwin (OSX, iPhone)
-MacOS X on PowerPC or ARM (iPhone) requires a preprocessor from
+The toolchain provided with Xcode is sufficient to build the basic
+unacelerated code.
+OSX on PowerPC or ARM (iPhone) requires a preprocessor from
 @url{http://github.com/yuvi/gas-preprocessor} to build the optimized
 assembler functions. Just download the Perl script and put it somewhere
 in your PATH, FFmpeg's configure will pick it up automatically.
+OSX on amd64 and x86 requires @command{yasm} to build most of the
+optimized assembler functions @url{http://mxcl.github.com/homebrew/, Homebrew},
+@url{http://www.gentoo.org/proj/en/gentoo-alt/prefix/bootstrap-macos.xml, Gentoo Prefix}
+or @url{http://www.macports.org, MacPorts} can easily provide it.
 @section Windows
 To get help and instructions for building FFmpeg under Windows, check out

ffmpeg.c+3−2

         av_init_packet(&pkt);
         pkt.stream_index= ost->index;
-        if (s->oformat->flags & AVFMT_RAWPICTURE) {
+        if (s->oformat->flags & AVFMT_RAWPICTURE &&
+            enc->codec->id == CODEC_ID_RAWVIDEO) {
             /* raw pictures are written as AVPicture structure to
                avoid any copies. We support temporarily the older
                method. */
         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
             continue;
-        if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
+        if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
             continue;
         for(;;) {

libavcodec/8svx.c+23−11

 /** decoder context */
 typedef struct EightSvxContext {
+    AVFrame frame;
     const int8_t *table;
     /* buffer used to store the whole audio decoded/interleaved chunk,
     return dst-dst0;
 }
-static int eightsvx_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
+/** decode a frame */
-                                 AVPacket *avpkt)
+static int eightsvx_decode_frame(AVCodecContext *avctx, void *data,
+                                 int *got_frame_ptr, AVPacket *avpkt)
 {
     EightSvxContext *esc = avctx->priv_data;
-    int out_data_size, n;
+    int n, out_data_size, ret;
+    uint8_t *out_date;
     uint8_t *src, *dst;
     /* decode and interleave the first packet */
             memcpy(esc->samples, deinterleaved_samples, esc->samples_size);
     }
-    /* return single packed with fixed size */
+    /* get output buffer */
-    out_data_size = FFMIN(MAX_FRAME_SIZE, esc->samples_size - esc->samples_idx);
+    esc->frame.nb_samples = (FFMIN(MAX_FRAME_SIZE, esc->samples_size - esc->samples_idx) +avctx->channels-1)  / avctx->channels;
-    if (*data_size < out_data_size) {
+    if ((ret = avctx->get_buffer(avctx, &esc->frame)) < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Provided buffer with size %d is too small.\n", *data_size);
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-        return AVERROR(EINVAL);
+        return ret;
     }
-    *data_size = out_data_size;
+    *got_frame_ptr   = 1;
-    dst = data;
+    *(AVFrame *)data = esc->frame;
+    dst = esc->frame.data[0];
     src = esc->samples + esc->samples_idx;
+    out_data_size = esc->frame.nb_samples * avctx->channels;
     for (n = out_data_size; n > 0; n--)
         *dst++ = *src++ + 128;
-    esc->samples_idx += *data_size;
+    esc->samples_idx += out_data_size;
     return avctx->codec->id == CODEC_ID_8SVX_FIB || avctx->codec->id == CODEC_ID_8SVX_EXP ?
         (avctx->frame_number == 0)*2 + out_data_size / 2 :
     }
     avctx->sample_fmt = AV_SAMPLE_FMT_U8;
+    avcodec_get_frame_defaults(&esc->frame);
+    avctx->coded_frame = &esc->frame;
     return 0;
 }
   .init           = eightsvx_decode_init,
   .decode         = eightsvx_decode_frame,
   .close          = eightsvx_decode_close,
+  .capabilities   = CODEC_CAP_DR1,
   .long_name      = NULL_IF_CONFIG_SMALL("8SVX fibonacci"),
 };
   .init           = eightsvx_decode_init,
   .decode         = eightsvx_decode_frame,
   .close          = eightsvx_decode_close,
+  .capabilities   = CODEC_CAP_DR1,
   .long_name      = NULL_IF_CONFIG_SMALL("8SVX exponential"),
 };
     .init           = eightsvx_decode_init,
     .close          = eightsvx_decode_close,
     .decode         = eightsvx_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name      = NULL_IF_CONFIG_SMALL("PCM signed 8-bit planar"),
 };

libavcodec/aac.h+1−0

@@ -251,6 +251,7 @@ typedef struct { · 250 unmodified lines
251	*/	251	*/
252	typedef struct {	252	typedef struct {
253	AVCodecContext *avctx;	253	AVCodecContext *avctx;
		254	AVFrame frame;
254		255
255	MPEG4AudioConfig m4ac;	256	MPEG4AudioConfig m4ac;
256		257

libavcodec/aacdec.c+61−45

@@ -471,15 +471,17 @@ static int decode_ga_specific_config(AACContext ac, AVCodecContext avctx, · 470 unmodified lines
471	* @param ac pointer to AACContext, may be null	471	* @param ac pointer to AACContext, may be null
472	* @param avctx pointer to AVCCodecContext, used for logging	472	* @param avctx pointer to AVCCodecContext, used for logging
473	* @param m4ac pointer to MPEG4AudioConfig, used for parsing	473	* @param m4ac pointer to MPEG4AudioConfig, used for parsing
474	* @param data pointer to AVCodecContext extradata	474	* @param data pointer to buffer holding an audio specific config
475	* @param data_size size of AVCCodecContext extradata	475	* @param bit_size size of audio specific config or data in bits
		476	* @param sync_extension look for an appended sync extension
476	*	477	*
477	* @return Returns error status or number of consumed bits. <0 - error	478	* @return Returns error status or number of consumed bits. <0 - error
478	*/	479	*/
479	static int decode_audio_specific_config(AACContext *ac,	480	static int decode_audio_specific_config(AACContext *ac,
480	AVCodecContext *avctx,	481	AVCodecContext *avctx,
481	MPEG4AudioConfig *m4ac,	482	MPEG4AudioConfig *m4ac,
482	const uint8_t *data, int data_size, int asclen)	483	const uint8_t *data, int bit_size,
		484	int sync_extension)
483	{	485	{
484	GetBitContext gb;	486	GetBitContext gb;
485	int i;	487	int i;
@@ -489,9 +491,9 @@ static int decode_audio_specific_config(AACContext *ac, · 3 unmodified lines
489	av_dlog(avctx, "%02x ", avctx->extradata[i]);	491	av_dlog(avctx, "%02x ", avctx->extradata[i]);
490	av_dlog(avctx, "\n");	492	av_dlog(avctx, "\n");
491		493
492	init_get_bits(&gb, data, data_size * 8);	494	init_get_bits(&gb, data, bit_size);
493		495
494	if ((i = avpriv_mpeg4audio_get_config(m4ac, data, asclen/8)) < 0)	496	if ((i = avpriv_mpeg4audio_get_config(m4ac, data, bit_size, sync_extension)) < 0)
495	return -1;	497	return -1;
496	if (m4ac->sampling_index > 12) {	498	if (m4ac->sampling_index > 12) {
497	av_log(avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", m4ac->sampling_index);	499	av_log(avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", m4ac->sampling_index);
@@ -591,7 +593,7 @@ static av_cold int aac_decode_init(AVCodecContext *avctx) · 93 unmodified lines
591	if (avctx->extradata_size > 0) {	593	if (avctx->extradata_size > 0) {
592	if (decode_audio_specific_config(ac, ac->avctx, &ac->m4ac,	594	if (decode_audio_specific_config(ac, ac->avctx, &ac->m4ac,
593	avctx->extradata,	595	avctx->extradata,
594	avctx->extradata_size, 8*avctx->extradata_size) < 0)	596	avctx->extradata_size*8, 1) < 0)
595	return -1;	597	return -1;
596	} else {	598	} else {
597	int sr, i;	599	int sr, i;
@@ -665,6 +667,9 @@ static av_cold int aac_decode_init(AVCodecContext *avctx) · 67 unmodified lines
665		667
666	cbrt_tableinit();	668	cbrt_tableinit();
667		669
		670	avcodec_get_frame_defaults(&ac->frame);
		671	avctx->coded_frame = &ac->frame;
		672
668	return 0;	673	return 0;
669	}	674	}
670		675
@@ -2132,12 +2137,12 @@ static int parse_adts_frame_header(AACContext ac, GetBitContext gb) · 1461 unmodified lines
2132	}	2137	}
2133		2138
2134	static int aac_decode_frame_int(AVCodecContext avctx, void data,	2139	static int aac_decode_frame_int(AVCodecContext avctx, void data,
2135	int data_size, GetBitContext gb)	2140	int got_frame_ptr, GetBitContext gb)
2136	{	2141	{
2137	AACContext *ac = avctx->priv_data;	2142	AACContext *ac = avctx->priv_data;
2138	ChannelElement che = NULL, che_prev = NULL;	2143	ChannelElement che = NULL, che_prev = NULL;
2139	enum RawDataBlockType elem_type, elem_type_prev = TYPE_END;	2144	enum RawDataBlockType elem_type, elem_type_prev = TYPE_END;
2140	int err, elem_id, data_size_tmp;	2145	int err, elem_id;
2141	int samples = 0, multiplier, audio_found = 0;	2146	int samples = 0, multiplier, audio_found = 0;
2142		2147
2143	if (show_bits(gb, 12) == 0xfff) {	2148	if (show_bits(gb, 12) == 0xfff) {
@@ -2250,24 +2255,26 @@ static int aac_decode_frame_int(AVCodecContext avctx, void data, · 106 unmodified lines
2250	avctx->frame_size = samples;	2255	avctx->frame_size = samples;
2251	}	2256	}
2252		2257
2253	data_size_tmp = samples * avctx->channels *
2254	av_get_bytes_per_sample(avctx->sample_fmt);
2255	if (*data_size < data_size_tmp) {
2256	av_log(avctx, AV_LOG_ERROR,
2257	"Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",
2258	*data_size, data_size_tmp);
2259	return -1;
2260	}
2261	*data_size = data_size_tmp;
2262
2263	if (samples) {	2258	if (samples) {
		2259	/* get output buffer */
		2260	ac->frame.nb_samples = samples;
		2261	if ((err = avctx->get_buffer(avctx, &ac->frame)) < 0) {
		2262	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		2263	return err;
		2264	}
		2265
2264	if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT)	2266	if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT)
2265	ac->fmt_conv.float_interleave(data, (const float **)ac->output_data,	2267	ac->fmt_conv.float_interleave((float *)ac->frame.data[0],
		2268	(const float **)ac->output_data,
2266	samples, avctx->channels);	2269	samples, avctx->channels);
2267	else	2270	else
2268	ac->fmt_conv.float_to_int16_interleave(data, (const float **)ac->output_data,	2271	ac->fmt_conv.float_to_int16_interleave((int16_t *)ac->frame.data[0],
		2272	(const float **)ac->output_data,
2269	samples, avctx->channels);	2273	samples, avctx->channels);
		2274
		2275	(AVFrame )data = ac->frame;
2270	}	2276	}
		2277	*got_frame_ptr = !!samples;
2271		2278
2272	if (ac->output_configured && audio_found)	2279	if (ac->output_configured && audio_found)
2273	ac->output_configured = OC_LOCKED;	2280	ac->output_configured = OC_LOCKED;
@@ -2276,7 +2283,7 @@ static int aac_decode_frame_int(AVCodecContext avctx, void data, · 2 unmodified lines
2276	}	2283	}
2277		2284
2278	static int aac_decode_frame(AVCodecContext avctx, void data,	2285	static int aac_decode_frame(AVCodecContext avctx, void data,
2279	int data_size, AVPacket avpkt)	2286	int got_frame_ptr, AVPacket avpkt)
2280	{	2287	{
2281	const uint8_t *buf = avpkt->data;	2288	const uint8_t *buf = avpkt->data;
2282	int buf_size = avpkt->size;	2289	int buf_size = avpkt->size;
@@ -2287,7 +2294,7 @@ static int aac_decode_frame(AVCodecContext avctx, void data, · 4 unmodified lines
2287		2294
2288	init_get_bits(&gb, buf, buf_size * 8);	2295	init_get_bits(&gb, buf, buf_size * 8);
2289		2296
2290	if ((err = aac_decode_frame_int(avctx, data, data_size, &gb)) < 0)	2297	if ((err = aac_decode_frame_int(avctx, data, got_frame_ptr, &gb)) < 0)
2291	return err;	2298	return err;
2292		2299
2293	buf_consumed = (get_bits_count(&gb) + 7) >> 3;	2300	buf_consumed = (get_bits_count(&gb) + 7) >> 3;
@@ -2340,30 +2347,40 @@ static inline uint32_t latm_get_value(GetBitContext *b) · 46 unmodified lines
2340	static int latm_decode_audio_specific_config(struct LATMContext *latmctx,	2347	static int latm_decode_audio_specific_config(struct LATMContext *latmctx,
2341	GetBitContext *gb, int asclen)	2348	GetBitContext *gb, int asclen)
2342	{	2349	{
2343	AVCodecContext *avctx = latmctx->aac_ctx.avctx;	2350	AACContext *ac = &latmctx->aac_ctx;
2344	AACContext *ac= &latmctx->aac_ctx;	2351	AVCodecContext *avctx = ac->avctx;
2345	MPEG4AudioConfig m4ac=ac->m4ac;	2352	MPEG4AudioConfig m4ac = {0};
2346	int config_start_bit = get_bits_count(gb);	2353	int config_start_bit = get_bits_count(gb);
2347	int bits_consumed, esize;	2354	int sync_extension = 0;
		2355	int bits_consumed, esize;
		2356
		2357	if (asclen) {
		2358	sync_extension = 1;
		2359	asclen = FFMIN(asclen, get_bits_left(gb));
		2360	} else
		2361	asclen = get_bits_left(gb);
2348		2362
2349	if (config_start_bit % 8) {	2363	if (config_start_bit % 8) {
2350	av_log_missing_feature(latmctx->aac_ctx.avctx, "audio specific "	2364	av_log_missing_feature(latmctx->aac_ctx.avctx, "audio specific "
2351	"config not byte aligned.\n", 1);	2365	"config not byte aligned.\n", 1);
2352	return AVERROR_INVALIDDATA;	2366	return AVERROR_INVALIDDATA;
2353	} else {	2367	}
2354	bits_consumed =	2368	bits_consumed = decode_audio_specific_config(NULL, avctx, &m4ac,
2355	decode_audio_specific_config(ac, avctx, &m4ac,
2356	gb->buffer + (config_start_bit / 8),	2369	gb->buffer + (config_start_bit / 8),
2357	get_bits_left(gb) / 8, asclen);	2370	asclen, sync_extension);
2358		2371
2359	if (bits_consumed < 0)	2372	if (bits_consumed < 0)
2360	return AVERROR_INVALIDDATA;	2373	return AVERROR_INVALIDDATA;
2361	if(ac->m4ac.sample_rate != m4ac.sample_rate \|\| m4ac.chan_config != ac->m4ac.chan_config)	2374
2362	ac->m4ac= m4ac;	2375	if (ac->m4ac.sample_rate != m4ac.sample_rate \|\|
		2376	ac->m4ac.chan_config != m4ac.chan_config) {
		2377
		2378	av_log(avctx, AV_LOG_INFO, "audio config changed\n");
		2379	latmctx->initialized = 0;
2363		2380
2364	esize = (bits_consumed+7) / 8;	2381	esize = (bits_consumed+7) / 8;
2365		2382
2366	if (avctx->extradata_size <= esize) {	2383	if (avctx->extradata_size < esize) {
2367	av_free(avctx->extradata);	2384	av_free(avctx->extradata);
2368	avctx->extradata = av_malloc(esize + FF_INPUT_BUFFER_PADDING_SIZE);	2385	avctx->extradata = av_malloc(esize + FF_INPUT_BUFFER_PADDING_SIZE);
2369	if (!avctx->extradata)	2386	if (!avctx->extradata)
@@ -2373,9 +2390,8 @@ static int latm_decode_audio_specific_config(struct LATMContext *latmctx, · 3 unmodified lines
2373	avctx->extradata_size = esize;	2390	avctx->extradata_size = esize;
2374	memcpy(avctx->extradata, gb->buffer + (config_start_bit/8), esize);	2391	memcpy(avctx->extradata, gb->buffer + (config_start_bit/8), esize);
2375	memset(avctx->extradata+esize, 0, FF_INPUT_BUFFER_PADDING_SIZE);	2392	memset(avctx->extradata+esize, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2376
2377	skip_bits_long(gb, bits_consumed);
2378	}	2393	}
		2394	skip_bits_long(gb, bits_consumed);
2379		2395
2380	return bits_consumed;	2396	return bits_consumed;
2381	}	2397	}
@@ -2512,8 +2528,8 @@ static int read_audio_mux_element(struct LATMContext *latmctx, · 130 unmodified lines
2512	}	2528	}
2513		2529
2514		2530
2515	static int latm_decode_frame(AVCodecContext avctx, void out, int *out_size,	2531	static int latm_decode_frame(AVCodecContext avctx, void out,
2516	AVPacket *avpkt)	2532	int got_frame_ptr, AVPacket avpkt)
2517	{	2533	{
2518	struct LATMContext *latmctx = avctx->priv_data;	2534	struct LATMContext *latmctx = avctx->priv_data;
2519	int muxlength, err;	2535	int muxlength, err;
@@ -2535,12 +2551,12 @@ static int latm_decode_frame(AVCodecContext avctx, void out, int *out_size, · 15 unmodified lines
2535		2551
2536	if (!latmctx->initialized) {	2552	if (!latmctx->initialized) {
2537	if (!avctx->extradata) {	2553	if (!avctx->extradata) {
2538	*out_size = 0;	2554	*got_frame_ptr = 0;
2539	return avpkt->size;	2555	return avpkt->size;
2540	} else {	2556	} else {
2541	if ((err = decode_audio_specific_config(	2557	if ((err = decode_audio_specific_config(
2542	&latmctx->aac_ctx, avctx, &latmctx->aac_ctx.m4ac,	2558	&latmctx->aac_ctx, avctx, &latmctx->aac_ctx.m4ac,
2543	avctx->extradata, avctx->extradata_size, 8*avctx->extradata_size)) < 0)	2559	avctx->extradata, avctx->extradata_size*8, 1)) < 0)
2544	return err;	2560	return err;
2545	latmctx->initialized = 1;	2561	latmctx->initialized = 1;
2546	}	2562	}
@@ -2553,7 +2569,7 @@ static int latm_decode_frame(AVCodecContext avctx, void out, int *out_size, · 6 unmodified lines
2553	return AVERROR_INVALIDDATA;	2569	return AVERROR_INVALIDDATA;
2554	}	2570	}
2555		2571
2556	if ((err = aac_decode_frame_int(avctx, out, out_size, &gb)) < 0)	2572	if ((err = aac_decode_frame_int(avctx, out, got_frame_ptr, &gb)) < 0)
2557	return err;	2573	return err;
2558		2574
2559	return muxlength;	2575	return muxlength;
@@ -2583,7 +2599,7 @@ AVCodec ff_aac_decoder = { · 23 unmodified lines
2583	.sample_fmts = (const enum AVSampleFormat[]) {	2599	.sample_fmts = (const enum AVSampleFormat[]) {
2584	AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE	2600	AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
2585	},	2601	},
2586	.capabilities = CODEC_CAP_CHANNEL_CONF,	2602	.capabilities = CODEC_CAP_CHANNEL_CONF \| CODEC_CAP_DR1,
2587	.channel_layouts = aac_channel_layout,	2603	.channel_layouts = aac_channel_layout,
2588	};	2604	};
2589		2605
@@ -2604,7 +2620,7 @@ AVCodec ff_aac_latm_decoder = { · 14 unmodified lines
2604	.sample_fmts = (const enum AVSampleFormat[]) {	2620	.sample_fmts = (const enum AVSampleFormat[]) {
2605	AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE	2621	AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
2606	},	2622	},
2607	.capabilities = CODEC_CAP_CHANNEL_CONF,	2623	.capabilities = CODEC_CAP_CHANNEL_CONF \| CODEC_CAP_DR1,
2608	.channel_layouts = aac_channel_layout,	2624	.channel_layouts = aac_channel_layout,
2609	.flush = flush,	2625	.flush = flush,
2610	};	2626	};

libavcodec/ac3dec.c+24−16

@@ -208,6 +208,9 @@ static av_cold int ac3_decode_init(AVCodecContext *avctx) · 207 unmodified lines
208	}	208	}
209	s->downmixed = 1;	209	s->downmixed = 1;
210		210
		211	avcodec_get_frame_defaults(&s->frame);
		212	avctx->coded_frame = &s->frame;
		213
211	return 0;	214	return 0;
212	}	215	}
213		216
@@ -1296,16 +1299,15 @@ static int decode_audio_block(AC3DecodeContext *s, int blk) · 1082 unmodified lines
1296	/**	1299	/**
1297	* Decode a single AC-3 frame.	1300	* Decode a single AC-3 frame.
1298	*/	1301	*/
1299	static int ac3_decode_frame(AVCodecContext * avctx, void data, int data_size,	1302	static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1300	AVPacket *avpkt)	1303	int got_frame_ptr, AVPacket avpkt)
1301	{	1304	{
1302	const uint8_t *buf = avpkt->data;	1305	const uint8_t *buf = avpkt->data;
1303	int buf_size = avpkt->size;	1306	int buf_size = avpkt->size;
1304	AC3DecodeContext *s = avctx->priv_data;	1307	AC3DecodeContext *s = avctx->priv_data;
1305	float *out_samples_flt = data;	1308	float *out_samples_flt;
1306	int16_t *out_samples_s16 = data;	1309	int16_t *out_samples_s16;
1307	int blk, ch, err;	1310	int blk, ch, err, ret;
1308	int data_size_orig, data_size_tmp;
1309	const uint8_t *channel_map;	1311	const uint8_t *channel_map;
1310	const float *output[AC3_MAX_CHANNELS];	1312	const float *output[AC3_MAX_CHANNELS];
1311		1313
@@ -1322,8 +1324,6 @@ static int ac3_decode_frame(AVCodecContext * avctx, void data, int data_size, · 10 unmodified lines
1322	init_get_bits(&s->gbc, buf, buf_size * 8);	1324	init_get_bits(&s->gbc, buf, buf_size * 8);
1323		1325
1324	/* parse the syncinfo */	1326	/* parse the syncinfo */
1325	data_size_orig = *data_size;
1326	*data_size = 0;
1327	err = parse_frame_header(s);	1327	err = parse_frame_header(s);
1328		1328
1329	if (err) {	1329	if (err) {
@@ -1345,6 +1345,7 @@ static int ac3_decode_frame(AVCodecContext * avctx, void data, int data_size, · 15 unmodified lines
1345	/* TODO: add support for substreams and dependent frames */	1345	/* TODO: add support for substreams and dependent frames */
1346	if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT \|\| s->substreamid) {	1346	if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT \|\| s->substreamid) {
1347	av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");	1347	av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
		1348	*got_frame_ptr = 0;
1348	return s->frame_size;	1349	return s->frame_size;
1349	} else {	1350	} else {
1350	av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");	1351	av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
@@ -1406,21 +1407,24 @@ static int ac3_decode_frame(AVCodecContext * avctx, void data, int data_size, · 55 unmodified lines
1406	if (s->bitstream_mode == 0x7 && s->channels > 1)	1407	if (s->bitstream_mode == 0x7 && s->channels > 1)
1407	avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;	1408	avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1408		1409
		1410	/* get output buffer */
		1411	s->frame.nb_samples = s->num_blocks * 256;
		1412	if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
		1413	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		1414	return ret;
		1415	}
		1416	out_samples_flt = (float *)s->frame.data[0];
		1417	out_samples_s16 = (int16_t *)s->frame.data[0];
		1418
1409	/* decode the audio blocks */	1419	/* decode the audio blocks */
1410	channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];	1420	channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1411	for (ch = 0; ch < s->out_channels; ch++)	1421	for (ch = 0; ch < s->out_channels; ch++)
1412	output[ch] = s->output[channel_map[ch]];	1422	output[ch] = s->output[channel_map[ch]];
1413	data_size_tmp = s->num_blocks * 256 * avctx->channels;
1414	data_size_tmp = avctx->sample_fmt == AV_SAMPLE_FMT_FLT ? sizeof(out_samples_flt) : sizeof(*out_samples_s16);
1415	if (data_size_orig < data_size_tmp)
1416	return -1;
1417	*data_size = data_size_tmp;
1418	for (blk = 0; blk < s->num_blocks; blk++) {	1423	for (blk = 0; blk < s->num_blocks; blk++) {
1419	if (!err && decode_audio_block(s, blk)) {	1424	if (!err && decode_audio_block(s, blk)) {
1420	av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");	1425	av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1421	err = 1;	1426	err = 1;
1422	}	1427	}
1423
1424	if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {	1428	if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
1425	s->fmt_conv.float_interleave(out_samples_flt, output, 256,	1429	s->fmt_conv.float_interleave(out_samples_flt, output, 256,
1426	s->out_channels);	1430	s->out_channels);
@@ -1431,8 +1435,10 @@ static int ac3_decode_frame(AVCodecContext * avctx, void data, int data_size, · 4 unmodified lines
1431	out_samples_s16 += 256 * s->out_channels;	1435	out_samples_s16 += 256 * s->out_channels;
1432	}	1436	}
1433	}	1437	}
1434	data_size = s->num_blocks 256 * avctx->channels *	1438
1435	av_get_bytes_per_sample(avctx->sample_fmt);	1439	*got_frame_ptr = 1;
		1440	(AVFrame )data = s->frame;
		1441
1436	return FFMIN(buf_size, s->frame_size);	1442	return FFMIN(buf_size, s->frame_size);
1437	}	1443	}
1438		1444
@@ -1477,6 +1483,7 @@ AVCodec ff_ac3_decoder = { · 38 unmodified lines
1477	.init = ac3_decode_init,	1483	.init = ac3_decode_init,
1478	.close = ac3_decode_end,	1484	.close = ac3_decode_end,
1479	.decode = ac3_decode_frame,	1485	.decode = ac3_decode_frame,
		1486	.capabilities = CODEC_CAP_DR1,
1480	.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),	1487	.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1481	.sample_fmts = (const enum AVSampleFormat[]) {	1488	.sample_fmts = (const enum AVSampleFormat[]) {
1482	AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE	1489	AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
@@ -1499,6 +1506,7 @@ AVCodec ff_eac3_decoder = { · 16 unmodified lines
1499	.init = ac3_decode_init,	1506	.init = ac3_decode_init,
1500	.close = ac3_decode_end,	1507	.close = ac3_decode_end,
1501	.decode = ac3_decode_frame,	1508	.decode = ac3_decode_frame,
		1509	.capabilities = CODEC_CAP_DR1,
1502	.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),	1510	.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1503	.sample_fmts = (const enum AVSampleFormat[]) {	1511	.sample_fmts = (const enum AVSampleFormat[]) {
1504	AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE	1512	AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE

libavcodec/ac3dec.h+1−0

@@ -68,6 +68,7 @@ · 67 unmodified lines
68	typedef struct {	68	typedef struct {
69	AVClass *class; ///< class for AVOptions	69	AVClass *class; ///< class for AVOptions
70	AVCodecContext *avctx; ///< parent context	70	AVCodecContext *avctx; ///< parent context
		71	AVFrame frame; ///< AVFrame for decoded output
71	GetBitContext gbc; ///< bitstream reader	72	GetBitContext gbc; ///< bitstream reader
72		73
73	///@name Bit stream information	74	///@name Bit stream information

libavcodec/adpcm.c+25−17

@@ -84,6 +84,7 @@ static const int swf_index_tables[4][16] = { · 83 unmodified lines
84	/* end of tables */	84	/* end of tables */
85		85
86	typedef struct ADPCMDecodeContext {	86	typedef struct ADPCMDecodeContext {
		87	AVFrame frame;
87	ADPCMChannelStatus status[6];	88	ADPCMChannelStatus status[6];
88	} ADPCMDecodeContext;	89	} ADPCMDecodeContext;
89		90
@@ -124,6 +125,10 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx) · 34 unmodified lines
124	break;	125	break;
125	}	126	}
126	avctx->sample_fmt = AV_SAMPLE_FMT_S16;	127	avctx->sample_fmt = AV_SAMPLE_FMT_S16;
		128
		129	avcodec_get_frame_defaults(&c->frame);
		130	avctx->coded_frame = &c->frame;
		131
127	return 0;	132	return 0;
128	}	133	}
129		134
@@ -501,9 +506,8 @@ static int get_nb_samples(AVCodecContext avctx, const uint8_t buf, · 371 unmodified lines
501	decode_top_nibble_next = 1; \	506	decode_top_nibble_next = 1; \
502	}	507	}
503		508
504	static int adpcm_decode_frame(AVCodecContext *avctx,	509	static int adpcm_decode_frame(AVCodecContext avctx, void data,
505	void data, int data_size,	510	int got_frame_ptr, AVPacket avpkt)
506	AVPacket *avpkt)
507	{	511	{
508	const uint8_t *buf = avpkt->data;	512	const uint8_t *buf = avpkt->data;
509	int buf_size = avpkt->size;	513	int buf_size = avpkt->size;
@@ -514,7 +518,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, · 4 unmodified lines
514	const uint8_t *src;	518	const uint8_t *src;
515	int st; /* stereo */	519	int st; /* stereo */
516	int count1, count2;	520	int count1, count2;
517	int nb_samples, coded_samples, out_bps, out_size;	521	int nb_samples, coded_samples, ret;
518		522
519	nb_samples = get_nb_samples(avctx, buf, buf_size, &coded_samples);	523	nb_samples = get_nb_samples(avctx, buf, buf_size, &coded_samples);
520	if (nb_samples <= 0) {	524	if (nb_samples <= 0) {
@@ -522,22 +526,22 @@ static int adpcm_decode_frame(AVCodecContext *avctx, · 1 unmodified line
522	return AVERROR_INVALIDDATA;	526	return AVERROR_INVALIDDATA;
523	}	527	}
524		528
525	out_bps = av_get_bytes_per_sample(avctx->sample_fmt);	529	/* get output buffer */
526	out_size = nb_samples * avctx->channels * out_bps;	530	c->frame.nb_samples = nb_samples;
527	if (*data_size < out_size) {	531	if ((ret = avctx->get_buffer(avctx, &c->frame)) < 0) {
528	av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");	532	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
529	return AVERROR(EINVAL);	533	return ret;
530	}	534	}
		535	samples = (short *)c->frame.data[0];
		536
531	/* use coded_samples when applicable */	537	/* use coded_samples when applicable */
532	/* it is always <= nb_samples, so the output buffer will be large enough */	538	/* it is always <= nb_samples, so the output buffer will be large enough */
533	if (coded_samples) {	539	if (coded_samples) {
534	if (coded_samples != nb_samples)	540	if (coded_samples != nb_samples)
535	av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");	541	av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");
536	nb_samples = coded_samples;	542	c->frame.nb_samples = nb_samples = coded_samples;
537	out_size = nb_samples * avctx->channels * out_bps;
538	}	543	}
539		544
540	samples = data;
541	src = buf;	545	src = buf;
542		546
543	st = avctx->channels == 2 ? 1 : 0;	547	st = avctx->channels == 2 ? 1 : 0;
@@ -576,7 +580,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, · 32 unmodified lines
576	cs->step_index = 88;	580	cs->step_index = 88;
577	}	581	}
578		582
579	samples = (short*)data + channel;	583	samples = (short *)c->frame.data[0] + channel;
580		584
581	for (m = 0; m < 32; m++) {	585	for (m = 0; m < 32; m++) {
582	*samples = adpcm_ima_qt_expand_nibble(cs, src[0] & 0x0F, 3);	586	*samples = adpcm_ima_qt_expand_nibble(cs, src[0] & 0x0F, 3);
@@ -628,7 +632,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, · 45 unmodified lines
628	}	632	}
629		633
630	for (i = 0; i < avctx->channels; i++) {	634	for (i = 0; i < avctx->channels; i++) {
631	samples = (short*)data + i;	635	samples = (short *)c->frame.data[0] + i;
632	cs = &c->status[i];	636	cs = &c->status[i];
633	for (n = nb_samples >> 1; n > 0; n--, src++) {	637	for (n = nb_samples >> 1; n > 0; n--, src++) {
634	uint8_t v = *src;	638	uint8_t v = *src;
@@ -965,7 +969,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, · 330 unmodified lines
965	}	969	}
966	}	970	}
967		971
968	out_size = count * 28 * avctx->channels * out_bps;	972	c->frame.nb_samples = count * 28;
969	src = src_end;	973	src = src_end;
970	break;	974	break;
971	}	975	}
@@ -1144,7 +1148,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx, · 172 unmodified lines
1144	prev[0][i] = (int16_t)bytestream_get_be16(&src);	1148	prev[0][i] = (int16_t)bytestream_get_be16(&src);
1145		1149
1146	for (ch = 0; ch <= st; ch++) {	1150	for (ch = 0; ch <= st; ch++) {
1147	samples = (unsigned short *) data + ch;	1151	samples = (short *)c->frame.data[0] + ch;
1148		1152
1149	/* Read in every sample for this channel. */	1153	/* Read in every sample for this channel. */
1150	for (i = 0; i < nb_samples / 14; i++) {	1154	for (i = 0; i < nb_samples / 14; i++) {
@@ -1177,7 +1181,10 @@ static int adpcm_decode_frame(AVCodecContext *avctx, · 26 unmodified lines
1177	default:	1181	default:
1178	return -1;	1182	return -1;
1179	}	1183	}
1180	*data_size = out_size;	1184
		1185	*got_frame_ptr = 1;
		1186	(AVFrame )data = c->frame;
		1187
1181	return src - buf;	1188	return src - buf;
1182	}	1189	}
1183		1190
@@ -1190,6 +1197,7 @@ AVCodec ff_ ## name_ ## _decoder = { \ · 6 unmodified lines
1190	.priv_data_size = sizeof(ADPCMDecodeContext), \	1197	.priv_data_size = sizeof(ADPCMDecodeContext), \
1191	.init = adpcm_decode_init, \	1198	.init = adpcm_decode_init, \
1192	.decode = adpcm_decode_frame, \	1199	.decode = adpcm_decode_frame, \
		1200	.capabilities = CODEC_CAP_DR1, \
1193	.long_name = NULL_IF_CONFIG_SMALL(long_name_), \	1201	.long_name = NULL_IF_CONFIG_SMALL(long_name_), \
1194	}	1202	}
1195		1203

libavcodec/adx.h+1−0

@@ -40,6 +40,7 @@ typedef struct { · 39 unmodified lines
40	} ADXChannelState;	40	} ADXChannelState;
41		41
42	typedef struct {	42	typedef struct {
		43	AVFrame frame;
43	int channels;	44	int channels;
44	ADXChannelState prev[2];	45	ADXChannelState prev[2];
45	int header_parsed;	46	int header_parsed;

libavcodec/adxdec.c+27−14

@@ -50,6 +50,10 @@ static av_cold int adx_decode_init(AVCodecContext *avctx) · 49 unmodified lines
50	c->channels = avctx->channels;	50	c->channels = avctx->channels;
51		51
52	avctx->sample_fmt = AV_SAMPLE_FMT_S16;	52	avctx->sample_fmt = AV_SAMPLE_FMT_S16;
		53
		54	avcodec_get_frame_defaults(&c->frame);
		55	avctx->coded_frame = &c->frame;
		56
53	return 0;	57	return 0;
54	}	58	}
55		59
@@ -89,36 +93,42 @@ static int adx_decode(ADXContext c, int16_t out, const uint8_t *in, int ch) · 33 unmodified lines
89	return 0;	93	return 0;
90	}	94	}
91		95
92	static int adx_decode_frame(AVCodecContext avctx, void data, int *data_size,	96	static int adx_decode_frame(AVCodecContext avctx, void data,
93	AVPacket *avpkt)	97	int got_frame_ptr, AVPacket avpkt)
94	{	98	{
95	int buf_size = avpkt->size;	99	int buf_size = avpkt->size;
96	ADXContext *c = avctx->priv_data;	100	ADXContext *c = avctx->priv_data;
97	int16_t *samples = data;	101	int16_t *samples;
98	const uint8_t *buf = avpkt->data;	102	const uint8_t *buf = avpkt->data;
99	int num_blocks, ch;	103	int num_blocks, ch, ret;
100		104
101	if (c->eof) {	105	if (c->eof) {
102	*data_size = 0;	106	*got_frame_ptr = 0;
103	return buf_size;	107	return buf_size;
104	}	108	}
105		109
106	/* 18 bytes of data are expanded into 32*2 bytes of audio,	110	/* calculate number of blocks in the packet */
107	so guard against buffer overflows */
108	num_blocks = buf_size / (BLOCK_SIZE * c->channels);	111	num_blocks = buf_size / (BLOCK_SIZE * c->channels);
109	if (num_blocks > data_size / (BLOCK_SAMPLES c->channels)) {	112
110	buf_size = (data_size / (BLOCK_SAMPLES c->channels)) * BLOCK_SIZE;	113	/* if the packet is not an even multiple of BLOCK_SIZE, check for an EOF
111	num_blocks = buf_size / (BLOCK_SIZE * c->channels);	114	packet */
112	}	115	if (!num_blocks \|\| buf_size % (BLOCK_SIZE * avctx->channels)) {
113	if (!buf_size \|\| buf_size % (BLOCK_SIZE * avctx->channels)) {
114	if (buf_size >= 4 && (AV_RB16(buf) & 0x8000)) {	116	if (buf_size >= 4 && (AV_RB16(buf) & 0x8000)) {
115	c->eof = 1;	117	c->eof = 1;
116	*data_size = 0;	118	*got_frame_ptr = 0;
117	return avpkt->size;	119	return avpkt->size;
118	}	120	}
119	return AVERROR_INVALIDDATA;	121	return AVERROR_INVALIDDATA;
120	}	122	}
121		123
		124	/* get output buffer */
		125	c->frame.nb_samples = num_blocks * BLOCK_SAMPLES;
		126	if ((ret = avctx->get_buffer(avctx, &c->frame)) < 0) {
		127	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		128	return ret;
		129	}
		130	samples = (int16_t *)c->frame.data[0];
		131
122	while (num_blocks--) {	132	while (num_blocks--) {
123	for (ch = 0; ch < c->channels; ch++) {	133	for (ch = 0; ch < c->channels; ch++) {
124	if (adx_decode(c, samples + ch, buf, ch)) {	134	if (adx_decode(c, samples + ch, buf, ch)) {
@@ -132,7 +142,9 @@ static int adx_decode_frame(AVCodecContext avctx, void data, int *data_size, · 7 unmodified lines
132	samples += BLOCK_SAMPLES * c->channels;	142	samples += BLOCK_SAMPLES * c->channels;
133	}	143	}
134		144
135	data_size = (uint8_t)samples - (uint8_t*)data;	145	*got_frame_ptr = 1;
		146	(AVFrame )data = c->frame;
		147
136	return buf - avpkt->data;	148	return buf - avpkt->data;
137	}	149	}
138		150
@@ -143,5 +155,6 @@ AVCodec ff_adpcm_adx_decoder = { · 4 unmodified lines
143	.priv_data_size = sizeof(ADXContext),	155	.priv_data_size = sizeof(ADXContext),
144	.init = adx_decode_init,	156	.init = adx_decode_init,
145	.decode = adx_decode_frame,	157	.decode = adx_decode_frame,
		158	.capabilities = CODEC_CAP_DR1,
146	.long_name = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"),	159	.long_name = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"),
147	};	160	};

libavcodec/alac.c+28−17

@@ -62,10 +62,10 @@ · 61 unmodified lines
62	typedef struct {	62	typedef struct {
63		63
64	AVCodecContext *avctx;	64	AVCodecContext *avctx;
		65	AVFrame frame;
65	GetBitContext gb;	66	GetBitContext gb;
66		67
67	int numchannels;	68	int numchannels;
68	int bytespersample;
69		69
70	/* buffers */	70	/* buffers */
71	int32_t *predicterror_buffer[MAX_CHANNELS];	71	int32_t *predicterror_buffer[MAX_CHANNELS];
@@ -351,9 +351,8 @@ static void interleave_stereo_24(int32_t *buffer[MAX_CHANNELS], · 279 unmodified lines
351	}	351	}
352	}	352	}
353		353
354	static int alac_decode_frame(AVCodecContext *avctx,	354	static int alac_decode_frame(AVCodecContext avctx, void data,
355	void outbuffer, int outputsize,	355	int got_frame_ptr, AVPacket avpkt)
356	AVPacket *avpkt)
357	{	356	{
358	const uint8_t *inbuffer = avpkt->data;	357	const uint8_t *inbuffer = avpkt->data;
359	int input_buffer_size = avpkt->size;	358	int input_buffer_size = avpkt->size;
@@ -366,7 +365,7 @@ static int alac_decode_frame(AVCodecContext *avctx, · 6 unmodified lines
366	int isnotcompressed;	365	int isnotcompressed;
367	uint8_t interlacing_shift;	366	uint8_t interlacing_shift;
368	uint8_t interlacing_leftweight;	367	uint8_t interlacing_leftweight;
369	int i, ch;	368	int i, ch, ret;
370		369
371	init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8);	370	init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8);
372		371
@@ -401,14 +400,17 @@ static int alac_decode_frame(AVCodecContext *avctx, · 28 unmodified lines
401	} else	400	} else
402	outputsamples = alac->setinfo_max_samples_per_frame;	401	outputsamples = alac->setinfo_max_samples_per_frame;
403		402
404	alac->bytespersample = channels * av_get_bytes_per_sample(avctx->sample_fmt);	403	/* get output buffer */
405		404	if (outputsamples > INT32_MAX) {
406	if(outputsamples > *outputsize / alac->bytespersample){	405	av_log(avctx, AV_LOG_ERROR, "unsupported block size: %u\n", outputsamples);
407	av_log(avctx, AV_LOG_ERROR, "sample buffer too small\n");	406	return AVERROR_INVALIDDATA;
408	return -1;	407	}
		408	alac->frame.nb_samples = outputsamples;
		409	if ((ret = avctx->get_buffer(avctx, &alac->frame)) < 0) {
		410	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		411	return ret;
409	}	412	}
410		413
411	outputsize = outputsamples alac->bytespersample;
412	readsamplesize = alac->setinfo_sample_size - alac->extra_bits + channels - 1;	414	readsamplesize = alac->setinfo_sample_size - alac->extra_bits + channels - 1;
413	if (readsamplesize > MIN_CACHE_BITS) {	415	if (readsamplesize > MIN_CACHE_BITS) {
414	av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize);	416	av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize);
@@ -501,21 +503,23 @@ static int alac_decode_frame(AVCodecContext *avctx, · 86 unmodified lines
501	switch(alac->setinfo_sample_size) {	503	switch(alac->setinfo_sample_size) {
502	case 16:	504	case 16:
503	if (channels == 2) {	505	if (channels == 2) {
504	interleave_stereo_16(alac->outputsamples_buffer, outbuffer,	506	interleave_stereo_16(alac->outputsamples_buffer,
505	outputsamples);	507	(int16_t *)alac->frame.data[0], outputsamples);
506	} else {	508	} else {
		509	int16_t outbuffer = (int16_t )alac->frame.data[0];
507	for (i = 0; i < outputsamples; i++) {	510	for (i = 0; i < outputsamples; i++) {
508	((int16_t*)outbuffer)[i] = alac->outputsamples_buffer[0][i];	511	outbuffer[i] = alac->outputsamples_buffer[0][i];
509	}	512	}
510	}	513	}
511	break;	514	break;
512	case 24:	515	case 24:
513	if (channels == 2) {	516	if (channels == 2) {
514	interleave_stereo_24(alac->outputsamples_buffer, outbuffer,	517	interleave_stereo_24(alac->outputsamples_buffer,
515	outputsamples);	518	(int32_t *)alac->frame.data[0], outputsamples);
516	} else {	519	} else {
		520	int32_t outbuffer = (int32_t )alac->frame.data[0];
517	for (i = 0; i < outputsamples; i++)	521	for (i = 0; i < outputsamples; i++)
518	((int32_t *)outbuffer)[i] = alac->outputsamples_buffer[0][i] << 8;	522	outbuffer[i] = alac->outputsamples_buffer[0][i] << 8;
519	}	523	}
520	break;	524	break;
521	}	525	}
@@ -523,6 +527,9 @@ static int alac_decode_frame(AVCodecContext *avctx, · 1 unmodified line
523	if (input_buffer_size * 8 - get_bits_count(&alac->gb) > 8)	527	if (input_buffer_size * 8 - get_bits_count(&alac->gb) > 8)
524	av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", input_buffer_size * 8 - get_bits_count(&alac->gb));	528	av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", input_buffer_size * 8 - get_bits_count(&alac->gb));
525		529
		530	*got_frame_ptr = 1;
		531	(AVFrame )data = alac->frame;
		532
526	return input_buffer_size;	533	return input_buffer_size;
527	}	534	}
528		535
@@ -637,6 +644,9 @@ static av_cold int alac_decode_init(AVCodecContext * avctx) · 108 unmodified lines
637	return ret;	644	return ret;
638	}	645	}
639		646
		647	avcodec_get_frame_defaults(&alac->frame);
		648	avctx->coded_frame = &alac->frame;
		649
640	return 0;	650	return 0;
641	}	651	}
642		652
@@ -648,5 +658,6 @@ AVCodec ff_alac_decoder = { · 5 unmodified lines
648	.init = alac_decode_init,	658	.init = alac_decode_init,
649	.close = alac_decode_close,	659	.close = alac_decode_close,
650	.decode = alac_decode_frame,	660	.decode = alac_decode_frame,
		661	.capabilities = CODEC_CAP_DR1,
651	.long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),	662	.long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
652	};	663	};

libavcodec/alacenc.c+54−47

 } AlacEncodeContext;
-static void init_sample_buffers(AlacEncodeContext *s, const int16_t *input_samples)
+static void init_sample_buffers(AlacEncodeContext *s,
+                                const int16_t *input_samples)
 {
     int ch, i;
-    for(ch=0;ch<s->avctx->channels;ch++) {
+    for (ch = 0; ch < s->avctx->channels; ch++) {
         const int16_t *sptr = input_samples + ch;
-        for(i=0;i<s->avctx->frame_size;i++) {
+        for (i = 0; i < s->avctx->frame_size; i++) {
             s->sample_buf[ch][i] = *sptr;
             sptr += s->avctx->channels;
         }
     }
 }
-static void encode_scalar(AlacEncodeContext *s, int x, int k, int write_sample_size)
+static void encode_scalar(AlacEncodeContext *s, int x,
+                          int k, int write_sample_size)
 {
     int divisor, q, r;
     q = x / divisor;
     r = x % divisor;
-    if(q > 8) {
+    if (q > 8) {
         // write escape code and sample value directly
         put_bits(&s->pbctx, 9, ALAC_ESCAPE_CODE);
         put_bits(&s->pbctx, write_sample_size, x);
     } else {
-        if(q)
+        if (q)
             put_bits(&s->pbctx, q, (1<<q) - 1);
         put_bits(&s->pbctx, 1, 0);
-        if(k != 1) {
+        if (k != 1) {
-            if(r > 0)
+            if (r > 0)
                 put_bits(&s->pbctx, k, r+1);
             else
                 put_bits(&s->pbctx, k-1, 0);
     /* calculate sum of 2nd order residual for each channel */
     sum[0] = sum[1] = sum[2] = sum[3] = 0;
-    for(i=2; i<n; i++) {
+    for (i = 2; i < n; i++) {
         lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
         rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
         sum[2] += FFABS((lt + rt) >> 1);
     /* return mode with lowest score */
     best = 0;
-    for(i=1; i<4; i++) {
+    for (i = 1; i < 4; i++) {
-        if(score[i] < score[best]) {
+        if (score[i] < score[best]) {
             best = i;
         }
     }
             break;
         case ALAC_CHMODE_LEFT_SIDE:
-            for(i=0; i<n; i++) {
+            for (i = 0; i < n; i++) {
                 right[i] = left[i] - right[i];
             }
             s->interlacing_leftweight = 1;
             break;
         case ALAC_CHMODE_RIGHT_SIDE:
-            for(i=0; i<n; i++) {
+            for (i = 0; i < n; i++) {
                 tmp = right[i];
                 right[i] = left[i] - right[i];
                 left[i] = tmp + (right[i] >> 31);
             break;
         default:
-            for(i=0; i<n; i++) {
+            for (i = 0; i < n; i++) {
                 tmp = left[i];
                 left[i] = (tmp + right[i]) >> 1;
                 right[i] = tmp - right[i];
     int i;
     AlacLPCContext lpc = s->lpc[ch];
-    if(lpc.lpc_order == 31) {
+    if (lpc.lpc_order == 31) {
         s->predictor_buf[0] = s->sample_buf[ch][0];
-        for(i=1; i<s->avctx->frame_size; i++)
+        for (i = 1; i < s->avctx->frame_size; i++)
             s->predictor_buf[i] = s->sample_buf[ch][i] - s->sample_buf[ch][i-1];
         return;
     // generalised linear predictor
-    if(lpc.lpc_order > 0) {
+    if (lpc.lpc_order > 0) {
         int32_t *samples  = s->sample_buf[ch];
         int32_t *residual = s->predictor_buf;
         // generate warm-up samples
         residual[0] = samples[0];
-        for(i=1;i<=lpc.lpc_order;i++)
+        for (i = 1; i <= lpc.lpc_order; i++)
             residual[i] = samples[i] - samples[i-1];
         // perform lpc on remaining samples
-        for(i = lpc.lpc_order + 1; i < s->avctx->frame_size; i++) {
+        for (i = lpc.lpc_order + 1; i < s->avctx->frame_size; i++) {
             int sum = 1 << (lpc.lpc_quant - 1), res_val, j;
             for (j = 0; j < lpc.lpc_order; j++) {
     int sign_modifier = 0, i, k;
     int32_t *samples = s->predictor_buf;
-    for(i=0;i < s->avctx->frame_size;) {
+    for (i = 0; i < s->avctx->frame_size;) {
         int x;
         k = av_log2((history >> 9) + 3);
                    - ((history * s->rc.history_mult) >> 9);
         sign_modifier = 0;
-        if(x > 0xFFFF)
+        if (x > 0xFFFF)
             history = 0xFFFF;
-        if((history < 128) && (i < s->avctx->frame_size)) {
+        if (history < 128 && i < s->avctx->frame_size) {
             unsigned int block_size = 0;
             k = 7 - av_log2(history) + ((history + 16) >> 6);
-            while((*samples == 0) && (i < s->avctx->frame_size)) {
+            while (*samples == 0 && i < s->avctx->frame_size) {
                 samples++;
                 i++;
                 block_size++;
 {
     int i, j;
-    if(s->avctx->channels == 2)
+    if (s->avctx->channels == 2)
         alac_stereo_decorrelation(s);
     put_bits(&s->pbctx, 8, s->interlacing_shift);
     put_bits(&s->pbctx, 8, s->interlacing_leftweight);
-    for(i=0;i<s->avctx->channels;i++) {
+    for (i = 0; i < s->avctx->channels; i++) {
         calc_predictor_params(s, i);
         put_bits(&s->pbctx, 3, s->rc.rice_modifier);
         put_bits(&s->pbctx, 5, s->lpc[i].lpc_order);
         // predictor coeff. table
-        for(j=0;j<s->lpc[i].lpc_order;j++) {
+        for (j = 0; j < s->lpc[i].lpc_order; j++) {
             put_sbits(&s->pbctx, 16, s->lpc[i].lpc_coeff[j]);
         }
     }
     // apply lpc and entropy coding to audio samples
-    for(i=0;i<s->avctx->channels;i++) {
+    for (i = 0; i < s->avctx->channels; i++) {
         alac_linear_predictor(s, i);
         alac_entropy_coder(s);
     }
     avctx->frame_size      = DEFAULT_FRAME_SIZE;
     avctx->bits_per_coded_sample = DEFAULT_SAMPLE_SIZE;
-    if(avctx->sample_fmt != AV_SAMPLE_FMT_S16) {
+    if (avctx->sample_fmt != AV_SAMPLE_FMT_S16) {
         av_log(avctx, AV_LOG_ERROR, "only pcm_s16 input samples are supported\n");
         return -1;
     }
     }
     // Set default compression level
-    if(avctx->compression_level == FF_COMPRESSION_DEFAULT)
+    if (avctx->compression_level == FF_COMPRESSION_DEFAULT)
         s->compression_level = 2;
     else
         s->compression_level = av_clip(avctx->compression_level, 0, 2);
     AV_WB8 (alac_extradata+17, avctx->bits_per_coded_sample);
     AV_WB8 (alac_extradata+21, avctx->channels);
     AV_WB32(alac_extradata+24, s->max_coded_frame_size);
-    AV_WB32(alac_extradata+28, avctx->sample_rate*avctx->channels*avctx->bits_per_coded_sample); // average bitrate
+    AV_WB32(alac_extradata+28,
+            avctx->sample_rate * avctx->channels * avctx->bits_per_coded_sample); // average bitrate
     AV_WB32(alac_extradata+32, avctx->sample_rate);
     // Set relevant extradata fields
-    if(s->compression_level > 0) {
+    if (s->compression_level > 0) {
         AV_WB8(alac_extradata+18, s->rc.history_mult);
         AV_WB8(alac_extradata+19, s->rc.initial_history);
         AV_WB8(alac_extradata+20, s->rc.k_modifier);
     }
     s->min_prediction_order = DEFAULT_MIN_PRED_ORDER;
-    if(avctx->min_prediction_order >= 0) {
+    if (avctx->min_prediction_order >= 0) {
-        if(avctx->min_prediction_order < MIN_LPC_ORDER ||
+        if (avctx->min_prediction_order < MIN_LPC_ORDER ||
            avctx->min_prediction_order > ALAC_MAX_LPC_ORDER) {
-            av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n", avctx->min_prediction_order);
+            av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
+                   avctx->min_prediction_order);
                 return -1;
         }
     }
     s->max_prediction_order = DEFAULT_MAX_PRED_ORDER;
-    if(avctx->max_prediction_order >= 0) {
+    if (avctx->max_prediction_order >= 0) {
-        if(avctx->max_prediction_order < MIN_LPC_ORDER ||
+        if (avctx->max_prediction_order < MIN_LPC_ORDER ||
-           avctx->max_prediction_order > ALAC_MAX_LPC_ORDER) {
+            avctx->max_prediction_order > ALAC_MAX_LPC_ORDER) {
-            av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n", avctx->max_prediction_order);
+            av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
+                   avctx->max_prediction_order);
                 return -1;
         }
         s->max_prediction_order = avctx->max_prediction_order;
     }
-    if(s->max_prediction_order < s->min_prediction_order) {
+    if (s->max_prediction_order < s->min_prediction_order) {
-        av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
+        av_log(avctx, AV_LOG_ERROR,
+               "invalid prediction orders: min=%d max=%d\n",
                s->min_prediction_order, s->max_prediction_order);
         return -1;
     }
     PutBitContext *pb = &s->pbctx;
     int i, out_bytes, verbatim_flag = 0;
-    if(avctx->frame_size > DEFAULT_FRAME_SIZE) {
+    if (avctx->frame_size > DEFAULT_FRAME_SIZE) {
         av_log(avctx, AV_LOG_ERROR, "input frame size exceeded\n");
         return -1;
     }
-    if(buf_size < 2*s->max_coded_frame_size) {
+    if (buf_size < 2 * s->max_coded_frame_size) {
         av_log(avctx, AV_LOG_ERROR, "buffer size is too small\n");
         return -1;
     }
 verbatim:
     init_put_bits(pb, frame, buf_size);
-    if((s->compression_level == 0) || verbatim_flag) {
+    if (s->compression_level == 0 || verbatim_flag) {
         // Verbatim mode
         const int16_t *samples = data;
         write_frame_header(s, 1);
-        for(i=0; i<avctx->frame_size*avctx->channels; i++) {
+        for (i = 0; i < avctx->frame_size * avctx->channels; i++) {
             put_sbits(pb, 16, *samples++);
         }
     } else {
     flush_put_bits(pb);
     out_bytes = put_bits_count(pb) >> 3;
-    if(out_bytes > s->max_coded_frame_size) {
+    if (out_bytes > s->max_coded_frame_size) {
         /* frame too large. use verbatim mode */
-        if(verbatim_flag || (s->compression_level == 0)) {
+        if (verbatim_flag || s->compression_level == 0) {
             /* still too large. must be an error. */
             av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");
             return -1;
     .encode         = alac_encode_frame,
     .close          = alac_encode_close,
     .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
-    .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE},
+    .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+                                                  AV_SAMPLE_FMT_NONE },
     .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
 };

libavcodec/alsdec.c+25−20

@@ -191,6 +191,7 @@ typedef struct { · 190 unmodified lines
191		191
192	typedef struct {	192	typedef struct {
193	AVCodecContext *avctx;	193	AVCodecContext *avctx;
		194	AVFrame frame;
194	ALSSpecificConfig sconf;	195	ALSSpecificConfig sconf;
195	GetBitContext gb;	196	GetBitContext gb;
196	DSPContext dsp;	197	DSPContext dsp;
@@ -290,7 +291,7 @@ static av_cold int read_specific_config(ALSDecContext *ctx) · 93 unmodified lines
290	init_get_bits(&gb, avctx->extradata, avctx->extradata_size * 8);	291	init_get_bits(&gb, avctx->extradata, avctx->extradata_size * 8);
291		292
292	config_offset = avpriv_mpeg4audio_get_config(&m4ac, avctx->extradata,	293	config_offset = avpriv_mpeg4audio_get_config(&m4ac, avctx->extradata,
293	avctx->extradata_size);	294	avctx->extradata_size * 8, 1);
294		295
295	if (config_offset < 0)	296	if (config_offset < 0)
296	return -1;	297	return -1;
@@ -1415,15 +1416,14 @@ static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame) · 1118 unmodified lines
1415		1416
1416	/** Decode an ALS frame.	1417	/** Decode an ALS frame.
1417	*/	1418	*/
1418	static int decode_frame(AVCodecContext *avctx,	1419	static int decode_frame(AVCodecContext avctx, void data, int *got_frame_ptr,
1419	void data, int data_size,
1420	AVPacket *avpkt)	1420	AVPacket *avpkt)
1421	{	1421	{
1422	ALSDecContext *ctx = avctx->priv_data;	1422	ALSDecContext *ctx = avctx->priv_data;
1423	ALSSpecificConfig *sconf = &ctx->sconf;	1423	ALSSpecificConfig *sconf = &ctx->sconf;
1424	const uint8_t *buffer = avpkt->data;	1424	const uint8_t *buffer = avpkt->data;
1425	int buffer_size = avpkt->size;	1425	int buffer_size = avpkt->size;
1426	int invalid_frame, size;	1426	int invalid_frame, ret;
1427	unsigned int c, sample, ra_frame, bytes_read, shift;	1427	unsigned int c, sample, ra_frame, bytes_read, shift;
1428		1428
1429	init_get_bits(&ctx->gb, buffer, buffer_size * 8);	1429	init_get_bits(&ctx->gb, buffer, buffer_size * 8);
@@ -1448,21 +1448,17 @@ static int decode_frame(AVCodecContext *avctx, · 18 unmodified lines
1448		1448
1449	ctx->frame_id++;	1449	ctx->frame_id++;
1450		1450
1451	// check for size of decoded data	1451	/* get output buffer */
1452	size = ctx->cur_frame_length * avctx->channels *	1452	ctx->frame.nb_samples = ctx->cur_frame_length;
1453	av_get_bytes_per_sample(avctx->sample_fmt);	1453	if ((ret = avctx->get_buffer(avctx, &ctx->frame)) < 0) {
1454		1454	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1455	if (size > *data_size) {	1455	return ret;
1456	av_log(avctx, AV_LOG_ERROR, "Decoded data exceeds buffer size.\n");
1457	return -1;
1458	}	1456	}
1459		1457
1460	*data_size = size;
1461
1462	// transform decoded frame into output format	1458	// transform decoded frame into output format
1463	#define INTERLEAVE_OUTPUT(bps) \	1459	#define INTERLEAVE_OUTPUT(bps) \
1464	{ \	1460	{ \
1465	int##bps##_t dest = (int##bps##_t) data; \	1461	int##bps##_t dest = (int##bps##_t)ctx->frame.data[0]; \
1466	shift = bps - ctx->avctx->bits_per_raw_sample; \	1462	shift = bps - ctx->avctx->bits_per_raw_sample; \
1467	for (sample = 0; sample < ctx->cur_frame_length; sample++) \	1463	for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1468	for (c = 0; c < avctx->channels; c++) \	1464	for (c = 0; c < avctx->channels; c++) \
@@ -1480,7 +1476,7 @@ static int decode_frame(AVCodecContext *avctx, · 11 unmodified lines
1480	int swap = HAVE_BIGENDIAN != sconf->msb_first;	1476	int swap = HAVE_BIGENDIAN != sconf->msb_first;
1481		1477
1482	if (ctx->avctx->bits_per_raw_sample == 24) {	1478	if (ctx->avctx->bits_per_raw_sample == 24) {
1483	int32_t *src = data;	1479	int32_t src = (int32_t )ctx->frame.data[0];
1484		1480
1485	for (sample = 0;	1481	for (sample = 0;
1486	sample < ctx->cur_frame_length * avctx->channels;	1482	sample < ctx->cur_frame_length * avctx->channels;
@@ -1501,22 +1497,25 @@ static int decode_frame(AVCodecContext *avctx, · 14 unmodified lines
1501		1497
1502	if (swap) {	1498	if (swap) {
1503	if (ctx->avctx->bits_per_raw_sample <= 16) {	1499	if (ctx->avctx->bits_per_raw_sample <= 16) {
1504	int16_t src = (int16_t) data;	1500	int16_t src = (int16_t) ctx->frame.data[0];
1505	int16_t dest = (int16_t) ctx->crc_buffer;	1501	int16_t dest = (int16_t) ctx->crc_buffer;
1506	for (sample = 0;	1502	for (sample = 0;
1507	sample < ctx->cur_frame_length * avctx->channels;	1503	sample < ctx->cur_frame_length * avctx->channels;
1508	sample++)	1504	sample++)
1509	*dest++ = av_bswap16(src[sample]);	1505	*dest++ = av_bswap16(src[sample]);
1510	} else {	1506	} else {
1511	ctx->dsp.bswap_buf((uint32_t*)ctx->crc_buffer, data,	1507	ctx->dsp.bswap_buf((uint32_t*)ctx->crc_buffer,
		1508	(uint32_t *)ctx->frame.data[0],
1512	ctx->cur_frame_length * avctx->channels);	1509	ctx->cur_frame_length * avctx->channels);
1513	}	1510	}
1514	crc_source = ctx->crc_buffer;	1511	crc_source = ctx->crc_buffer;
1515	} else {	1512	} else {
1516	crc_source = data;	1513	crc_source = ctx->frame.data[0];
1517	}	1514	}
1518		1515
1519	ctx->crc = av_crc(ctx->crc_table, ctx->crc, crc_source, size);	1516	ctx->crc = av_crc(ctx->crc_table, ctx->crc, crc_source,
		1517	ctx->cur_frame_length * avctx->channels *
		1518	av_get_bytes_per_sample(avctx->sample_fmt));
1520	}	1519	}
1521		1520
1522		1521
@@ -1527,6 +1526,9 @@ static int decode_frame(AVCodecContext *avctx, · 4 unmodified lines
1527	}	1526	}
1528	}	1527	}
1529		1528
		1529	*got_frame_ptr = 1;
		1530	(AVFrame )data = ctx->frame;
		1531
1530		1532
1531	bytes_read = invalid_frame ? buffer_size :	1533	bytes_read = invalid_frame ? buffer_size :
1532	(get_bits_count(&ctx->gb) + 7) >> 3;	1534	(get_bits_count(&ctx->gb) + 7) >> 3;
@@ -1724,6 +1726,9 @@ static av_cold int decode_init(AVCodecContext *avctx) · 191 unmodified lines
1724		1726
1725	dsputil_init(&ctx->dsp, avctx);	1727	dsputil_init(&ctx->dsp, avctx);
1726		1728
		1729	avcodec_get_frame_defaults(&ctx->frame);
		1730	avctx->coded_frame = &ctx->frame;
		1731
1727	return 0;	1732	return 0;
1728	}	1733	}
1729		1734
@@ -1747,7 +1752,7 @@ AVCodec ff_als_decoder = { · 17 unmodified lines
1747	.close = decode_end,	1752	.close = decode_end,
1748	.decode = decode_frame,	1753	.decode = decode_frame,
1749	.flush = flush,	1754	.flush = flush,
1750	.capabilities = CODEC_CAP_SUBFRAMES,	1755	.capabilities = CODEC_CAP_SUBFRAMES \| CODEC_CAP_DR1,
1751	.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),	1756	.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),
1752	};	1757	};
1753		1758

libavcodec/amrnbdec.c+19−6

 #define AMR_AGC_ALPHA      0.9
 typedef struct AMRContext {
+    AVFrame                         avframe; ///< AVFrame for decoded samples
     AMRNBFrame                        frame; ///< decoded AMR parameters (lsf coefficients, codebook indexes, etc)
     uint8_t             bad_frame_indicator; ///< bad frame ? 1 : 0
     enum Mode                cur_frame_mode;
     for (i = 0; i < 4; i++)
         p->prediction_error[i] = MIN_ENERGY;
+    avcodec_get_frame_defaults(&p->avframe);
+    avctx->coded_frame = &p->avframe;
     return 0;
 }
 /// @}
-static int amrnb_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
+static int amrnb_decode_frame(AVCodecContext *avctx, void *data,
-                              AVPacket *avpkt)
+                              int *got_frame_ptr, AVPacket *avpkt)
 {
     AMRContext *p = avctx->priv_data;        // pointer to private data
     const uint8_t *buf = avpkt->data;
     int buf_size       = avpkt->size;
-    float *buf_out = data;                   // pointer to the output data buffer
+    float *buf_out;                          // pointer to the output data buffer
-    int i, subframe;
+    int i, subframe, ret;
     float fixed_gain_factor;
     AMRFixed fixed_sparse = {0};             // fixed vector up to anti-sparseness processing
     float spare_vector[AMR_SUBFRAME_SIZE];   // extra stack space to hold result from anti-sparseness processing
     float synth_fixed_gain;                  // the fixed gain that synthesis should use
     const float *synth_fixed_vector;         // pointer to the fixed vector that synthesis should use
+    /* get output buffer */
+    p->avframe.nb_samples = AMR_BLOCK_SIZE;
+    if ((ret = avctx->get_buffer(avctx, &p->avframe)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        return ret;
+    }
+    buf_out = (float *)p->avframe.data[0];
     p->cur_frame_mode = unpack_bitstream(p, buf, buf_size);
     if (p->cur_frame_mode == MODE_DTX) {
         av_log_missing_feature(avctx, "dtx mode", 0);
     ff_weighted_vector_sumf(p->lsf_avg, p->lsf_avg, p->lsf_q[3],
                             0.84, 0.16, LP_FILTER_ORDER);
-    /* report how many samples we got */
+    *got_frame_ptr   = 1;
-    *data_size = AMR_BLOCK_SIZE * sizeof(float);
+    *(AVFrame *)data = p->avframe;
     /* return the amount of bytes consumed if everything was OK */
     return frame_sizes_nb[p->cur_frame_mode] + 1; // +7 for rounding and +8 for TOC
     .priv_data_size = sizeof(AMRContext),
     .init           = amrnb_decode_init,
     .decode         = amrnb_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name      = NULL_IF_CONFIG_SMALL("Adaptive Multi-Rate NarrowBand"),
     .sample_fmts    = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE},
 };

libavcodec/amrwbdec.c+20−7

 #include "amrwbdata.h"
 typedef struct {
+    AVFrame                              avframe; ///< AVFrame for decoded samples
     AMRWBFrame                             frame; ///< AMRWB parameters decoded from bitstream
     enum Mode                        fr_cur_mode; ///< mode index of current frame
     uint8_t                           fr_quality; ///< frame quality index (FQI)
     for (i = 0; i < 4; i++)
         ctx->prediction_error[i] = MIN_ENERGY;
+    avcodec_get_frame_defaults(&ctx->avframe);
+    avctx->coded_frame = &ctx->avframe;
     return 0;
 }
             LP_ORDER_16k * sizeof(float));
 }
-static int amrwb_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
+static int amrwb_decode_frame(AVCodecContext *avctx, void *data,
-                              AVPacket *avpkt)
+                              int *got_frame_ptr, AVPacket *avpkt)
 {
     AMRWBContext *ctx  = avctx->priv_data;
     AMRWBFrame   *cf   = &ctx->frame;
     const uint8_t *buf = avpkt->data;
     int buf_size       = avpkt->size;
     int expected_fr_size, header_size;
-    float *buf_out = data;
+    float *buf_out;
     float spare_vector[AMRWB_SFR_SIZE];      // extra stack space to hold result from anti-sparseness processing
     float fixed_gain_factor;                 // fixed gain correction factor (gamma)
     float *synth_fixed_vector;               // pointer to the fixed vector that synthesis should use
     float hb_exc[AMRWB_SFR_SIZE_16k];        // excitation for the high frequency band
     float hb_samples[AMRWB_SFR_SIZE_16k];    // filtered high-band samples from synthesis
     float hb_gain;
-    int sub, i;
+    int sub, i, ret;
+    /* get output buffer */
+    ctx->avframe.nb_samples = 4 * AMRWB_SFR_SIZE_16k;
+    if ((ret = avctx->get_buffer(avctx, &ctx->avframe)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        return ret;
+    }
+    buf_out = (float *)ctx->avframe.data[0];
     header_size      = decode_mime_header(ctx, buf);
     expected_fr_size = ((cf_sizes_wb[ctx->fr_cur_mode] + 7) >> 3) + 1;
     if (buf_size < expected_fr_size) {
         av_log(avctx, AV_LOG_ERROR,
             "Frame too small (%d bytes). Truncated file?\n", buf_size);
-        *data_size = 0;
+        *got_frame_ptr = 0;
         return buf_size;
     }
     memcpy(ctx->isp_sub4_past, ctx->isp[3], LP_ORDER * sizeof(ctx->isp[3][0]));
     memcpy(ctx->isf_past_final, ctx->isf_cur, LP_ORDER * sizeof(float));
-    /* report how many samples we got */
+    *got_frame_ptr   = 1;
-    *data_size = 4 * AMRWB_SFR_SIZE_16k * sizeof(float);
+    *(AVFrame *)data = ctx->avframe;
     return expected_fr_size;
 }
     .priv_data_size = sizeof(AMRWBContext),
     .init           = amrwb_decode_init,
     .decode         = amrwb_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name      = NULL_IF_CONFIG_SMALL("Adaptive Multi-Rate WideBand"),
     .sample_fmts    = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE},
 };

libavcodec/apedec.c+22−15

 /** Decoder context */
 typedef struct APEContext {
     AVCodecContext *avctx;
+    AVFrame frame;
     DSPContext dsp;
     int channels;
     int samples;                             ///< samples left to decode in current frame
     dsputil_init(&s->dsp, avctx);
     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
     avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
+    avcodec_get_frame_defaults(&s->frame);
+    avctx->coded_frame = &s->frame;
     return 0;
 filter_alloc_fail:
     ape_decode_close(avctx);
     }
 }
-static int ape_decode_frame(AVCodecContext *avctx,
+static int ape_decode_frame(AVCodecContext *avctx, void *data,
-                            void *data, int *data_size,
+                            int *got_frame_ptr, AVPacket *avpkt)
-                            AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     APEContext *s = avctx->priv_data;
-    int16_t *samples = data;
+    int16_t *samples;
-    int i;
+    int i, ret;
-    int blockstodecode, out_size;
+    int blockstodecode;
     int bytes_used = 0;
     /* this should never be negative, but bad things will happen if it is, so
         void *tmp_data;
         if (!buf_size) {
-            *data_size = 0;
+            *got_frame_ptr = 0;
             return 0;
         }
         if (buf_size < 8) {
     }
     if (!s->data) {
-        *data_size = 0;
+        *got_frame_ptr = 0;
         return buf_size;
     }
     blockstodecode = FFMIN(BLOCKS_PER_LOOP, s->samples);
-    out_size = blockstodecode * avctx->channels *
+    /* get output buffer */
-               av_get_bytes_per_sample(avctx->sample_fmt);
+    s->frame.nb_samples = blockstodecode;
-    if (*data_size < out_size) {
+    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small.\n");
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-        return AVERROR(EINVAL);
+        return ret;
     }
+    samples = (int16_t *)s->frame.data[0];
     s->error=0;
     s->samples -= blockstodecode;
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = s->frame;
     return bytes_used;
 }
     .init           = ape_decode_init,
     .close          = ape_decode_close,
     .decode         = ape_decode_frame,
-    .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DELAY,
+    .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DELAY | CODEC_CAP_DR1,
     .flush = ape_flush,
     .long_name = NULL_IF_CONFIG_SMALL("Monkey's Audio"),
 };

libavcodec/arm/h264dsp_neon.S+314−353

@@ -19,55 +19,16 @@ · 18 unmodified lines
19	*/	19	*/
20		20
21	#include "asm.S"	21	#include "asm.S"
22		22	#include "neon.S"
23	.macro transpose_8x8 r0 r1 r2 r3 r4 r5 r6 r7
24	vtrn.32 \r0, \r4
25	vtrn.32 \r1, \r5
26	vtrn.32 \r2, \r6
27	vtrn.32 \r3, \r7
28	vtrn.16 \r0, \r2
29	vtrn.16 \r1, \r3
30	vtrn.16 \r4, \r6
31	vtrn.16 \r5, \r7
32	vtrn.8 \r0, \r1
33	vtrn.8 \r2, \r3
34	vtrn.8 \r4, \r5
35	vtrn.8 \r6, \r7
36	.endm
37
38	.macro transpose_4x4 r0 r1 r2 r3
39	vtrn.16 \r0, \r2
40	vtrn.16 \r1, \r3
41	vtrn.8 \r0, \r1
42	vtrn.8 \r2, \r3
43	.endm
44
45	.macro swap4 r0 r1 r2 r3 r4 r5 r6 r7
46	vswp \r0, \r4
47	vswp \r1, \r5
48	vswp \r2, \r6
49	vswp \r3, \r7
50	.endm
51
52	.macro transpose16_4x4 r0 r1 r2 r3 r4 r5 r6 r7
53	vtrn.32 \r0, \r2
54	vtrn.32 \r1, \r3
55	vtrn.32 \r4, \r6
56	vtrn.32 \r5, \r7
57	vtrn.16 \r0, \r1
58	vtrn.16 \r2, \r3
59	vtrn.16 \r4, \r5
60	vtrn.16 \r6, \r7
61	.endm
62		23
63	/* chroma_mc8(uint8_t dst, uint8_t src, int stride, int h, int x, int y) */	24	/* chroma_mc8(uint8_t dst, uint8_t src, int stride, int h, int x, int y) */
64	.macro h264_chroma_mc8 type	25	.macro h264_chroma_mc8 type
65	function ff_\type\()_h264_chroma_mc8_neon, export=1	26	function ff_\type\()_h264_chroma_mc8_neon, export=1
66	push {r4-r7, lr}	27	push {r4-r7, lr}
67	ldrd r4, [sp, #20]	28	ldrd r4, [sp, #20]
68	.ifc \type,avg	29	.ifc \type,avg
69	mov lr, r0	30	mov lr, r0
70	.endif	31	.endif
71	pld [r1]	32	pld [r1]
72	pld [r1, r2]	33	pld [r1, r2]
73		34
@@ -75,7 +36,7 @@ A muls r7, r4, r5 · 1 unmodified line
75	T mul r7, r4, r5	36	T mul r7, r4, r5
76	T cmp r7, #0	37	T cmp r7, #0
77	rsb r6, r7, r5, lsl #3	38	rsb r6, r7, r5, lsl #3
78	rsb ip, r7, r4, lsl #3	39	rsb r12, r7, r4, lsl #3
79	sub r4, r7, r4, lsl #3	40	sub r4, r7, r4, lsl #3
80	sub r4, r4, r5, lsl #3	41	sub r4, r4, r5, lsl #3
81	add r4, r4, #64	42	add r4, r4, #64
@@ -86,10 +47,10 @@ T cmp r7, #0 · 4 unmodified lines
86		47
87	vdup.8 d0, r4	48	vdup.8 d0, r4
88	lsl r4, r2, #1	49	lsl r4, r2, #1
89	vdup.8 d1, ip	50	vdup.8 d1, r12
90	vld1.64 {d4, d5}, [r1], r4	51	vld1.8 {d4, d5}, [r1], r4
91	vdup.8 d2, r6	52	vdup.8 d2, r6
92	vld1.64 {d6, d7}, [r5], r4	53	vld1.8 {d6, d7}, [r5], r4
93	vdup.8 d3, r7	54	vdup.8 d3, r7
94		55
95	vext.8 d5, d4, d5, #1	56	vext.8 d5, d4, d5, #1
@@ -98,7 +59,7 @@ T cmp r7, #0 · 2 unmodified lines
98	1: pld [r5]	59	1: pld [r5]
99	vmull.u8 q8, d4, d0	60	vmull.u8 q8, d4, d0
100	vmlal.u8 q8, d5, d1	61	vmlal.u8 q8, d5, d1
101	vld1.64 {d4, d5}, [r1], r4	62	vld1.8 {d4, d5}, [r1], r4
102	vmlal.u8 q8, d6, d2	63	vmlal.u8 q8, d6, d2
103	vext.8 d5, d4, d5, #1	64	vext.8 d5, d4, d5, #1
104	vmlal.u8 q8, d7, d3	65	vmlal.u8 q8, d7, d3
@@ -108,57 +69,57 @@ T cmp r7, #0 · 3 unmodified lines
108	vmlal.u8 q9, d4, d2	69	vmlal.u8 q9, d4, d2
109	vmlal.u8 q9, d5, d3	70	vmlal.u8 q9, d5, d3
110	vrshrn.u16 d16, q8, #6	71	vrshrn.u16 d16, q8, #6
111	vld1.64 {d6, d7}, [r5], r4	72	vld1.8 {d6, d7}, [r5], r4
112	pld [r1]	73	pld [r1]
113	vrshrn.u16 d17, q9, #6	74	vrshrn.u16 d17, q9, #6
114	.ifc \type,avg	75	.ifc \type,avg
115	vld1.64 {d20}, [lr,:64], r2	76	vld1.8 {d20}, [lr,:64], r2
116	vld1.64 {d21}, [lr,:64], r2	77	vld1.8 {d21}, [lr,:64], r2
117	vrhadd.u8 q8, q8, q10	78	vrhadd.u8 q8, q8, q10
118	.endif	79	.endif
119	vext.8 d7, d6, d7, #1	80	vext.8 d7, d6, d7, #1
120	vst1.64 {d16}, [r0,:64], r2	81	vst1.8 {d16}, [r0,:64], r2
121	vst1.64 {d17}, [r0,:64], r2	82	vst1.8 {d17}, [r0,:64], r2
122	bgt 1b	83	bgt 1b
123		84
124	pop {r4-r7, pc}	85	pop {r4-r7, pc}
125		86
126	2: tst r6, r6	87	2: tst r6, r6
127	add ip, ip, r6	88	add r12, r12, r6
128	vdup.8 d0, r4	89	vdup.8 d0, r4
129	vdup.8 d1, ip	90	vdup.8 d1, r12
130		91
131	beq 4f	92	beq 4f
132		93
133	add r5, r1, r2	94	add r5, r1, r2
134	lsl r4, r2, #1	95	lsl r4, r2, #1
135	vld1.64 {d4}, [r1], r4	96	vld1.8 {d4}, [r1], r4
136	vld1.64 {d6}, [r5], r4	97	vld1.8 {d6}, [r5], r4
137		98
138	3: pld [r5]	99	3: pld [r5]
139	vmull.u8 q8, d4, d0	100	vmull.u8 q8, d4, d0
140	vmlal.u8 q8, d6, d1	101	vmlal.u8 q8, d6, d1
141	vld1.64 {d4}, [r1], r4	102	vld1.8 {d4}, [r1], r4
142	vmull.u8 q9, d6, d0	103	vmull.u8 q9, d6, d0
143	vmlal.u8 q9, d4, d1	104	vmlal.u8 q9, d4, d1
144	vld1.64 {d6}, [r5], r4	105	vld1.8 {d6}, [r5], r4
145	vrshrn.u16 d16, q8, #6	106	vrshrn.u16 d16, q8, #6
146	vrshrn.u16 d17, q9, #6	107	vrshrn.u16 d17, q9, #6
147	.ifc \type,avg	108	.ifc \type,avg
148	vld1.64 {d20}, [lr,:64], r2	109	vld1.8 {d20}, [lr,:64], r2
149	vld1.64 {d21}, [lr,:64], r2	110	vld1.8 {d21}, [lr,:64], r2
150	vrhadd.u8 q8, q8, q10	111	vrhadd.u8 q8, q8, q10
151	.endif	112	.endif
152	subs r3, r3, #2	113	subs r3, r3, #2
153	pld [r1]	114	pld [r1]
154	vst1.64 {d16}, [r0,:64], r2	115	vst1.8 {d16}, [r0,:64], r2
155	vst1.64 {d17}, [r0,:64], r2	116	vst1.8 {d17}, [r0,:64], r2
156	bgt 3b	117	bgt 3b
157		118
158	pop {r4-r7, pc}	119	pop {r4-r7, pc}
159		120
160	4: vld1.64 {d4, d5}, [r1], r2	121	4: vld1.8 {d4, d5}, [r1], r2
161	vld1.64 {d6, d7}, [r1], r2	122	vld1.8 {d6, d7}, [r1], r2
162	vext.8 d5, d4, d5, #1	123	vext.8 d5, d4, d5, #1
163	vext.8 d7, d6, d7, #1	124	vext.8 d7, d6, d7, #1
164		125
@@ -166,36 +127,36 @@ T cmp r7, #0 · 1 unmodified line
166	subs r3, r3, #2	127	subs r3, r3, #2
167	vmull.u8 q8, d4, d0	128	vmull.u8 q8, d4, d0
168	vmlal.u8 q8, d5, d1	129	vmlal.u8 q8, d5, d1
169	vld1.64 {d4, d5}, [r1], r2	130	vld1.8 {d4, d5}, [r1], r2
170	vmull.u8 q9, d6, d0	131	vmull.u8 q9, d6, d0
171	vmlal.u8 q9, d7, d1	132	vmlal.u8 q9, d7, d1
172	pld [r1]	133	pld [r1]
173	vext.8 d5, d4, d5, #1	134	vext.8 d5, d4, d5, #1
174	vrshrn.u16 d16, q8, #6	135	vrshrn.u16 d16, q8, #6
175	vrshrn.u16 d17, q9, #6	136	vrshrn.u16 d17, q9, #6
176	.ifc \type,avg	137	.ifc \type,avg
177	vld1.64 {d20}, [lr,:64], r2	138	vld1.8 {d20}, [lr,:64], r2
178	vld1.64 {d21}, [lr,:64], r2	139	vld1.8 {d21}, [lr,:64], r2
179	vrhadd.u8 q8, q8, q10	140	vrhadd.u8 q8, q8, q10
180	.endif	141	.endif
181	vld1.64 {d6, d7}, [r1], r2	142	vld1.8 {d6, d7}, [r1], r2
182	vext.8 d7, d6, d7, #1	143	vext.8 d7, d6, d7, #1
183	vst1.64 {d16}, [r0,:64], r2	144	vst1.8 {d16}, [r0,:64], r2
184	vst1.64 {d17}, [r0,:64], r2	145	vst1.8 {d17}, [r0,:64], r2
185	bgt 5b	146	bgt 5b
186		147
187	pop {r4-r7, pc}	148	pop {r4-r7, pc}
188	endfunc	149	endfunc
189	.endm	150	.endm
190		151
191	/* chroma_mc4(uint8_t dst, uint8_t src, int stride, int h, int x, int y) */	152	/* chroma_mc4(uint8_t dst, uint8_t src, int stride, int h, int x, int y) */
192	.macro h264_chroma_mc4 type	153	.macro h264_chroma_mc4 type
193	function ff_\type\()_h264_chroma_mc4_neon, export=1	154	function ff_\type\()_h264_chroma_mc4_neon, export=1
194	push {r4-r7, lr}	155	push {r4-r7, lr}
195	ldrd r4, [sp, #20]	156	ldrd r4, [sp, #20]
196	.ifc \type,avg	157	.ifc \type,avg
197	mov lr, r0	158	mov lr, r0
198	.endif	159	.endif
199	pld [r1]	160	pld [r1]
200	pld [r1, r2]	161	pld [r1, r2]
201		162
@@ -203,7 +164,7 @@ A muls r7, r4, r5 · 1 unmodified line
203	T mul r7, r4, r5	164	T mul r7, r4, r5
204	T cmp r7, #0	165	T cmp r7, #0
205	rsb r6, r7, r5, lsl #3	166	rsb r6, r7, r5, lsl #3
206	rsb ip, r7, r4, lsl #3	167	rsb r12, r7, r4, lsl #3
207	sub r4, r7, r4, lsl #3	168	sub r4, r7, r4, lsl #3
208	sub r4, r4, r5, lsl #3	169	sub r4, r4, r5, lsl #3
209	add r4, r4, #64	170	add r4, r4, #64
@@ -214,10 +175,10 @@ T cmp r7, #0 · 4 unmodified lines
214		175
215	vdup.8 d0, r4	176	vdup.8 d0, r4
216	lsl r4, r2, #1	177	lsl r4, r2, #1
217	vdup.8 d1, ip	178	vdup.8 d1, r12
218	vld1.64 {d4}, [r1], r4	179	vld1.8 {d4}, [r1], r4
219	vdup.8 d2, r6	180	vdup.8 d2, r6
220	vld1.64 {d6}, [r5], r4	181	vld1.8 {d6}, [r5], r4
221	vdup.8 d3, r7	182	vdup.8 d3, r7
222		183
223	vext.8 d5, d4, d5, #1	184	vext.8 d5, d4, d5, #1
@@ -231,22 +192,22 @@ T cmp r7, #0 · 7 unmodified lines
231	1: pld [r5]	192	1: pld [r5]
232	vmull.u8 q8, d4, d0	193	vmull.u8 q8, d4, d0
233	vmlal.u8 q8, d6, d2	194	vmlal.u8 q8, d6, d2
234	vld1.64 {d4}, [r1], r4	195	vld1.8 {d4}, [r1], r4
235	vext.8 d5, d4, d5, #1	196	vext.8 d5, d4, d5, #1
236	vtrn.32 d4, d5	197	vtrn.32 d4, d5
237	vmull.u8 q9, d6, d0	198	vmull.u8 q9, d6, d0
238	vmlal.u8 q9, d4, d2	199	vmlal.u8 q9, d4, d2
239	vld1.64 {d6}, [r5], r4	200	vld1.8 {d6}, [r5], r4
240	vadd.i16 d16, d16, d17	201	vadd.i16 d16, d16, d17
241	vadd.i16 d17, d18, d19	202	vadd.i16 d17, d18, d19
242	vrshrn.u16 d16, q8, #6	203	vrshrn.u16 d16, q8, #6
243	subs r3, r3, #2	204	subs r3, r3, #2
244	pld [r1]	205	pld [r1]
245	.ifc \type,avg	206	.ifc \type,avg
246	vld1.32 {d20[0]}, [lr,:32], r2	207	vld1.32 {d20[0]}, [lr,:32], r2
247	vld1.32 {d20[1]}, [lr,:32], r2	208	vld1.32 {d20[1]}, [lr,:32], r2
248	vrhadd.u8 d16, d16, d20	209	vrhadd.u8 d16, d16, d20
249	.endif	210	.endif
250	vext.8 d7, d6, d7, #1	211	vext.8 d7, d6, d7, #1
251	vtrn.32 d6, d7	212	vtrn.32 d6, d7
252	vst1.32 {d16[0]}, [r0,:32], r2	213	vst1.32 {d16[0]}, [r0,:32], r2
@@ -256,9 +217,9 @@ T cmp r7, #0 · 3 unmodified lines
256	pop {r4-r7, pc}	217	pop {r4-r7, pc}
257		218
258	2: tst r6, r6	219	2: tst r6, r6
259	add ip, ip, r6	220	add r12, r12, r6
260	vdup.8 d0, r4	221	vdup.8 d0, r4
261	vdup.8 d1, ip	222	vdup.8 d1, r12
262	vtrn.32 d0, d1	223	vtrn.32 d0, d1
263		224
264	beq 4f	225	beq 4f
@@ -277,11 +238,11 @@ T cmp r7, #0 · 12 unmodified lines
277	vadd.i16 d16, d16, d17	238	vadd.i16 d16, d16, d17
278	vadd.i16 d17, d18, d19	239	vadd.i16 d17, d18, d19
279	vrshrn.u16 d16, q8, #6	240	vrshrn.u16 d16, q8, #6
280	.ifc \type,avg	241	.ifc \type,avg
281	vld1.32 {d20[0]}, [lr,:32], r2	242	vld1.32 {d20[0]}, [lr,:32], r2
282	vld1.32 {d20[1]}, [lr,:32], r2	243	vld1.32 {d20[1]}, [lr,:32], r2
283	vrhadd.u8 d16, d16, d20	244	vrhadd.u8 d16, d16, d20
284	.endif	245	.endif
285	subs r3, r3, #2	246	subs r3, r3, #2
286	pld [r1]	247	pld [r1]
287	vst1.32 {d16[0]}, [r0,:32], r2	248	vst1.32 {d16[0]}, [r0,:32], r2
@@ -290,8 +251,8 @@ T cmp r7, #0 · 2 unmodified lines
290		251
291	pop {r4-r7, pc}	252	pop {r4-r7, pc}
292		253
293	4: vld1.64 {d4}, [r1], r2	254	4: vld1.8 {d4}, [r1], r2
294	vld1.64 {d6}, [r1], r2	255	vld1.8 {d6}, [r1], r2
295	vext.8 d5, d4, d5, #1	256	vext.8 d5, d4, d5, #1
296	vext.8 d7, d6, d7, #1	257	vext.8 d7, d6, d7, #1
297	vtrn.32 d4, d5	258	vtrn.32 d4, d5
@@ -300,19 +261,19 @@ T cmp r7, #0 · 2 unmodified lines
300	5: vmull.u8 q8, d4, d0	261	5: vmull.u8 q8, d4, d0
301	vmull.u8 q9, d6, d0	262	vmull.u8 q9, d6, d0
302	subs r3, r3, #2	263	subs r3, r3, #2
303	vld1.64 {d4}, [r1], r2	264	vld1.8 {d4}, [r1], r2
304	vext.8 d5, d4, d5, #1	265	vext.8 d5, d4, d5, #1
305	vtrn.32 d4, d5	266	vtrn.32 d4, d5
306	vadd.i16 d16, d16, d17	267	vadd.i16 d16, d16, d17
307	vadd.i16 d17, d18, d19	268	vadd.i16 d17, d18, d19
308	pld [r1]	269	pld [r1]
309	vrshrn.u16 d16, q8, #6	270	vrshrn.u16 d16, q8, #6
310	.ifc \type,avg	271	.ifc \type,avg
311	vld1.32 {d20[0]}, [lr,:32], r2	272	vld1.32 {d20[0]}, [lr,:32], r2
312	vld1.32 {d20[1]}, [lr,:32], r2	273	vld1.32 {d20[1]}, [lr,:32], r2
313	vrhadd.u8 d16, d16, d20	274	vrhadd.u8 d16, d16, d20
314	.endif	275	.endif
315	vld1.64 {d6}, [r1], r2	276	vld1.8 {d6}, [r1], r2
316	vext.8 d7, d6, d7, #1	277	vext.8 d7, d6, d7, #1
317	vtrn.32 d6, d7	278	vtrn.32 d6, d7
318	pld [r1]	279	pld [r1]
@@ -322,9 +283,9 @@ T cmp r7, #0 · 3 unmodified lines
322		283
323	pop {r4-r7, pc}	284	pop {r4-r7, pc}
324	endfunc	285	endfunc
325	.endm	286	.endm
326		287
327	.macro h264_chroma_mc2 type	288	.macro h264_chroma_mc2 type
328	function ff_\type\()_h264_chroma_mc2_neon, export=1	289	function ff_\type\()_h264_chroma_mc2_neon, export=1
329	push {r4-r6, lr}	290	push {r4-r6, lr}
330	ldr r4, [sp, #16]	291	ldr r4, [sp, #16]
@@ -354,29 +315,29 @@ function ff_\type\()_h264_chroma_mc2_neon, export=1 · 23 unmodified lines
354	vtrn.16 q2, q3	315	vtrn.16 q2, q3
355	vmull.u8 q8, d4, d0	316	vmull.u8 q8, d4, d0
356	vmlal.u8 q8, d5, d1	317	vmlal.u8 q8, d5, d1
357	.ifc \type,avg	318	.ifc \type,avg
358	vld1.16 {d18[0]}, [r0,:16], r2	319	vld1.16 {d18[0]}, [r0,:16], r2
359	vld1.16 {d18[1]}, [r0,:16]	320	vld1.16 {d18[1]}, [r0,:16]
360	sub r0, r0, r2	321	sub r0, r0, r2
361	.endif	322	.endif
362	vtrn.32 d16, d17	323	vtrn.32 d16, d17
363	vadd.i16 d16, d16, d17	324	vadd.i16 d16, d16, d17
364	vrshrn.u16 d16, q8, #6	325	vrshrn.u16 d16, q8, #6
365	.ifc \type,avg	326	.ifc \type,avg
366	vrhadd.u8 d16, d16, d18	327	vrhadd.u8 d16, d16, d18
367	.endif	328	.endif
368	vst1.16 {d16[0]}, [r0,:16], r2	329	vst1.16 {d16[0]}, [r0,:16], r2
369	vst1.16 {d16[1]}, [r0,:16], r2	330	vst1.16 {d16[1]}, [r0,:16], r2
370	subs r3, r3, #2	331	subs r3, r3, #2
371	bgt 1b	332	bgt 1b
372	pop {r4-r6, pc}	333	pop {r4-r6, pc}
373	2:	334	2:
374	.ifc \type,put	335	.ifc \type,put
375	ldrh_post r5, r1, r2	336	ldrh_post r5, r1, r2
376	strh_post r5, r0, r2	337	strh_post r5, r0, r2
377	ldrh_post r6, r1, r2	338	ldrh_post r6, r1, r2
378	strh_post r6, r0, r2	339	strh_post r6, r0, r2
379	.else	340	.else
380	vld1.16 {d16[0]}, [r1], r2	341	vld1.16 {d16[0]}, [r1], r2
381	vld1.16 {d16[1]}, [r1], r2	342	vld1.16 {d16[1]}, [r1], r2
382	vld1.16 {d18[0]}, [r0,:16], r2	343	vld1.16 {d18[0]}, [r0,:16], r2
@@ -385,7 +346,7 @@ function ff_\type\()_h264_chroma_mc2_neon, export=1 · 2 unmodified lines
385	vrhadd.u8 d16, d16, d18	346	vrhadd.u8 d16, d16, d18
386	vst1.16 {d16[0]}, [r0,:16], r2	347	vst1.16 {d16[0]}, [r0,:16], r2
387	vst1.16 {d16[1]}, [r0,:16], r2	348	vst1.16 {d16[1]}, [r0,:16], r2
388	.endif	349	.endif
389	subs r3, r3, #2	350	subs r3, r3, #2
390	bgt 2b	351	bgt 2b
391	pop {r4-r6, pc}	352	pop {r4-r6, pc}
@@ -401,22 +362,22 @@ endfunc · 9 unmodified lines
401		362
402	/* H.264 loop filter */	363	/* H.264 loop filter */
403		364
404	.macro h264_loop_filter_start	365	.macro h264_loop_filter_start
405	ldr ip, [sp]	366	ldr r12, [sp]
406	tst r2, r2	367	tst r2, r2
407	ldr ip, [ip]	368	ldr r12, [r12]
408	it ne	369	it ne
409	tstne r3, r3	370	tstne r3, r3
410	vmov.32 d24[0], ip	371	vmov.32 d24[0], r12
411	and ip, ip, ip, lsl #16	372	and r12, r12, r12, lsl #16
412	it eq	373	it eq
413	bxeq lr	374	bxeq lr
414	ands ip, ip, ip, lsl #8	375	ands r12, r12, r12, lsl #8
415	it lt	376	it lt
416	bxlt lr	377	bxlt lr
417	.endm	378	.endm
418		379
419	.macro h264_loop_filter_luma	380	.macro h264_loop_filter_luma
420	vdup.8 q11, r2 @ alpha	381	vdup.8 q11, r2 @ alpha
421	vmovl.u8 q12, d24	382	vmovl.u8 q12, d24
422	vabd.u8 q6, q8, q0 @ abs(p0 - q0)	383	vabd.u8 q6, q8, q0 @ abs(p0 - q0)
@@ -482,29 +443,29 @@ endfunc · 59 unmodified lines
482	vqmovun.s16 d17, q6	443	vqmovun.s16 d17, q6
483	vqmovun.s16 d0, q11	444	vqmovun.s16 d0, q11
484	vqmovun.s16 d1, q12	445	vqmovun.s16 d1, q12
485	.endm	446	.endm
486		447
487	function ff_h264_v_loop_filter_luma_neon, export=1	448	function ff_h264_v_loop_filter_luma_neon, export=1
488	h264_loop_filter_start	449	h264_loop_filter_start
489		450
490	vld1.64 {d0, d1}, [r0,:128], r1	451	vld1.8 {d0, d1}, [r0,:128], r1
491	vld1.64 {d2, d3}, [r0,:128], r1	452	vld1.8 {d2, d3}, [r0,:128], r1
492	vld1.64 {d4, d5}, [r0,:128], r1	453	vld1.8 {d4, d5}, [r0,:128], r1
493	sub r0, r0, r1, lsl #2	454	sub r0, r0, r1, lsl #2
494	sub r0, r0, r1, lsl #1	455	sub r0, r0, r1, lsl #1
495	vld1.64 {d20,d21}, [r0,:128], r1	456	vld1.8 {d20,d21}, [r0,:128], r1
496	vld1.64 {d18,d19}, [r0,:128], r1	457	vld1.8 {d18,d19}, [r0,:128], r1
497	vld1.64 {d16,d17}, [r0,:128], r1	458	vld1.8 {d16,d17}, [r0,:128], r1
498		459
499	vpush {d8-d15}	460	vpush {d8-d15}
500		461
501	h264_loop_filter_luma	462	h264_loop_filter_luma
502		463
503	sub r0, r0, r1, lsl #1	464	sub r0, r0, r1, lsl #1
504	vst1.64 {d8, d9}, [r0,:128], r1	465	vst1.8 {d8, d9}, [r0,:128], r1
505	vst1.64 {d16,d17}, [r0,:128], r1	466	vst1.8 {d16,d17}, [r0,:128], r1
506	vst1.64 {d0, d1}, [r0,:128], r1	467	vst1.8 {d0, d1}, [r0,:128], r1
507	vst1.64 {d10,d11}, [r0,:128]	468	vst1.8 {d10,d11}, [r0,:128]
508		469
509	vpop {d8-d15}	470	vpop {d8-d15}
510	bx lr	471	bx lr
@@ -514,22 +475,22 @@ function ff_h264_h_loop_filter_luma_neon, export=1 · 3 unmodified lines
514	h264_loop_filter_start	475	h264_loop_filter_start
515		476
516	sub r0, r0, #4	477	sub r0, r0, #4
517	vld1.64 {d6}, [r0], r1	478	vld1.8 {d6}, [r0], r1
518	vld1.64 {d20}, [r0], r1	479	vld1.8 {d20}, [r0], r1
519	vld1.64 {d18}, [r0], r1	480	vld1.8 {d18}, [r0], r1
520	vld1.64 {d16}, [r0], r1	481	vld1.8 {d16}, [r0], r1
521	vld1.64 {d0}, [r0], r1	482	vld1.8 {d0}, [r0], r1
522	vld1.64 {d2}, [r0], r1	483	vld1.8 {d2}, [r0], r1
523	vld1.64 {d4}, [r0], r1	484	vld1.8 {d4}, [r0], r1
524	vld1.64 {d26}, [r0], r1	485	vld1.8 {d26}, [r0], r1
525	vld1.64 {d7}, [r0], r1	486	vld1.8 {d7}, [r0], r1
526	vld1.64 {d21}, [r0], r1	487	vld1.8 {d21}, [r0], r1
527	vld1.64 {d19}, [r0], r1	488	vld1.8 {d19}, [r0], r1
528	vld1.64 {d17}, [r0], r1	489	vld1.8 {d17}, [r0], r1
529	vld1.64 {d1}, [r0], r1	490	vld1.8 {d1}, [r0], r1
530	vld1.64 {d3}, [r0], r1	491	vld1.8 {d3}, [r0], r1
531	vld1.64 {d5}, [r0], r1	492	vld1.8 {d5}, [r0], r1
532	vld1.64 {d27}, [r0], r1	493	vld1.8 {d27}, [r0], r1
533		494
534	transpose_8x8 q3, q10, q9, q8, q0, q1, q2, q13	495	transpose_8x8 q3, q10, q9, q8, q0, q1, q2, q13
535		496
@@ -562,7 +523,7 @@ function ff_h264_h_loop_filter_luma_neon, export=1 · 26 unmodified lines
562	bx lr	523	bx lr
563	endfunc	524	endfunc
564		525
565	.macro h264_loop_filter_chroma	526	.macro h264_loop_filter_chroma
566	vdup.8 d22, r2 @ alpha	527	vdup.8 d22, r2 @ alpha
567	vmovl.u8 q12, d24	528	vmovl.u8 q12, d24
568	vabd.u8 d26, d16, d0 @ abs(p0 - q0)	529	vabd.u8 d26, d16, d0 @ abs(p0 - q0)
@@ -591,22 +552,22 @@ endfunc · 22 unmodified lines
591	vsubw.s8 q11, q11, d4	552	vsubw.s8 q11, q11, d4
592	vqmovun.s16 d16, q14	553	vqmovun.s16 d16, q14
593	vqmovun.s16 d0, q11	554	vqmovun.s16 d0, q11
594	.endm	555	.endm
595		556
596	function ff_h264_v_loop_filter_chroma_neon, export=1	557	function ff_h264_v_loop_filter_chroma_neon, export=1
597	h264_loop_filter_start	558	h264_loop_filter_start
598		559
599	sub r0, r0, r1, lsl #1	560	sub r0, r0, r1, lsl #1
600	vld1.64 {d18}, [r0,:64], r1	561	vld1.8 {d18}, [r0,:64], r1
601	vld1.64 {d16}, [r0,:64], r1	562	vld1.8 {d16}, [r0,:64], r1
602	vld1.64 {d0}, [r0,:64], r1	563	vld1.8 {d0}, [r0,:64], r1
603	vld1.64 {d2}, [r0,:64]	564	vld1.8 {d2}, [r0,:64]
604		565
605	h264_loop_filter_chroma	566	h264_loop_filter_chroma
606		567
607	sub r0, r0, r1, lsl #1	568	sub r0, r0, r1, lsl #1
608	vst1.64 {d16}, [r0,:64], r1	569	vst1.8 {d16}, [r0,:64], r1
609	vst1.64 {d0}, [r0,:64], r1	570	vst1.8 {d0}, [r0,:64], r1
610		571
611	bx lr	572	bx lr
612	endfunc	573	endfunc
@@ -651,20 +612,20 @@ endfunc · 38 unmodified lines
651		612
652	/* H.264 qpel MC */	613	/* H.264 qpel MC */
653		614
654	.macro lowpass_const r	615	.macro lowpass_const r
655	movw \r, #5	616	movw \r, #5
656	movt \r, #20	617	movt \r, #20
657	vmov.32 d6[0], \r	618	vmov.32 d6[0], \r
658	.endm	619	.endm
659		620
660	.macro lowpass_8 r0, r1, r2, r3, d0, d1, narrow=1	621	.macro lowpass_8 r0, r1, r2, r3, d0, d1, narrow=1
661	.if \narrow	622	.if \narrow
662	t0 .req q0	623	t0 .req q0
663	t1 .req q8	624	t1 .req q8
664	.else	625	.else
665	t0 .req \d0	626	t0 .req \d0
666	t1 .req \d1	627	t1 .req \d1
667	.endif	628	.endif
668	vext.8 d2, \r0, \r1, #2	629	vext.8 d2, \r0, \r1, #2
669	vext.8 d3, \r0, \r1, #3	630	vext.8 d3, \r0, \r1, #3
670	vaddl.u8 q1, d2, d3	631	vaddl.u8 q1, d2, d3
@@ -685,20 +646,20 @@ endfunc · 14 unmodified lines
685	vaddl.u8 t1, \r2, d31	646	vaddl.u8 t1, \r2, d31
686	vmla.i16 t1, q9, d6[1]	647	vmla.i16 t1, q9, d6[1]
687	vmls.i16 t1, q10, d6[0]	648	vmls.i16 t1, q10, d6[0]
688	.if \narrow	649	.if \narrow
689	vqrshrun.s16 \d0, t0, #5	650	vqrshrun.s16 \d0, t0, #5
690	vqrshrun.s16 \d1, t1, #5	651	vqrshrun.s16 \d1, t1, #5
691	.endif	652	.endif
692	.unreq t0	653	.unreq t0
693	.unreq t1	654	.unreq t1
694	.endm	655	.endm
695		656
696	.macro lowpass_8_1 r0, r1, d0, narrow=1	657	.macro lowpass_8_1 r0, r1, d0, narrow=1
697	.if \narrow	658	.if \narrow
698	t0 .req q0	659	t0 .req q0
699	.else	660	.else
700	t0 .req \d0	661	t0 .req \d0
701	.endif	662	.endif
702	vext.8 d2, \r0, \r1, #2	663	vext.8 d2, \r0, \r1, #2
703	vext.8 d3, \r0, \r1, #3	664	vext.8 d3, \r0, \r1, #3
704	vaddl.u8 q1, d2, d3	665	vaddl.u8 q1, d2, d3
@@ -709,13 +670,13 @@ endfunc · 4 unmodified lines
709	vaddl.u8 t0, \r0, d30	670	vaddl.u8 t0, \r0, d30
710	vmla.i16 t0, q1, d6[1]	671	vmla.i16 t0, q1, d6[1]
711	vmls.i16 t0, q2, d6[0]	672	vmls.i16 t0, q2, d6[0]
712	.if \narrow	673	.if \narrow
713	vqrshrun.s16 \d0, t0, #5	674	vqrshrun.s16 \d0, t0, #5
714	.endif	675	.endif
715	.unreq t0	676	.unreq t0
716	.endm	677	.endm
717		678
718	.macro lowpass_8.16 r0, r1, l0, h0, l1, h1, d	679	.macro lowpass_8.16 r0, r1, l0, h0, l1, h1, d
719	vext.16 q1, \r0, \r1, #2	680	vext.16 q1, \r0, \r1, #2
720	vext.16 q0, \r0, \r1, #3	681	vext.16 q0, \r0, \r1, #3
721	vaddl.s16 q9, d2, d0	682	vaddl.s16 q9, d2, d0
@@ -750,59 +711,59 @@ endfunc · 28 unmodified lines
750	vrshrn.s32 d19, q1, #10	711	vrshrn.s32 d19, q1, #10
751		712
752	vqmovun.s16 \d, q9	713	vqmovun.s16 \d, q9
753	.endm	714	.endm
754		715
755	function put_h264_qpel16_h_lowpass_neon_packed	716	function put_h264_qpel16_h_lowpass_neon_packed
756	mov r4, lr	717	mov r4, lr
757	mov ip, #16	718	mov r12, #16
758	mov r3, #8	719	mov r3, #8
759	bl put_h264_qpel8_h_lowpass_neon	720	bl put_h264_qpel8_h_lowpass_neon
760	sub r1, r1, r2, lsl #4	721	sub r1, r1, r2, lsl #4
761	add r1, r1, #8	722	add r1, r1, #8
762	mov ip, #16	723	mov r12, #16
763	mov lr, r4	724	mov lr, r4
764	b put_h264_qpel8_h_lowpass_neon	725	b put_h264_qpel8_h_lowpass_neon
765	endfunc	726	endfunc
766		727
767	.macro h264_qpel_h_lowpass type	728	.macro h264_qpel_h_lowpass type
768	function \type\()_h264_qpel16_h_lowpass_neon	729	function \type\()_h264_qpel16_h_lowpass_neon
769	push {lr}	730	push {lr}
770	mov ip, #16	731	mov r12, #16
771	bl \type\()_h264_qpel8_h_lowpass_neon	732	bl \type\()_h264_qpel8_h_lowpass_neon
772	sub r0, r0, r3, lsl #4	733	sub r0, r0, r3, lsl #4
773	sub r1, r1, r2, lsl #4	734	sub r1, r1, r2, lsl #4
774	add r0, r0, #8	735	add r0, r0, #8
775	add r1, r1, #8	736	add r1, r1, #8
776	mov ip, #16	737	mov r12, #16
777	pop {lr}	738	pop {lr}
778	endfunc	739	endfunc
779		740
780	function \type\()_h264_qpel8_h_lowpass_neon	741	function \type\()_h264_qpel8_h_lowpass_neon
781	1: vld1.64 {d0, d1}, [r1], r2	742	1: vld1.8 {d0, d1}, [r1], r2
782	vld1.64 {d16,d17}, [r1], r2	743	vld1.8 {d16,d17}, [r1], r2
783	subs ip, ip, #2	744	subs r12, r12, #2
784	lowpass_8 d0, d1, d16, d17, d0, d16	745	lowpass_8 d0, d1, d16, d17, d0, d16
785	.ifc \type,avg	746	.ifc \type,avg
786	vld1.8 {d2}, [r0,:64], r3	747	vld1.8 {d2}, [r0,:64], r3
787	vrhadd.u8 d0, d0, d2	748	vrhadd.u8 d0, d0, d2
788	vld1.8 {d3}, [r0,:64]	749	vld1.8 {d3}, [r0,:64]
789	vrhadd.u8 d16, d16, d3	750	vrhadd.u8 d16, d16, d3
790	sub r0, r0, r3	751	sub r0, r0, r3
791	.endif	752	.endif
792	vst1.64 {d0}, [r0,:64], r3	753	vst1.8 {d0}, [r0,:64], r3
793	vst1.64 {d16}, [r0,:64], r3	754	vst1.8 {d16}, [r0,:64], r3
794	bne 1b	755	bne 1b
795	bx lr	756	bx lr
796	endfunc	757	endfunc
797	.endm	758	.endm
798		759
799	h264_qpel_h_lowpass put	760	h264_qpel_h_lowpass put
800	h264_qpel_h_lowpass avg	761	h264_qpel_h_lowpass avg
801		762
802	.macro h264_qpel_h_lowpass_l2 type	763	.macro h264_qpel_h_lowpass_l2 type
803	function \type\()_h264_qpel16_h_lowpass_l2_neon	764	function \type\()_h264_qpel16_h_lowpass_l2_neon
804	push {lr}	765	push {lr}
805	mov ip, #16	766	mov r12, #16
806	bl \type\()_h264_qpel8_h_lowpass_l2_neon	767	bl \type\()_h264_qpel8_h_lowpass_l2_neon
807	sub r0, r0, r2, lsl #4	768	sub r0, r0, r2, lsl #4
808	sub r1, r1, r2, lsl #4	769	sub r1, r1, r2, lsl #4
@@ -810,31 +771,31 @@ function \type\()_h264_qpel16_h_lowpass_l2_neon · 1 unmodified line
810	add r0, r0, #8	771	add r0, r0, #8
811	add r1, r1, #8	772	add r1, r1, #8
812	add r3, r3, #8	773	add r3, r3, #8
813	mov ip, #16	774	mov r12, #16
814	pop {lr}	775	pop {lr}
815	endfunc	776	endfunc
816		777
817	function \type\()_h264_qpel8_h_lowpass_l2_neon	778	function \type\()_h264_qpel8_h_lowpass_l2_neon
818	1: vld1.64 {d0, d1}, [r1], r2	779	1: vld1.8 {d0, d1}, [r1], r2
819	vld1.64 {d16,d17}, [r1], r2	780	vld1.8 {d16,d17}, [r1], r2
820	vld1.64 {d28}, [r3], r2	781	vld1.8 {d28}, [r3], r2
821	vld1.64 {d29}, [r3], r2	782	vld1.8 {d29}, [r3], r2
822	subs ip, ip, #2	783	subs r12, r12, #2
823	lowpass_8 d0, d1, d16, d17, d0, d1	784	lowpass_8 d0, d1, d16, d17, d0, d1
824	vrhadd.u8 q0, q0, q14	785	vrhadd.u8 q0, q0, q14
825	.ifc \type,avg	786	.ifc \type,avg
826	vld1.8 {d2}, [r0,:64], r2	787	vld1.8 {d2}, [r0,:64], r2
827	vrhadd.u8 d0, d0, d2	788	vrhadd.u8 d0, d0, d2
828	vld1.8 {d3}, [r0,:64]	789	vld1.8 {d3}, [r0,:64]
829	vrhadd.u8 d1, d1, d3	790	vrhadd.u8 d1, d1, d3
830	sub r0, r0, r2	791	sub r0, r0, r2
831	.endif	792	.endif
832	vst1.64 {d0}, [r0,:64], r2	793	vst1.8 {d0}, [r0,:64], r2
833	vst1.64 {d1}, [r0,:64], r2	794	vst1.8 {d1}, [r0,:64], r2
834	bne 1b	795	bne 1b
835	bx lr	796	bx lr
836	endfunc	797	endfunc
837	.endm	798	.endm
838		799
839	h264_qpel_h_lowpass_l2 put	800	h264_qpel_h_lowpass_l2 put
840	h264_qpel_h_lowpass_l2 avg	801	h264_qpel_h_lowpass_l2 avg
@@ -854,7 +815,7 @@ function put_h264_qpel16_v_lowpass_neon_packed · 13 unmodified lines
854	b put_h264_qpel8_v_lowpass_neon	815	b put_h264_qpel8_v_lowpass_neon
855	endfunc	816	endfunc
856		817
857	.macro h264_qpel_v_lowpass type	818	.macro h264_qpel_v_lowpass type
858	function \type\()_h264_qpel16_v_lowpass_neon	819	function \type\()_h264_qpel16_v_lowpass_neon
859	mov r4, lr	820	mov r4, lr
860	bl \type\()_h264_qpel8_v_lowpass_neon	821	bl \type\()_h264_qpel8_v_lowpass_neon
@@ -871,19 +832,19 @@ function \type\()_h264_qpel16_v_lowpass_neon · 10 unmodified lines
871	endfunc	832	endfunc
872		833
873	function \type\()_h264_qpel8_v_lowpass_neon	834	function \type\()_h264_qpel8_v_lowpass_neon
874	vld1.64 {d8}, [r1], r3	835	vld1.8 {d8}, [r1], r3
875	vld1.64 {d10}, [r1], r3	836	vld1.8 {d10}, [r1], r3
876	vld1.64 {d12}, [r1], r3	837	vld1.8 {d12}, [r1], r3
877	vld1.64 {d14}, [r1], r3	838	vld1.8 {d14}, [r1], r3
878	vld1.64 {d22}, [r1], r3	839	vld1.8 {d22}, [r1], r3
879	vld1.64 {d24}, [r1], r3	840	vld1.8 {d24}, [r1], r3
880	vld1.64 {d26}, [r1], r3	841	vld1.8 {d26}, [r1], r3
881	vld1.64 {d28}, [r1], r3	842	vld1.8 {d28}, [r1], r3
882	vld1.64 {d9}, [r1], r3	843	vld1.8 {d9}, [r1], r3
883	vld1.64 {d11}, [r1], r3	844	vld1.8 {d11}, [r1], r3
884	vld1.64 {d13}, [r1], r3	845	vld1.8 {d13}, [r1], r3
885	vld1.64 {d15}, [r1], r3	846	vld1.8 {d15}, [r1], r3
886	vld1.64 {d23}, [r1]	847	vld1.8 {d23}, [r1]
887		848
888	transpose_8x8 q4, q5, q6, q7, q11, q12, q13, q14	849	transpose_8x8 q4, q5, q6, q7, q11, q12, q13, q14
889	lowpass_8 d8, d9, d10, d11, d8, d10	850	lowpass_8 d8, d9, d10, d11, d8, d10
@@ -892,7 +853,7 @@ function \type\()_h264_qpel8_v_lowpass_neon · 2 unmodified lines
892	lowpass_8 d26, d27, d28, d29, d26, d28	853	lowpass_8 d26, d27, d28, d29, d26, d28
893	transpose_8x8 d8, d10, d12, d14, d22, d24, d26, d28	854	transpose_8x8 d8, d10, d12, d14, d22, d24, d26, d28
894		855
895	.ifc \type,avg	856	.ifc \type,avg
896	vld1.8 {d9}, [r0,:64], r2	857	vld1.8 {d9}, [r0,:64], r2
897	vrhadd.u8 d8, d8, d9	858	vrhadd.u8 d8, d8, d9
898	vld1.8 {d11}, [r0,:64], r2	859	vld1.8 {d11}, [r0,:64], r2
@@ -910,34 +871,34 @@ function \type\()_h264_qpel8_v_lowpass_neon · 11 unmodified lines
910	vld1.8 {d29}, [r0,:64], r2	871	vld1.8 {d29}, [r0,:64], r2
911	vrhadd.u8 d28, d28, d29	872	vrhadd.u8 d28, d28, d29
912	sub r0, r0, r2, lsl #3	873	sub r0, r0, r2, lsl #3
913	.endif	874	.endif
914		875
915	vst1.64 {d8}, [r0,:64], r2	876	vst1.8 {d8}, [r0,:64], r2
916	vst1.64 {d10}, [r0,:64], r2	877	vst1.8 {d10}, [r0,:64], r2
917	vst1.64 {d12}, [r0,:64], r2	878	vst1.8 {d12}, [r0,:64], r2
918	vst1.64 {d14}, [r0,:64], r2	879	vst1.8 {d14}, [r0,:64], r2
919	vst1.64 {d22}, [r0,:64], r2	880	vst1.8 {d22}, [r0,:64], r2
920	vst1.64 {d24}, [r0,:64], r2	881	vst1.8 {d24}, [r0,:64], r2
921	vst1.64 {d26}, [r0,:64], r2	882	vst1.8 {d26}, [r0,:64], r2
922	vst1.64 {d28}, [r0,:64], r2	883	vst1.8 {d28}, [r0,:64], r2
923		884
924	bx lr	885	bx lr
925	endfunc	886	endfunc
926	.endm	887	.endm
927		888
928	h264_qpel_v_lowpass put	889	h264_qpel_v_lowpass put
929	h264_qpel_v_lowpass avg	890	h264_qpel_v_lowpass avg
930		891
931	.macro h264_qpel_v_lowpass_l2 type	892	.macro h264_qpel_v_lowpass_l2 type
932	function \type\()_h264_qpel16_v_lowpass_l2_neon	893	function \type\()_h264_qpel16_v_lowpass_l2_neon
933	mov r4, lr	894	mov r4, lr
934	bl \type\()_h264_qpel8_v_lowpass_l2_neon	895	bl \type\()_h264_qpel8_v_lowpass_l2_neon
935	sub r1, r1, r3, lsl #2	896	sub r1, r1, r3, lsl #2
936	bl \type\()_h264_qpel8_v_lowpass_l2_neon	897	bl \type\()_h264_qpel8_v_lowpass_l2_neon
937	sub r0, r0, r3, lsl #4	898	sub r0, r0, r3, lsl #4
938	sub ip, ip, r2, lsl #4	899	sub r12, r12, r2, lsl #4
939	add r0, r0, #8	900	add r0, r0, #8
940	add ip, ip, #8	901	add r12, r12, #8
941	sub r1, r1, r3, lsl #4	902	sub r1, r1, r3, lsl #4
942	sub r1, r1, r3, lsl #2	903	sub r1, r1, r3, lsl #2
943	add r1, r1, #8	904	add r1, r1, #8
@@ -947,19 +908,19 @@ function \type\()_h264_qpel16_v_lowpass_l2_neon · 3 unmodified lines
947	endfunc	908	endfunc
948		909
949	function \type\()_h264_qpel8_v_lowpass_l2_neon	910	function \type\()_h264_qpel8_v_lowpass_l2_neon
950	vld1.64 {d8}, [r1], r3	911	vld1.8 {d8}, [r1], r3
951	vld1.64 {d10}, [r1], r3	912	vld1.8 {d10}, [r1], r3
952	vld1.64 {d12}, [r1], r3	913	vld1.8 {d12}, [r1], r3
953	vld1.64 {d14}, [r1], r3	914	vld1.8 {d14}, [r1], r3
954	vld1.64 {d22}, [r1], r3	915	vld1.8 {d22}, [r1], r3
955	vld1.64 {d24}, [r1], r3	916	vld1.8 {d24}, [r1], r3
956	vld1.64 {d26}, [r1], r3	917	vld1.8 {d26}, [r1], r3
957	vld1.64 {d28}, [r1], r3	918	vld1.8 {d28}, [r1], r3
958	vld1.64 {d9}, [r1], r3	919	vld1.8 {d9}, [r1], r3
959	vld1.64 {d11}, [r1], r3	920	vld1.8 {d11}, [r1], r3
960	vld1.64 {d13}, [r1], r3	921	vld1.8 {d13}, [r1], r3
961	vld1.64 {d15}, [r1], r3	922	vld1.8 {d15}, [r1], r3
962	vld1.64 {d23}, [r1]	923	vld1.8 {d23}, [r1]
963		924
964	transpose_8x8 q4, q5, q6, q7, q11, q12, q13, q14	925	transpose_8x8 q4, q5, q6, q7, q11, q12, q13, q14
965	lowpass_8 d8, d9, d10, d11, d8, d9	926	lowpass_8 d8, d9, d10, d11, d8, d9
@@ -968,20 +929,20 @@ function \type\()_h264_qpel8_v_lowpass_l2_neon · 2 unmodified lines
968	lowpass_8 d26, d27, d28, d29, d26, d27	929	lowpass_8 d26, d27, d28, d29, d26, d27
969	transpose_8x8 d8, d9, d12, d13, d22, d23, d26, d27	930	transpose_8x8 d8, d9, d12, d13, d22, d23, d26, d27
970		931
971	vld1.64 {d0}, [ip], r2	932	vld1.8 {d0}, [r12], r2
972	vld1.64 {d1}, [ip], r2	933	vld1.8 {d1}, [r12], r2
973	vld1.64 {d2}, [ip], r2	934	vld1.8 {d2}, [r12], r2
974	vld1.64 {d3}, [ip], r2	935	vld1.8 {d3}, [r12], r2
975	vld1.64 {d4}, [ip], r2	936	vld1.8 {d4}, [r12], r2
976	vrhadd.u8 q0, q0, q4	937	vrhadd.u8 q0, q0, q4
977	vld1.64 {d5}, [ip], r2	938	vld1.8 {d5}, [r12], r2
978	vrhadd.u8 q1, q1, q6	939	vrhadd.u8 q1, q1, q6
979	vld1.64 {d10}, [ip], r2	940	vld1.8 {d10}, [r12], r2
980	vrhadd.u8 q2, q2, q11	941	vrhadd.u8 q2, q2, q11
981	vld1.64 {d11}, [ip], r2	942	vld1.8 {d11}, [r12], r2
982	vrhadd.u8 q5, q5, q13	943	vrhadd.u8 q5, q5, q13
983		944
984	.ifc \type,avg	945	.ifc \type,avg
985	vld1.8 {d16}, [r0,:64], r3	946	vld1.8 {d16}, [r0,:64], r3
986	vrhadd.u8 d0, d0, d16	947	vrhadd.u8 d0, d0, d16
987	vld1.8 {d17}, [r0,:64], r3	948	vld1.8 {d17}, [r0,:64], r3
@@ -999,51 +960,51 @@ function \type\()_h264_qpel8_v_lowpass_l2_neon · 11 unmodified lines
999	vld1.8 {d17}, [r0,:64], r3	960	vld1.8 {d17}, [r0,:64], r3
1000	vrhadd.u8 d11, d11, d17	961	vrhadd.u8 d11, d11, d17
1001	sub r0, r0, r3, lsl #3	962	sub r0, r0, r3, lsl #3
1002	.endif	963	.endif
1003		964
1004	vst1.64 {d0}, [r0,:64], r3	965	vst1.8 {d0}, [r0,:64], r3
1005	vst1.64 {d1}, [r0,:64], r3	966	vst1.8 {d1}, [r0,:64], r3
1006	vst1.64 {d2}, [r0,:64], r3	967	vst1.8 {d2}, [r0,:64], r3
1007	vst1.64 {d3}, [r0,:64], r3	968	vst1.8 {d3}, [r0,:64], r3
1008	vst1.64 {d4}, [r0,:64], r3	969	vst1.8 {d4}, [r0,:64], r3
1009	vst1.64 {d5}, [r0,:64], r3	970	vst1.8 {d5}, [r0,:64], r3
1010	vst1.64 {d10}, [r0,:64], r3	971	vst1.8 {d10}, [r0,:64], r3
1011	vst1.64 {d11}, [r0,:64], r3	972	vst1.8 {d11}, [r0,:64], r3
1012		973
1013	bx lr	974	bx lr
1014	endfunc	975	endfunc
1015	.endm	976	.endm
1016		977
1017	h264_qpel_v_lowpass_l2 put	978	h264_qpel_v_lowpass_l2 put
1018	h264_qpel_v_lowpass_l2 avg	979	h264_qpel_v_lowpass_l2 avg
1019		980
1020	function put_h264_qpel8_hv_lowpass_neon_top	981	function put_h264_qpel8_hv_lowpass_neon_top
1021	lowpass_const ip	982	lowpass_const r12
1022	mov ip, #12	983	mov r12, #12
1023	1: vld1.64 {d0, d1}, [r1], r3	984	1: vld1.8 {d0, d1}, [r1], r3
1024	vld1.64 {d16,d17}, [r1], r3	985	vld1.8 {d16,d17}, [r1], r3
1025	subs ip, ip, #2	986	subs r12, r12, #2
1026	lowpass_8 d0, d1, d16, d17, q11, q12, narrow=0	987	lowpass_8 d0, d1, d16, d17, q11, q12, narrow=0
1027	vst1.64 {d22-d25}, [r4,:128]!	988	vst1.8 {d22-d25}, [r4,:128]!
1028	bne 1b	989	bne 1b
1029		990
1030	vld1.64 {d0, d1}, [r1]	991	vld1.8 {d0, d1}, [r1]
1031	lowpass_8_1 d0, d1, q12, narrow=0	992	lowpass_8_1 d0, d1, q12, narrow=0
1032		993
1033	mov ip, #-16	994	mov r12, #-16
1034	add r4, r4, ip	995	add r4, r4, r12
1035	vld1.64 {d30,d31}, [r4,:128], ip	996	vld1.8 {d30,d31}, [r4,:128], r12
1036	vld1.64 {d20,d21}, [r4,:128], ip	997	vld1.8 {d20,d21}, [r4,:128], r12
1037	vld1.64 {d18,d19}, [r4,:128], ip	998	vld1.8 {d18,d19}, [r4,:128], r12
1038	vld1.64 {d16,d17}, [r4,:128], ip	999	vld1.8 {d16,d17}, [r4,:128], r12
1039	vld1.64 {d14,d15}, [r4,:128], ip	1000	vld1.8 {d14,d15}, [r4,:128], r12
1040	vld1.64 {d12,d13}, [r4,:128], ip	1001	vld1.8 {d12,d13}, [r4,:128], r12
1041	vld1.64 {d10,d11}, [r4,:128], ip	1002	vld1.8 {d10,d11}, [r4,:128], r12
1042	vld1.64 {d8, d9}, [r4,:128], ip	1003	vld1.8 {d8, d9}, [r4,:128], r12
1043	vld1.64 {d6, d7}, [r4,:128], ip	1004	vld1.8 {d6, d7}, [r4,:128], r12
1044	vld1.64 {d4, d5}, [r4,:128], ip	1005	vld1.8 {d4, d5}, [r4,:128], r12
1045	vld1.64 {d2, d3}, [r4,:128], ip	1006	vld1.8 {d2, d3}, [r4,:128], r12
1046	vld1.64 {d0, d1}, [r4,:128]	1007	vld1.8 {d0, d1}, [r4,:128]
1047		1008
1048	swap4 d1, d3, d5, d7, d8, d10, d12, d14	1009	swap4 d1, d3, d5, d7, d8, d10, d12, d14
1049	transpose16_4x4 q0, q1, q2, q3, q4, q5, q6, q7	1010	transpose16_4x4 q0, q1, q2, q3, q4, q5, q6, q7
@@ -1051,31 +1012,31 @@ function put_h264_qpel8_hv_lowpass_neon_top · 1 unmodified line
1051	swap4 d17, d19, d21, d31, d24, d26, d28, d22	1012	swap4 d17, d19, d21, d31, d24, d26, d28, d22
1052	transpose16_4x4 q8, q9, q10, q15, q12, q13, q14, q11	1013	transpose16_4x4 q8, q9, q10, q15, q12, q13, q14, q11
1053		1014
1054	vst1.64 {d30,d31}, [r4,:128]!	1015	vst1.8 {d30,d31}, [r4,:128]!
1055	vst1.64 {d6, d7}, [r4,:128]!	1016	vst1.8 {d6, d7}, [r4,:128]!
1056	vst1.64 {d20,d21}, [r4,:128]!	1017	vst1.8 {d20,d21}, [r4,:128]!
1057	vst1.64 {d4, d5}, [r4,:128]!	1018	vst1.8 {d4, d5}, [r4,:128]!
1058	vst1.64 {d18,d19}, [r4,:128]!	1019	vst1.8 {d18,d19}, [r4,:128]!
1059	vst1.64 {d2, d3}, [r4,:128]!	1020	vst1.8 {d2, d3}, [r4,:128]!
1060	vst1.64 {d16,d17}, [r4,:128]!	1021	vst1.8 {d16,d17}, [r4,:128]!
1061	vst1.64 {d0, d1}, [r4,:128]	1022	vst1.8 {d0, d1}, [r4,:128]
1062		1023
1063	lowpass_8.16 q4, q12, d8, d9, d24, d25, d8	1024	lowpass_8.16 q4, q12, d8, d9, d24, d25, d8
1064	lowpass_8.16 q5, q13, d10, d11, d26, d27, d9	1025	lowpass_8.16 q5, q13, d10, d11, d26, d27, d9
1065	lowpass_8.16 q6, q14, d12, d13, d28, d29, d10	1026	lowpass_8.16 q6, q14, d12, d13, d28, d29, d10
1066	lowpass_8.16 q7, q11, d14, d15, d22, d23, d11	1027	lowpass_8.16 q7, q11, d14, d15, d22, d23, d11
1067		1028
1068	vld1.64 {d16,d17}, [r4,:128], ip	1029	vld1.8 {d16,d17}, [r4,:128], r12
1069	vld1.64 {d30,d31}, [r4,:128], ip	1030	vld1.8 {d30,d31}, [r4,:128], r12
1070	lowpass_8.16 q8, q15, d16, d17, d30, d31, d12	1031	lowpass_8.16 q8, q15, d16, d17, d30, d31, d12
1071	vld1.64 {d16,d17}, [r4,:128], ip	1032	vld1.8 {d16,d17}, [r4,:128], r12
1072	vld1.64 {d30,d31}, [r4,:128], ip	1033	vld1.8 {d30,d31}, [r4,:128], r12
1073	lowpass_8.16 q8, q15, d16, d17, d30, d31, d13	1034	lowpass_8.16 q8, q15, d16, d17, d30, d31, d13
1074	vld1.64 {d16,d17}, [r4,:128], ip	1035	vld1.8 {d16,d17}, [r4,:128], r12
1075	vld1.64 {d30,d31}, [r4,:128], ip	1036	vld1.8 {d30,d31}, [r4,:128], r12
1076	lowpass_8.16 q8, q15, d16, d17, d30, d31, d14	1037	lowpass_8.16 q8, q15, d16, d17, d30, d31, d14
1077	vld1.64 {d16,d17}, [r4,:128], ip	1038	vld1.8 {d16,d17}, [r4,:128], r12
1078	vld1.64 {d30,d31}, [r4,:128]	1039	vld1.8 {d30,d31}, [r4,:128]
1079	lowpass_8.16 q8, q15, d16, d17, d30, d31, d15	1040	lowpass_8.16 q8, q15, d16, d17, d30, d31, d15
1080		1041
1081	transpose_8x8 d12, d13, d14, d15, d8, d9, d10, d11	1042	transpose_8x8 d12, d13, d14, d15, d8, d9, d10, d11
@@ -1083,11 +1044,11 @@ function put_h264_qpel8_hv_lowpass_neon_top · 1 unmodified line
1083	bx lr	1044	bx lr
1084	endfunc	1045	endfunc
1085		1046
1086	.macro h264_qpel8_hv_lowpass type	1047	.macro h264_qpel8_hv_lowpass type
1087	function \type\()_h264_qpel8_hv_lowpass_neon	1048	function \type\()_h264_qpel8_hv_lowpass_neon
1088	mov r10, lr	1049	mov r10, lr
1089	bl put_h264_qpel8_hv_lowpass_neon_top	1050	bl put_h264_qpel8_hv_lowpass_neon_top
1090	.ifc \type,avg	1051	.ifc \type,avg
1091	vld1.8 {d0}, [r0,:64], r2	1052	vld1.8 {d0}, [r0,:64], r2
1092	vrhadd.u8 d12, d12, d0	1053	vrhadd.u8 d12, d12, d0
1093	vld1.8 {d1}, [r0,:64], r2	1054	vld1.8 {d1}, [r0,:64], r2
@@ -1105,39 +1066,39 @@ function \type\()_h264_qpel8_hv_lowpass_neon · 11 unmodified lines
1105	vld1.8 {d7}, [r0,:64], r2	1066	vld1.8 {d7}, [r0,:64], r2
1106	vrhadd.u8 d11, d11, d7	1067	vrhadd.u8 d11, d11, d7
1107	sub r0, r0, r2, lsl #3	1068	sub r0, r0, r2, lsl #3
1108	.endif	1069	.endif
1109		1070
1110	vst1.64 {d12}, [r0,:64], r2	1071	vst1.8 {d12}, [r0,:64], r2
1111	vst1.64 {d13}, [r0,:64], r2	1072	vst1.8 {d13}, [r0,:64], r2
1112	vst1.64 {d14}, [r0,:64], r2	1073	vst1.8 {d14}, [r0,:64], r2
1113	vst1.64 {d15}, [r0,:64], r2	1074	vst1.8 {d15}, [r0,:64], r2
1114	vst1.64 {d8}, [r0,:64], r2	1075	vst1.8 {d8}, [r0,:64], r2
1115	vst1.64 {d9}, [r0,:64], r2	1076	vst1.8 {d9}, [r0,:64], r2
1116	vst1.64 {d10}, [r0,:64], r2	1077	vst1.8 {d10}, [r0,:64], r2
1117	vst1.64 {d11}, [r0,:64], r2	1078	vst1.8 {d11}, [r0,:64], r2
1118		1079
1119	mov lr, r10	1080	mov lr, r10
1120	bx lr	1081	bx lr
1121	endfunc	1082	endfunc
1122	.endm	1083	.endm
1123		1084
1124	h264_qpel8_hv_lowpass put	1085	h264_qpel8_hv_lowpass put
1125	h264_qpel8_hv_lowpass avg	1086	h264_qpel8_hv_lowpass avg
1126		1087
1127	.macro h264_qpel8_hv_lowpass_l2 type	1088	.macro h264_qpel8_hv_lowpass_l2 type
1128	function \type\()_h264_qpel8_hv_lowpass_l2_neon	1089	function \type\()_h264_qpel8_hv_lowpass_l2_neon
1129	mov r10, lr	1090	mov r10, lr
1130	bl put_h264_qpel8_hv_lowpass_neon_top	1091	bl put_h264_qpel8_hv_lowpass_neon_top
1131		1092
1132	vld1.64 {d0, d1}, [r2,:128]!	1093	vld1.8 {d0, d1}, [r2,:128]!
1133	vld1.64 {d2, d3}, [r2,:128]!	1094	vld1.8 {d2, d3}, [r2,:128]!
1134	vrhadd.u8 q0, q0, q6	1095	vrhadd.u8 q0, q0, q6
1135	vld1.64 {d4, d5}, [r2,:128]!	1096	vld1.8 {d4, d5}, [r2,:128]!
1136	vrhadd.u8 q1, q1, q7	1097	vrhadd.u8 q1, q1, q7
1137	vld1.64 {d6, d7}, [r2,:128]!	1098	vld1.8 {d6, d7}, [r2,:128]!
1138	vrhadd.u8 q2, q2, q4	1099	vrhadd.u8 q2, q2, q4
1139	vrhadd.u8 q3, q3, q5	1100	vrhadd.u8 q3, q3, q5
1140	.ifc \type,avg	1101	.ifc \type,avg
1141	vld1.8 {d16}, [r0,:64], r3	1102	vld1.8 {d16}, [r0,:64], r3
1142	vrhadd.u8 d0, d0, d16	1103	vrhadd.u8 d0, d0, d16
1143	vld1.8 {d17}, [r0,:64], r3	1104	vld1.8 {d17}, [r0,:64], r3
@@ -1155,25 +1116,25 @@ function \type\()_h264_qpel8_hv_lowpass_l2_neon · 11 unmodified lines
1155	vld1.8 {d23}, [r0,:64], r3	1116	vld1.8 {d23}, [r0,:64], r3
1156	vrhadd.u8 d7, d7, d23	1117	vrhadd.u8 d7, d7, d23
1157	sub r0, r0, r3, lsl #3	1118	sub r0, r0, r3, lsl #3
1158	.endif	1119	.endif
1159	vst1.64 {d0}, [r0,:64], r3	1120	vst1.8 {d0}, [r0,:64], r3
1160	vst1.64 {d1}, [r0,:64], r3	1121	vst1.8 {d1}, [r0,:64], r3
1161	vst1.64 {d2}, [r0,:64], r3	1122	vst1.8 {d2}, [r0,:64], r3
1162	vst1.64 {d3}, [r0,:64], r3	1123	vst1.8 {d3}, [r0,:64], r3
1163	vst1.64 {d4}, [r0,:64], r3	1124	vst1.8 {d4}, [r0,:64], r3
1164	vst1.64 {d5}, [r0,:64], r3	1125	vst1.8 {d5}, [r0,:64], r3
1165	vst1.64 {d6}, [r0,:64], r3	1126	vst1.8 {d6}, [r0,:64], r3
1166	vst1.64 {d7}, [r0,:64], r3	1127	vst1.8 {d7}, [r0,:64], r3
1167		1128
1168	mov lr, r10	1129	mov lr, r10
1169	bx lr	1130	bx lr
1170	endfunc	1131	endfunc
1171	.endm	1132	.endm
1172		1133
1173	h264_qpel8_hv_lowpass_l2 put	1134	h264_qpel8_hv_lowpass_l2 put
1174	h264_qpel8_hv_lowpass_l2 avg	1135	h264_qpel8_hv_lowpass_l2 avg
1175		1136
1176	.macro h264_qpel16_hv type	1137	.macro h264_qpel16_hv type
1177	function \type\()_h264_qpel16_hv_lowpass_neon	1138	function \type\()_h264_qpel16_hv_lowpass_neon
1178	mov r9, lr	1139	mov r9, lr
1179	bl \type\()_h264_qpel8_hv_lowpass_neon	1140	bl \type\()_h264_qpel8_hv_lowpass_neon
@@ -1206,17 +1167,17 @@ function \type\()_h264_qpel16_hv_lowpass_l2_neon · 26 unmodified lines
1206	mov lr, r9	1167	mov lr, r9
1207	b \type\()_h264_qpel8_hv_lowpass_l2_neon	1168	b \type\()_h264_qpel8_hv_lowpass_l2_neon
1208	endfunc	1169	endfunc
1209	.endm	1170	.endm
1210		1171
1211	h264_qpel16_hv put	1172	h264_qpel16_hv put
1212	h264_qpel16_hv avg	1173	h264_qpel16_hv avg
1213		1174
1214	.macro h264_qpel8 type	1175	.macro h264_qpel8 type
1215	function ff_\type\()_h264_qpel8_mc10_neon, export=1	1176	function ff_\type\()_h264_qpel8_mc10_neon, export=1
1216	lowpass_const r3	1177	lowpass_const r3
1217	mov r3, r1	1178	mov r3, r1
1218	sub r1, r1, #2	1179	sub r1, r1, #2
1219	mov ip, #8	1180	mov r12, #8
1220	b \type\()_h264_qpel8_h_lowpass_l2_neon	1181	b \type\()_h264_qpel8_h_lowpass_l2_neon
1221	endfunc	1182	endfunc
1222		1183
@@ -1224,7 +1185,7 @@ function ff_\type\()_h264_qpel8_mc20_neon, export=1 · 1 unmodified line
1224	lowpass_const r3	1185	lowpass_const r3
1225	sub r1, r1, #2	1186	sub r1, r1, #2
1226	mov r3, r2	1187	mov r3, r2
1227	mov ip, #8	1188	mov r12, #8
1228	b \type\()_h264_qpel8_h_lowpass_neon	1189	b \type\()_h264_qpel8_h_lowpass_neon
1229	endfunc	1190	endfunc
1230		1191
@@ -1232,13 +1193,13 @@ function ff_\type\()_h264_qpel8_mc30_neon, export=1 · 1 unmodified line
1232	lowpass_const r3	1193	lowpass_const r3
1233	add r3, r1, #1	1194	add r3, r1, #1
1234	sub r1, r1, #2	1195	sub r1, r1, #2
1235	mov ip, #8	1196	mov r12, #8
1236	b \type\()_h264_qpel8_h_lowpass_l2_neon	1197	b \type\()_h264_qpel8_h_lowpass_l2_neon
1237	endfunc	1198	endfunc
1238		1199
1239	function ff_\type\()_h264_qpel8_mc01_neon, export=1	1200	function ff_\type\()_h264_qpel8_mc01_neon, export=1
1240	push {lr}	1201	push {lr}
1241	mov ip, r1	1202	mov r12, r1
1242	\type\()_h264_qpel8_mc01:	1203	\type\()_h264_qpel8_mc01:
1243	lowpass_const r3	1204	lowpass_const r3
1244	mov r3, r2	1205	mov r3, r2
@@ -1261,12 +1222,12 @@ T mov sp, r0 · 16 unmodified lines
1261	mov r0, sp	1222	mov r0, sp
1262	sub r1, r1, #2	1223	sub r1, r1, #2
1263	mov r3, #8	1224	mov r3, #8
1264	mov ip, #8	1225	mov r12, #8
1265	vpush {d8-d15}	1226	vpush {d8-d15}
1266	bl put_h264_qpel8_h_lowpass_neon	1227	bl put_h264_qpel8_h_lowpass_neon
1267	ldrd r0, [r11], #8	1228	ldrd r0, [r11], #8
1268	mov r3, r2	1229	mov r3, r2
1269	add ip, sp, #64	1230	add r12, sp, #64
1270	sub r1, r1, r2, lsl #1	1231	sub r1, r1, r2, lsl #1
1271	mov r2, #8	1232	mov r2, #8
1272	bl \type\()_h264_qpel8_v_lowpass_l2_neon	1233	bl \type\()_h264_qpel8_v_lowpass_l2_neon
@@ -1287,7 +1248,7 @@ T mov sp, r0 · 14 unmodified lines
1287	sub r1, r1, #2	1248	sub r1, r1, #2
1288	mov r3, #8	1249	mov r3, #8
1289	mov r0, sp	1250	mov r0, sp
1290	mov ip, #8	1251	mov r12, #8
1291	vpush {d8-d15}	1252	vpush {d8-d15}
1292	bl put_h264_qpel8_h_lowpass_neon	1253	bl put_h264_qpel8_h_lowpass_neon
1293	mov r4, r0	1254	mov r4, r0
@@ -1372,7 +1333,7 @@ endfunc · 78 unmodified lines
1372		1333
1373	function ff_\type\()_h264_qpel8_mc03_neon, export=1	1334	function ff_\type\()_h264_qpel8_mc03_neon, export=1
1374	push {lr}	1335	push {lr}
1375	add ip, r1, r2	1336	add r12, r1, r2
1376	b \type\()_h264_qpel8_mc01	1337	b \type\()_h264_qpel8_mc01
1377	endfunc	1338	endfunc
1378		1339
@@ -1395,12 +1356,12 @@ function ff_\type\()_h264_qpel8_mc33_neon, export=1 · 16 unmodified lines
1395	sub r1, r1, #1	1356	sub r1, r1, #1
1396	b \type\()_h264_qpel8_mc11	1357	b \type\()_h264_qpel8_mc11
1397	endfunc	1358	endfunc
1398	.endm	1359	.endm
1399		1360
1400	h264_qpel8 put	1361	h264_qpel8 put
1401	h264_qpel8 avg	1362	h264_qpel8 avg
1402		1363
1403	.macro h264_qpel16 type	1364	.macro h264_qpel16 type
1404	function ff_\type\()_h264_qpel16_mc10_neon, export=1	1365	function ff_\type\()_h264_qpel16_mc10_neon, export=1
1405	lowpass_const r3	1366	lowpass_const r3
1406	mov r3, r1	1367	mov r3, r1
@@ -1424,7 +1385,7 @@ endfunc · 17 unmodified lines
1424		1385
1425	function ff_\type\()_h264_qpel16_mc01_neon, export=1	1386	function ff_\type\()_h264_qpel16_mc01_neon, export=1
1426	push {r4, lr}	1387	push {r4, lr}
1427	mov ip, r1	1388	mov r12, r1
1428	\type\()_h264_qpel16_mc01:	1389	\type\()_h264_qpel16_mc01:
1429	lowpass_const r3	1390	lowpass_const r3
1430	mov r3, r2	1391	mov r3, r2
@@ -1451,7 +1412,7 @@ T mov sp, r0 · 20 unmodified lines
1451	bl put_h264_qpel16_h_lowpass_neon	1412	bl put_h264_qpel16_h_lowpass_neon
1452	ldrd r0, [r11], #8	1413	ldrd r0, [r11], #8
1453	mov r3, r2	1414	mov r3, r2
1454	add ip, sp, #64	1415	add r12, sp, #64
1455	sub r1, r1, r2, lsl #1	1416	sub r1, r1, r2, lsl #1
1456	mov r2, #16	1417	mov r2, #16
1457	bl \type\()_h264_qpel16_v_lowpass_l2_neon	1418	bl \type\()_h264_qpel16_v_lowpass_l2_neon
@@ -1554,7 +1515,7 @@ endfunc · 96 unmodified lines
1554		1515
1555	function ff_\type\()_h264_qpel16_mc03_neon, export=1	1516	function ff_\type\()_h264_qpel16_mc03_neon, export=1
1556	push {r4, lr}	1517	push {r4, lr}
1557	add ip, r1, r2	1518	add r12, r1, r2
1558	b \type\()_h264_qpel16_mc01	1519	b \type\()_h264_qpel16_mc01
1559	endfunc	1520	endfunc
1560		1521
@@ -1577,14 +1538,14 @@ function ff_\type\()_h264_qpel16_mc33_neon, export=1 · 16 unmodified lines
1577	sub r1, r1, #1	1538	sub r1, r1, #1
1578	b \type\()_h264_qpel16_mc11	1539	b \type\()_h264_qpel16_mc11
1579	endfunc	1540	endfunc
1580	.endm	1541	.endm
1581		1542
1582	h264_qpel16 put	1543	h264_qpel16 put
1583	h264_qpel16 avg	1544	h264_qpel16 avg
1584		1545
1585	@ Biweighted prediction	1546	@ Biweighted prediction
1586		1547
1587	.macro biweight_16 macs, macd	1548	.macro biweight_16 macs, macd
1588	vdup.8 d0, r4	1549	vdup.8 d0, r4
1589	vdup.8 d1, r5	1550	vdup.8 d1, r5
1590	vmov q2, q8	1551	vmov q2, q8
@@ -1622,9 +1583,9 @@ endfunc · 31 unmodified lines
1622	vst1.8 {d24-d25},[r6,:128], r2	1583	vst1.8 {d24-d25},[r6,:128], r2
1623	bne 1b	1584	bne 1b
1624	pop {r4-r6, pc}	1585	pop {r4-r6, pc}
1625	.endm	1586	.endm
1626		1587
1627	.macro biweight_8 macs, macd	1588	.macro biweight_8 macs, macd
1628	vdup.8 d0, r4	1589	vdup.8 d0, r4
1629	vdup.8 d1, r5	1590	vdup.8 d1, r5
1630	vmov q1, q8	1591	vmov q1, q8
@@ -1652,9 +1613,9 @@ endfunc · 21 unmodified lines
1652	vst1.8 {d4},[r6,:64], r2	1613	vst1.8 {d4},[r6,:64], r2
1653	bne 1b	1614	bne 1b
1654	pop {r4-r6, pc}	1615	pop {r4-r6, pc}
1655	.endm	1616	.endm
1656		1617
1657	.macro biweight_4 macs, macd	1618	.macro biweight_4 macs, macd
1658	vdup.8 d0, r4	1619	vdup.8 d0, r4
1659	vdup.8 d1, r5	1620	vdup.8 d1, r5
1660	vmov q1, q8	1621	vmov q1, q8
@@ -1694,9 +1655,9 @@ endfunc · 33 unmodified lines
1694	vst1.32 {d2[0]},[r6,:32], r2	1655	vst1.32 {d2[0]},[r6,:32], r2
1695	vst1.32 {d2[1]},[r6,:32], r2	1656	vst1.32 {d2[1]},[r6,:32], r2
1696	pop {r4-r6, pc}	1657	pop {r4-r6, pc}
1697	.endm	1658	.endm
1698		1659
1699	.macro biweight_func w	1660	.macro biweight_func w
1700	function ff_biweight_h264_pixels_\w\()_neon, export=1	1661	function ff_biweight_h264_pixels_\w\()_neon, export=1
1701	push {r4-r6, lr}	1662	push {r4-r6, lr}
1702	ldr r12, [sp, #16]	1663	ldr r12, [sp, #16]
@@ -1726,7 +1687,7 @@ function ff_biweight_h264_pixels_\w\()_neon, export=1 · 23 unmodified lines
1726	40: rsb r5, r5, #0	1687	40: rsb r5, r5, #0
1727	biweight_\w vmlsl.u8, vmlal.u8	1688	biweight_\w vmlsl.u8, vmlal.u8
1728	endfunc	1689	endfunc
1729	.endm	1690	.endm
1730		1691
1731	biweight_func 16	1692	biweight_func 16
1732	biweight_func 8	1693	biweight_func 8
@@ -1734,7 +1695,7 @@ endfunc · 1 unmodified line
1734		1695
1735	@ Weighted prediction	1696	@ Weighted prediction
1736		1697
1737	.macro weight_16 add	1698	.macro weight_16 add
1738	vdup.8 d0, r12	1699	vdup.8 d0, r12
1739	1: subs r2, r2, #2	1700	1: subs r2, r2, #2
1740	vld1.8 {d20-d21},[r0,:128], r1	1701	vld1.8 {d20-d21},[r0,:128], r1
@@ -1761,9 +1722,9 @@ endfunc · 20 unmodified lines
1761	vst1.8 {d24-d25},[r4,:128], r1	1722	vst1.8 {d24-d25},[r4,:128], r1
1762	bne 1b	1723	bne 1b
1763	pop {r4, pc}	1724	pop {r4, pc}
1764	.endm	1725	.endm
1765		1726
1766	.macro weight_8 add	1727	.macro weight_8 add
1767	vdup.8 d0, r12	1728	vdup.8 d0, r12
1768	1: subs r2, r2, #2	1729	1: subs r2, r2, #2
1769	vld1.8 {d4},[r0,:64], r1	1730	vld1.8 {d4},[r0,:64], r1
@@ -1782,9 +1743,9 @@ endfunc · 12 unmodified lines
1782	vst1.8 {d4},[r4,:64], r1	1743	vst1.8 {d4},[r4,:64], r1
1783	bne 1b	1744	bne 1b
1784	pop {r4, pc}	1745	pop {r4, pc}
1785	.endm	1746	.endm
1786		1747
1787	.macro weight_4 add	1748	.macro weight_4 add
1788	vdup.8 d0, r12	1749	vdup.8 d0, r12
1789	vmov q1, q8	1750	vmov q1, q8
1790	vmov q10, q8	1751	vmov q10, q8
@@ -1818,9 +1779,9 @@ endfunc · 27 unmodified lines
1818	vst1.32 {d2[0]},[r4,:32], r1	1779	vst1.32 {d2[0]},[r4,:32], r1
1819	vst1.32 {d2[1]},[r4,:32], r1	1780	vst1.32 {d2[1]},[r4,:32], r1
1820	pop {r4, pc}	1781	pop {r4, pc}
1821	.endm	1782	.endm
1822		1783
1823	.macro weight_func w	1784	.macro weight_func w
1824	function ff_weight_h264_pixels_\w\()_neon, export=1	1785	function ff_weight_h264_pixels_\w\()_neon, export=1
1825	push {r4, lr}	1786	push {r4, lr}
1826	ldr r12, [sp, #8]	1787	ldr r12, [sp, #8]
@@ -1845,7 +1806,7 @@ function ff_weight_h264_pixels_\w\()_neon, export=1 · 18 unmodified lines
1845	10: rsb r12, r12, #0	1806	10: rsb r12, r12, #0
1846	weight_\w vsub.s16	1807	weight_\w vsub.s16
1847	endfunc	1808	endfunc
1848	.endm	1809	.endm
1849		1810
1850	weight_func 16	1811	weight_func 16
1851	weight_func 8	1812	weight_func 8

libavcodec/arm/neon.S+59−0

@@ -0,0 +1,59 @@
	1	/*
	2	* Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
	3	*
	4	* This file is part of Libav.
	5	*
	6	* Libav is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2.1 of the License, or (at your option) any later version.
	10	*
	11	* Libav is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public
	17	* License along with Libav; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20
	21	.macro transpose_8x8 r0, r1, r2, r3, r4, r5, r6, r7
	22	vtrn.32 \r0, \r4
	23	vtrn.32 \r1, \r5
	24	vtrn.32 \r2, \r6
	25	vtrn.32 \r3, \r7
	26	vtrn.16 \r0, \r2
	27	vtrn.16 \r1, \r3
	28	vtrn.16 \r4, \r6
	29	vtrn.16 \r5, \r7
	30	vtrn.8 \r0, \r1
	31	vtrn.8 \r2, \r3
	32	vtrn.8 \r4, \r5
	33	vtrn.8 \r6, \r7
	34	.endm
	35
	36	.macro transpose_4x4 r0, r1, r2, r3
	37	vtrn.16 \r0, \r2
	38	vtrn.16 \r1, \r3
	39	vtrn.8 \r0, \r1
	40	vtrn.8 \r2, \r3
	41	.endm
	42
	43	.macro swap4 r0, r1, r2, r3, r4, r5, r6, r7
	44	vswp \r0, \r4
	45	vswp \r1, \r5
	46	vswp \r2, \r6
	47	vswp \r3, \r7
	48	.endm
	49
	50	.macro transpose16_4x4 r0, r1, r2, r3, r4, r5, r6, r7
	51	vtrn.32 \r0, \r2
	52	vtrn.32 \r1, \r3
	53	vtrn.32 \r4, \r6
	54	vtrn.32 \r5, \r7
	55	vtrn.16 \r0, \r1
	56	vtrn.16 \r2, \r3
	57	vtrn.16 \r4, \r5
	58	vtrn.16 \r6, \r7
	59	.endm

libavcodec/arm/vp8dsp_neon.S+5−21

  */
 #include "asm.S"
+#include "neon.S"
 function ff_vp8_luma_dc_wht_neon, export=1
         vld1.16         {q0-q1},  [r1,:128]
     .endif
 .endm
-.macro transpose8x16matrix
-        vtrn.32         q0,   q4
-        vtrn.32         q1,   q5
-        vtrn.32         q2,   q6
-        vtrn.32         q3,   q7
-        vtrn.16         q0,   q2
-        vtrn.16         q1,   q3
-        vtrn.16         q4,   q6
-        vtrn.16         q5,   q7
-        vtrn.8          q0,   q1
-        vtrn.8          q2,   q3
-        vtrn.8          q4,   q5
-        vtrn.8          q6,   q7
-.endm
 .macro  vp8_v_loop_filter16 name, inner=0, simple=0
 function ff_vp8_v_loop_filter16\name\()_neon, export=1
         vpush           {q4-q7}
         vld1.8          {d13},    [r0], r1
         vld1.8          {d15},    [r0], r1
-        transpose8x16matrix
+        transpose_8x8   q0,  q1,  q2,  q3,  q4,  q5,  q6,  q7
         vdup.8          q14, r2                 @ flim_E
     .if !\simple
         sub             r0,  r0,  r1, lsl #4    @ backup 16 rows
-        transpose8x16matrix
+        transpose_8x8   q0,  q1,  q2,  q3,  q4,  q5,  q6,  q7
         @ Store pixels:
         vst1.8          {d0},     [r0],     r1
         vld1.8          {d14},    [r0], r2
         vld1.8          {d15},    [r1], r2
-        transpose8x16matrix
+        transpose_8x8   q0,  q1,  q2,  q3,  q4,  q5,  q6,  q7
         vdup.8          q14, r3                 @ flim_E
         vdup.8          q15, r12                @ flim_I
         sub             r0,  r0,  r2, lsl #3    @ backup u 8 rows
         sub             r1,  r1,  r2, lsl #3    @ backup v 8 rows
-        transpose8x16matrix
+        transpose_8x8   q0,  q1,  q2,  q3,  q4,  q5,  q6,  q7
         @ Store pixels:
         vst1.8          {d0},     [r0], r2

libavcodec/atrac1.c+17−9

  * The atrac1 context, holds all needed parameters for decoding
  */
 typedef struct {
+    AVFrame frame;
     AT1SUCtx            SUs[AT1_MAX_CHANNELS];              ///< channel sound unit
     DECLARE_ALIGNED(32, float, spec)[AT1_SU_SAMPLES];      ///< the mdct spectrum buffer
 static int atrac1_decode_frame(AVCodecContext *avctx, void *data,
-                               int *data_size, AVPacket *avpkt)
+                               int *got_frame_ptr, AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size       = avpkt->size;
     AT1Ctx *q          = avctx->priv_data;
-    int ch, ret, out_size;
+    int ch, ret;
     GetBitContext gb;
-    float* samples = data;
+    float *samples;
     if (buf_size < 212 * q->channels) {
         return AVERROR_INVALIDDATA;
     }
-    out_size = q->channels * AT1_SU_SAMPLES *
+    /* get output buffer */
-               av_get_bytes_per_sample(avctx->sample_fmt);
+    q->frame.nb_samples = AT1_SU_SAMPLES;
-    if (*data_size < out_size) {
+    if ((ret = avctx->get_buffer(avctx, &q->frame)) < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-        return AVERROR(EINVAL);
+        return ret;
     }
+    samples = (float *)q->frame.data[0];
     for (ch = 0; ch < q->channels; ch++) {
         AT1SUCtx* su = &q->SUs[ch];
                                      AT1_SU_SAMPLES, 2);
     }
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = q->frame;
     return avctx->block_align;
 }
     q->SUs[1].spectrum[0] = q->SUs[1].spec1;
     q->SUs[1].spectrum[1] = q->SUs[1].spec2;
+    avcodec_get_frame_defaults(&q->frame);
+    avctx->coded_frame = &q->frame;
     return 0;
 }
     .init = atrac1_decode_init,
     .close = atrac1_decode_end,
     .decode = atrac1_decode_frame,
+    .capabilities = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Atrac 1 (Adaptive TRansform Acoustic Coding)"),
 };

libavcodec/atrac3.c+21−13

@@ -86,6 +86,7 @@ typedef struct { · 85 unmodified lines
86	} channel_unit;	86	} channel_unit;
87		87
88	typedef struct {	88	typedef struct {
		89	AVFrame frame;
89	GetBitContext gb;	90	GetBitContext gb;
90	//@{	91	//@{
91	/** stream data */	92	/** stream data */
@@ -823,16 +824,16 @@ static int decodeFrame(ATRAC3Context q, const uint8_t databuf, · 731 unmodified lines
823	* @param avctx pointer to the AVCodecContext	824	* @param avctx pointer to the AVCodecContext
824	*/	825	*/
825		826
826	static int atrac3_decode_frame(AVCodecContext *avctx,	827	static int atrac3_decode_frame(AVCodecContext avctx, void data,
827	void data, int data_size,	828	int got_frame_ptr, AVPacket avpkt)
828	AVPacket *avpkt) {	829	{
829	const uint8_t *buf = avpkt->data;	830	const uint8_t *buf = avpkt->data;
830	int buf_size = avpkt->size;	831	int buf_size = avpkt->size;
831	ATRAC3Context *q = avctx->priv_data;	832	ATRAC3Context *q = avctx->priv_data;
832	int result = 0, out_size;	833	int result;
833	const uint8_t* databuf;	834	const uint8_t* databuf;
834	float *samples_flt = data;	835	float *samples_flt;
835	int16_t *samples_s16 = data;	836	int16_t *samples_s16;
836		837
837	if (buf_size < avctx->block_align) {	838	if (buf_size < avctx->block_align) {
838	av_log(avctx, AV_LOG_ERROR,	839	av_log(avctx, AV_LOG_ERROR,
@@ -840,12 +841,14 @@ static int atrac3_decode_frame(AVCodecContext *avctx, · 1 unmodified line
840	return AVERROR_INVALIDDATA;	841	return AVERROR_INVALIDDATA;
841	}	842	}
842		843
843	out_size = SAMPLES_PER_FRAME * q->channels *	844	/* get output buffer */
844	av_get_bytes_per_sample(avctx->sample_fmt);	845	q->frame.nb_samples = SAMPLES_PER_FRAME;
845	if (*data_size < out_size) {	846	if ((result = avctx->get_buffer(avctx, &q->frame)) < 0) {
846	av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");	847	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
847	return AVERROR(EINVAL);	848	return result;
848	}	849	}
		850	samples_flt = (float *)q->frame.data[0];
		851	samples_s16 = (int16_t *)q->frame.data[0];
849		852
850	/* Check if we need to descramble and what buffer to pass on. */	853	/* Check if we need to descramble and what buffer to pass on. */
851	if (q->scrambled_stream) {	854	if (q->scrambled_stream) {
@@ -875,7 +878,9 @@ static int atrac3_decode_frame(AVCodecContext *avctx, · 23 unmodified lines
875	(const float **)q->outSamples,	878	(const float **)q->outSamples,
876	SAMPLES_PER_FRAME, q->channels);	879	SAMPLES_PER_FRAME, q->channels);
877	}	880	}
878	*data_size = out_size;	881
		882	*got_frame_ptr = 1;
		883	(AVFrame )data = q->frame;
879		884
880	return avctx->block_align;	885	return avctx->block_align;
881	}	886	}
@@ -1047,6 +1052,9 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx) · 165 unmodified lines
1047	}	1052	}
1048	}	1053	}
1049		1054
		1055	avcodec_get_frame_defaults(&q->frame);
		1056	avctx->coded_frame = &q->frame;
		1057
1050	return 0;	1058	return 0;
1051	}	1059	}
1052		1060
@@ -1060,6 +1068,6 @@ AVCodec ff_atrac3_decoder = · 7 unmodified lines
1060	.init = atrac3_decode_init,	1068	.init = atrac3_decode_init,
1061	.close = atrac3_decode_close,	1069	.close = atrac3_decode_close,
1062	.decode = atrac3_decode_frame,	1070	.decode = atrac3_decode_frame,
1063	.capabilities = CODEC_CAP_SUBFRAMES,	1071	.capabilities = CODEC_CAP_SUBFRAMES \| CODEC_CAP_DR1,
1064	.long_name = NULL_IF_CONFIG_SMALL("Atrac 3 (Adaptive TRansform Acoustic Coding 3)"),	1072	.long_name = NULL_IF_CONFIG_SMALL("Atrac 3 (Adaptive TRansform Acoustic Coding 3)"),
1065	};	1073	};

libavcodec/avcodec.h+149−19

@@ -491,8 +491,10 @@ enum CodecID { · 490 unmodified lines
491	#define CH_LAYOUT_STEREO_DOWNMIX AV_CH_LAYOUT_STEREO_DOWNMIX	491	#define CH_LAYOUT_STEREO_DOWNMIX AV_CH_LAYOUT_STEREO_DOWNMIX
492	#endif	492	#endif
493		493
		494	#if FF_API_OLD_DECODE_AUDIO
494	/* in bytes */	495	/* in bytes */
495	#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio	496	#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio
		497	#endif
496		498
497	/**	499	/**
498	* Required number of additionally allocated bytes at the end of the input bitstream for decoding.	500	* Required number of additionally allocated bytes at the end of the input bitstream for decoding.
@@ -947,21 +949,37 @@ typedef struct AVPacket { · 448 unmodified lines
947	* sizeof(AVFrame) must not be used outside libav*.	949	* sizeof(AVFrame) must not be used outside libav*.
948	*/	950	*/
949	typedef struct AVFrame {	951	typedef struct AVFrame {
		952	#if FF_API_DATA_POINTERS
		953	#define AV_NUM_DATA_POINTERS 4
		954	#else
		955	#define AV_NUM_DATA_POINTERS 8
		956	#endif
950	/**	957	/**
951	* pointer to the picture planes.	958	* pointer to the picture/channel planes.
952	* This might be different from the first allocated byte	959	* This might be different from the first allocated byte
953	* - encoding:	960	* - encoding: Set by user
954	* - decoding:	961	* - decoding: set by AVCodecContext.get_buffer()
		962	*/
		963	uint8_t *data[AV_NUM_DATA_POINTERS];
		964
		965	/**
		966	* Size, in bytes, of the data for each picture/channel plane.
		967	*
		968	* For audio, only linesize[0] may be set. For planar audio, each channel
		969	* plane must be the same size.
		970	*
		971	* - encoding: Set by user (video only)
		972	* - decoding: set by AVCodecContext.get_buffer()
955	*/	973	*/
956	uint8_t *data[4];	974	int linesize[AV_NUM_DATA_POINTERS];
957	int linesize[4];	975
958	/**	976	/**
959	* pointer to the first allocated byte of the picture. Can be used in get_buffer/release_buffer.	977	* pointer to the first allocated byte of the picture. Can be used in get_buffer/release_buffer.
960	* This isn't used by libavcodec unless the default get/release_buffer() is used.	978	* This isn't used by libavcodec unless the default get/release_buffer() is used.
961	* - encoding:	979	* - encoding:
962	* - decoding:	980	* - decoding:
963	*/	981	*/
964	uint8_t *base[4];	982	uint8_t *base[AV_NUM_DATA_POINTERS];
965	/**	983	/**
966	* 1 -> keyframe, 0-> not	984	* 1 -> keyframe, 0-> not
967	* - encoding: Set by libavcodec.	985	* - encoding: Set by libavcodec.
@@ -1008,7 +1026,7 @@ typedef struct AVFrame { · 40 unmodified lines
1008	* buffer age (1->was last buffer and dint change, 2->..., ...).	1026	* buffer age (1->was last buffer and dint change, 2->..., ...).
1009	* Set to INT_MAX if the buffer has not been used yet.	1027	* Set to INT_MAX if the buffer has not been used yet.
1010	* - encoding: unused	1028	* - encoding: unused
1011	* - decoding: MUST be set by get_buffer().	1029	* - decoding: MUST be set by get_buffer() for video.
1012	*/	1030	*/
1013	int age;	1031	int age;
1014		1032
@@ -1085,7 +1103,7 @@ typedef struct AVFrame { · 70 unmodified lines
1085	* - encoding: Set by libavcodec. if flags&CODEC_FLAG_PSNR.	1103	* - encoding: Set by libavcodec. if flags&CODEC_FLAG_PSNR.
1086	* - decoding: unused	1104	* - decoding: unused
1087	*/	1105	*/
1088	uint64_t error[4];	1106	uint64_t error[AV_NUM_DATA_POINTERS];
1089		1107
1090	/**	1108	/**
1091	* type of the buffer (to keep track of who has to deallocate data[*])	1109	* type of the buffer (to keep track of who has to deallocate data[*])
@@ -1206,6 +1224,33 @@ typedef struct AVFrame { · 114 unmodified lines
1206	*/	1224	*/
1207	void *thread_opaque;	1225	void *thread_opaque;
1208		1226
		1227	/**
		1228	* number of audio samples (per channel) described by this frame
		1229	* - encoding: unused
		1230	* - decoding: Set by libavcodec
		1231	*/
		1232	int nb_samples;
		1233
		1234	/**
		1235	* pointers to the data planes/channels.
		1236	*
		1237	* For video, this should simply point to data[].
		1238	*
		1239	* For planar audio, each channel has a separate data pointer, and
		1240	* linesize[0] contains the size of each channel buffer.
		1241	* For packed audio, there is just one data pointer, and linesize[0]
		1242	* contains the total size of the buffer for all channels.
		1243	*
		1244	* Note: Both data and extended_data will always be set by get_buffer(),
		1245	* but for planar audio with more channels that can fit in data,
		1246	* extended_data must be used by the decoder in order to access all
		1247	* channels.
		1248	*
		1249	* encoding: unused
		1250	* decoding: set by AVCodecContext.get_buffer()
		1251	*/
		1252	uint8_t **extended_data;
		1253
1209	/**	1254	/**
1210	* frame timestamp estimated using various heuristics, in stream time base	1255	* frame timestamp estimated using various heuristics, in stream time base
1211	* - encoding: unused	1256	* - encoding: unused
@@ -1379,7 +1424,7 @@ typedef struct AVCodecContext { · 167 unmodified lines
1379	* @param offset offset into the AVFrame.data from which the slice should be read	1424	* @param offset offset into the AVFrame.data from which the slice should be read
1380	*/	1425	*/
1381	void (draw_horiz_band)(struct AVCodecContext s,	1426	void (draw_horiz_band)(struct AVCodecContext s,
1382	const AVFrame *src, int offset[4],	1427	const AVFrame *src, int offset[AV_NUM_DATA_POINTERS],
1383	int y, int type, int height);	1428	int y, int type, int height);
1384		1429
1385	/* audio only */	1430	/* audio only */
@@ -1602,15 +1647,56 @@ typedef struct AVCodecContext { · 216 unmodified lines
1602		1647
1603	/**	1648	/**
1604	* Called at the beginning of each frame to get a buffer for it.	1649	* Called at the beginning of each frame to get a buffer for it.
1605	* If pic.reference is set then the frame will be read later by libavcodec.	1650	*
1606	* avcodec_align_dimensions2() should be used to find the required width and	1651	* The function will set AVFrame.data[], AVFrame.linesize[].
1607	* height, as they normally need to be rounded up to the next multiple of 16.	1652	* AVFrame.extended_data[] must also be set, but it should be the same as
		1653	* AVFrame.data[] except for planar audio with more channels than can fit
		1654	* in AVFrame.data[]. In that case, AVFrame.data[] shall still contain as
		1655	* many data pointers as it can hold.
		1656	*
1608	* if CODEC_CAP_DR1 is not set then get_buffer() must call	1657	* if CODEC_CAP_DR1 is not set then get_buffer() must call
1609	* avcodec_default_get_buffer() instead of providing buffers allocated by	1658	* avcodec_default_get_buffer() instead of providing buffers allocated by
1610	* some other means.	1659	* some other means.
		1660	*
		1661	* AVFrame.data[] should be 32- or 16-byte-aligned unless the CPU doesn't
		1662	* need it. avcodec_default_get_buffer() aligns the output buffer properly,
		1663	* but if get_buffer() is overridden then alignment considerations should
		1664	* be taken into account.
		1665	*
		1666	* @see avcodec_default_get_buffer()
		1667	*
		1668	* Video:
		1669	*
		1670	* If pic.reference is set then the frame will be read later by libavcodec.
		1671	* avcodec_align_dimensions2() should be used to find the required width and
		1672	* height, as they normally need to be rounded up to the next multiple of 16.
		1673	*
1611	* If frame multithreading is used and thread_safe_callbacks is set,	1674	* If frame multithreading is used and thread_safe_callbacks is set,
1612	* it may be called from a different thread, but not from more than one at once.	1675	* it may be called from a different thread, but not from more than one at
1613	* Does not need to be reentrant.	1676	* once. Does not need to be reentrant.
		1677	*
		1678	* @see release_buffer(), reget_buffer()
		1679	* @see avcodec_align_dimensions2()
		1680	*
		1681	* Audio:
		1682	*
		1683	* Decoders request a buffer of a particular size by setting
		1684	* AVFrame.nb_samples prior to calling get_buffer(). The decoder may,
		1685	* however, utilize only part of the buffer by setting AVFrame.nb_samples
		1686	* to a smaller value in the output frame.
		1687	*
		1688	* Decoders cannot use the buffer after returning from
		1689	* avcodec_decode_audio4(), so they will not call release_buffer(), as it
		1690	* is assumed to be released immediately upon return.
		1691	*
		1692	* As a convenience, av_samples_get_buffer_size() and
		1693	* av_samples_fill_arrays() in libavutil may be used by custom get_buffer()
		1694	* functions to find the required data size and to fill data pointers and
		1695	* linesize. In AVFrame.linesize, only linesize[0] may be set for audio
		1696	* since all planes must be the same size.
		1697	*
		1698	* @see av_samples_get_buffer_size(), av_samples_fill_arrays()
		1699	*
1614	* - encoding: unused	1700	* - encoding: unused
1615	* - decoding: Set by libavcodec, user can override.	1701	* - decoding: Set by libavcodec, user can override.
1616	*/	1702	*/
@@ -1929,7 +2015,7 @@ typedef struct AVCodecContext { · 312 unmodified lines
1929	* - encoding: Set by libavcodec if flags&CODEC_FLAG_PSNR.	2015	* - encoding: Set by libavcodec if flags&CODEC_FLAG_PSNR.
1930	* - decoding: unused	2016	* - decoding: unused
1931	*/	2017	*/
1932	uint64_t error[4];	2018	uint64_t error[AV_NUM_DATA_POINTERS];
1933		2019
1934	/**	2020	/**
1935	* motion estimation comparison function	2021	* motion estimation comparison function
@@ -3253,8 +3339,8 @@ typedef struct AVHWAccel { · 1317 unmodified lines
3253	* the last component is alpha	3339	* the last component is alpha
3254	*/	3340	*/
3255	typedef struct AVPicture {	3341	typedef struct AVPicture {
3256	uint8_t *data[4];	3342	uint8_t *data[AV_NUM_DATA_POINTERS];
3257	int linesize[4]; ///< number of bytes per line	3343	int linesize[AV_NUM_DATA_POINTERS]; ///< number of bytes per line
3258	} AVPicture;	3344	} AVPicture;
3259		3345
3260	#define AVPALETTE_SIZE 1024	3346	#define AVPALETTE_SIZE 1024
@@ -3922,7 +4008,7 @@ void avcodec_align_dimensions(AVCodecContext s, int width, int *height); · 661 unmodified lines
3922	* according to avcodec_get_edge_width() before.	4008	* according to avcodec_get_edge_width() before.
3923	*/	4009	*/
3924	void avcodec_align_dimensions2(AVCodecContext s, int width, int *height,	4010	void avcodec_align_dimensions2(AVCodecContext s, int width, int *height,
3925	int linesize_align[4]);	4011	int linesize_align[AV_NUM_DATA_POINTERS]);
3926		4012
3927	enum PixelFormat avcodec_default_get_format(struct AVCodecContext s, const enum PixelFormat fmt);	4013	enum PixelFormat avcodec_default_get_format(struct AVCodecContext s, const enum PixelFormat fmt);
3928		4014
@@ -4005,7 +4091,12 @@ int avcodec_open(AVCodecContext avctx, AVCodec codec); · 76 unmodified lines
4005	*/	4091	*/
4006	int avcodec_open2(AVCodecContext avctx, AVCodec codec, AVDictionary **options);	4092	int avcodec_open2(AVCodecContext avctx, AVCodec codec, AVDictionary **options);
4007		4093
		4094	#if FF_API_OLD_DECODE_AUDIO
4008	/**	4095	/**
		4096	* Wrapper function which calls avcodec_decode_audio4.
		4097	*
		4098	* @deprecated Use avcodec_decode_audio4 instead.
		4099	*
4009	* Decode the audio frame of size avpkt->size from avpkt->data into samples.	4100	* Decode the audio frame of size avpkt->size from avpkt->data into samples.
4010	* Some decoders may support multiple frames in a single AVPacket, such	4101	* Some decoders may support multiple frames in a single AVPacket, such
4011	* decoders would then just decode the first frame. In this case,	4102	* decoders would then just decode the first frame. In this case,
@@ -4040,6 +4131,8 @@ int avcodec_open2(AVCodecContext avctx, AVCodec codec, AVDictionary **options) · 28 unmodified lines
4040	*	4131	*
4041	* @param avctx the codec context	4132	* @param avctx the codec context
4042	* @param[out] samples the output buffer, sample type in avctx->sample_fmt	4133	* @param[out] samples the output buffer, sample type in avctx->sample_fmt
		4134	* If the sample format is planar, each channel plane will
		4135	* be the same size, with no padding between channels.
4043	* @param[in,out] frame_size_ptr the output buffer size in bytes	4136	* @param[in,out] frame_size_ptr the output buffer size in bytes
4044	* @param[in] avpkt The input AVPacket containing the input buffer.	4137	* @param[in] avpkt The input AVPacket containing the input buffer.
4045	* You can create such packet with av_init_packet() and by then setting	4138	* You can create such packet with av_init_packet() and by then setting
@@ -4048,9 +4141,46 @@ int avcodec_open2(AVCodecContext avctx, AVCodec codec, AVDictionary **options) · 2 unmodified lines
4048	* @return On error a negative value is returned, otherwise the number of bytes	4141	* @return On error a negative value is returned, otherwise the number of bytes
4049	* used or zero if no frame data was decompressed (used) from the input AVPacket.	4142	* used or zero if no frame data was decompressed (used) from the input AVPacket.
4050	*/	4143	*/
4051	int avcodec_decode_audio3(AVCodecContext avctx, int16_t samples,	4144	attribute_deprecated int avcodec_decode_audio3(AVCodecContext avctx, int16_t samples,
4052	int *frame_size_ptr,	4145	int *frame_size_ptr,
4053	AVPacket *avpkt);	4146	AVPacket *avpkt);
		4147	#endif
		4148
		4149	/**
		4150	* Decode the audio frame of size avpkt->size from avpkt->data into frame.
		4151	*
		4152	* Some decoders may support multiple frames in a single AVPacket. Such
		4153	* decoders would then just decode the first frame. In this case,
		4154	* avcodec_decode_audio4 has to be called again with an AVPacket containing
		4155	* the remaining data in order to decode the second frame, etc...
		4156	* Even if no frames are returned, the packet needs to be fed to the decoder
		4157	* with remaining data until it is completely consumed or an error occurs.
		4158	*
		4159	* @warning The input buffer, avpkt->data must be FF_INPUT_BUFFER_PADDING_SIZE
		4160	* larger than the actual read bytes because some optimized bitstream
		4161	* readers read 32 or 64 bits at once and could read over the end.
		4162	*
		4163	* @note You might have to align the input buffer. The alignment requirements
		4164	* depend on the CPU and the decoder.
		4165	*
		4166	* @param avctx the codec context
		4167	* @param[out] frame The AVFrame in which to store decoded audio samples.
		4168	* Decoders request a buffer of a particular size by setting
		4169	* AVFrame.nb_samples prior to calling get_buffer(). The
		4170	* decoder may, however, only utilize part of the buffer by
		4171	* setting AVFrame.nb_samples to a smaller value in the
		4172	* output frame.
		4173	* @param[out] got_frame_ptr Zero if no frame could be decoded, otherwise it is
		4174	* non-zero.
		4175	* @param[in] avpkt The input AVPacket containing the input buffer.
		4176	* At least avpkt->data and avpkt->size should be set. Some
		4177	* decoders might also require additional fields to be set.
		4178	* @return A negative error code is returned if an error occurred during
		4179	* decoding, otherwise the number of bytes consumed from the input
		4180	* AVPacket is returned.
		4181	*/
		4182	int avcodec_decode_audio4(AVCodecContext avctx, AVFrame frame,
		4183	int got_frame_ptr, AVPacket avpkt);
4054		4184
4055	/**	4185	/**
4056	* Decode the video frame of size avpkt->size from avpkt->data into picture.	4186	* Decode the video frame of size avpkt->size from avpkt->data into picture.

libavcodec/binkaudio.c+21−13

 #define BINK_BLOCK_MAX_SIZE (MAX_CHANNELS << 11)
 typedef struct {
+    AVFrame frame;
     GetBitContext gb;
     DSPContext dsp;
     FmtConvertContext fmt_conv;
     else
         return -1;
+    avcodec_get_frame_defaults(&s->frame);
+    avctx->coded_frame = &s->frame;
     return 0;
 }
         ff_rdft_end(&s->trans.rdft);
     else if (CONFIG_BINKAUDIO_DCT_DECODER)
         ff_dct_end(&s->trans.dct);
     return 0;
 }
     if (n) skip_bits(s, n);
 }
-static int decode_frame(AVCodecContext *avctx,
+static int decode_frame(AVCodecContext *avctx, void *data,
-                        void *data, int *data_size,
+                        int *got_frame_ptr, AVPacket *avpkt)
-                        AVPacket *avpkt)
 {
     BinkAudioContext *s = avctx->priv_data;
-    int16_t *samples      = data;
+    int16_t *samples;
     GetBitContext *gb = &s->gb;
-    int out_size, consumed = 0;
+    int ret, consumed = 0;
     if (!get_bits_left(gb)) {
         uint8_t *buf;
         /* handle end-of-stream */
         if (!avpkt->size) {
-            *data_size = 0;
+            *got_frame_ptr = 0;
             return 0;
         }
         if (avpkt->size < 4) {
         skip_bits_long(gb, 32);
     }
-    out_size = s->block_size * av_get_bytes_per_sample(avctx->sample_fmt);
+    /* get output buffer */
-    if (*data_size < out_size) {
+    s->frame.nb_samples = s->block_size / avctx->channels;
-        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
+    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
-        return AVERROR(EINVAL);
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        return ret;
     }
+    samples = (int16_t *)s->frame.data[0];
     if (decode_block(s, samples, avctx->codec->id == CODEC_ID_BINKAUDIO_DCT)) {
         av_log(avctx, AV_LOG_ERROR, "Incomplete packet\n");
     }
     get_bits_align32(gb);
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = s->frame;
     return consumed;
 }
     .init           = decode_init,
     .close          = decode_end,
     .decode         = decode_frame,
-    .capabilities   = CODEC_CAP_DELAY,
+    .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)")
 };
     .init           = decode_init,
     .close          = decode_end,
     .decode         = decode_frame,
-    .capabilities   = CODEC_CAP_DELAY,
+    .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (DCT)")
 };

libavcodec/cook.c+30−13

     void (* saturate_output) (struct cook *q, int chan, float *out);
     AVCodecContext*     avctx;
+    AVFrame             frame;
     GetBitContext       gb;
     /* stream data */
     int                 nb_channels;
     int                 samples_per_channel;
     /* states */
     AVLFG               random_state;
+    int                 discarded_packets;
     /* transform data */
     FFTContext          mdct_ctx;
                       float *out, int chan)
 {
     imlt_gain(q, decode_buffer, gains_ptr, previous_buffer);
-    q->saturate_output (q, chan, out);
+    if (out)
+        q->saturate_output(q, chan, out);
 }
  * @param avctx     pointer to the AVCodecContext
  */
-static int cook_decode_frame(AVCodecContext *avctx,
+static int cook_decode_frame(AVCodecContext *avctx, void *data,
-            void *data, int *data_size,
+                             int *got_frame_ptr, AVPacket *avpkt)
-            AVPacket *avpkt) {
+{
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     COOKContext *q = avctx->priv_data;
-    int i, out_size;
+    float *samples = NULL;
+    int i, ret;
     int offset = 0;
     int chidx = 0;
     if (buf_size < avctx->block_align)
         return buf_size;
-    out_size = q->nb_channels * q->samples_per_channel *
+    /* get output buffer */
-               av_get_bytes_per_sample(avctx->sample_fmt);
+    if (q->discarded_packets >= 2) {
-    if (*data_size < out_size) {
+        q->frame.nb_samples = q->samples_per_channel;
-        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
+        if ((ret = avctx->get_buffer(avctx, &q->frame)) < 0) {
-        return AVERROR(EINVAL);
+            av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+            return ret;
+        }
+        samples = (float *)q->frame.data[0];
     }
     /* estimate subpacket sizes */
         q->subpacket[i].bits_per_subpacket = (q->subpacket[i].size*8)>>q->subpacket[i].bits_per_subpdiv;
         q->subpacket[i].ch_idx = chidx;
         av_log(avctx,AV_LOG_DEBUG,"subpacket[%i] size %i js %i %i block_align %i\n",i,q->subpacket[i].size,q->subpacket[i].joint_stereo,offset,avctx->block_align);
-        decode_subpacket(q, &q->subpacket[i], buf + offset, data);
+        decode_subpacket(q, &q->subpacket[i], buf + offset, samples);
         offset += q->subpacket[i].size;
         chidx += q->subpacket[i].num_channels;
         av_log(avctx,AV_LOG_DEBUG,"subpacket[%i] %i %i\n",i,q->subpacket[i].size * 8,get_bits_count(&q->gb));
     }
-    *data_size = out_size;
     /* Discard the first two frames: no valid audio. */
-    if (avctx->frame_number < 2) *data_size = 0;
+    if (q->discarded_packets < 2) {
+        q->discarded_packets++;
+        *got_frame_ptr = 0;
+        return avctx->block_align;
+    }
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = q->frame;
     return avctx->block_align;
 }
     else
         avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
+    avcodec_get_frame_defaults(&q->frame);
+    avctx->coded_frame = &q->frame;
 #ifdef DEBUG
     dump_cook_context(q);
 #endif
     .init = cook_decode_init,
     .close = cook_decode_close,
     .decode = cook_decode_frame,
+    .capabilities = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("COOK"),
 };

libavcodec/dca.c+20−12

 typedef struct {
     AVCodecContext *avctx;
+    AVFrame frame;
     /* Frame header */
     int frame_type;             ///< type of the current frame
     int samples_deficit;        ///< deficit sample count
  * Main frame decoding function
  * FIXME add arguments
  */
-static int dca_decode_frame(AVCodecContext * avctx,
+static int dca_decode_frame(AVCodecContext *avctx, void *data,
-                            void *data, int *data_size,
+                            int *got_frame_ptr, AVPacket *avpkt)
-                            AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     int lfe_samples;
     int num_core_channels = 0;
     int i, ret;
-    float   *samples_flt = data;
+    float   *samples_flt;
-    int16_t *samples_s16 = data;
+    int16_t *samples_s16;
-    int out_size;
     DCAContext *s = avctx->priv_data;
     int channels;
     int core_ss_end;
         avctx->channels = channels;
     }
-    out_size = 256 / 8 * s->sample_blocks * channels *
+    /* get output buffer */
-               av_get_bytes_per_sample(avctx->sample_fmt);
+    s->frame.nb_samples = 256 * (s->sample_blocks / 8);
-    if (*data_size < out_size)
+    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
-        return AVERROR(EINVAL);
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-    *data_size = out_size;
+        return ret;
+    }
+    samples_flt = (float   *)s->frame.data[0];
+    samples_s16 = (int16_t *)s->frame.data[0];
     /* filter to get final output */
     for (i = 0; i < (s->sample_blocks / 8); i++) {
         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
     }
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = s->frame;
     return buf_size;
 }
         avctx->channels = avctx->request_channels;
     }
+    avcodec_get_frame_defaults(&s->frame);
+    avctx->coded_frame = &s->frame;
     return 0;
 }
     .decode = dca_decode_frame,
     .close = dca_decode_end,
     .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
-    .capabilities = CODEC_CAP_CHANNEL_CONF,
+    .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
     .sample_fmts = (const enum AVSampleFormat[]) {
         AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE
     },

libavcodec/dpcm.c+19−9

@@ -42,6 +42,7 @@ · 41 unmodified lines
42	#include "bytestream.h"	42	#include "bytestream.h"
43		43
44	typedef struct DPCMContext {	44	typedef struct DPCMContext {
		45	AVFrame frame;
45	int channels;	46	int channels;
46	int16_t roq_square_array[256];	47	int16_t roq_square_array[256];
47	int sample[2]; ///< previous sample (for SOL_DPCM)	48	int sample[2]; ///< previous sample (for SOL_DPCM)
@@ -162,22 +163,25 @@ static av_cold int dpcm_decode_init(AVCodecContext *avctx) · 114 unmodified lines
162	else	163	else
163	avctx->sample_fmt = AV_SAMPLE_FMT_S16;	164	avctx->sample_fmt = AV_SAMPLE_FMT_S16;
164		165
		166	avcodec_get_frame_defaults(&s->frame);
		167	avctx->coded_frame = &s->frame;
		168
165	return 0;	169	return 0;
166	}	170	}
167		171
168		172
169	static int dpcm_decode_frame(AVCodecContext avctx, void data, int *data_size,	173	static int dpcm_decode_frame(AVCodecContext avctx, void data,
170	AVPacket *avpkt)	174	int got_frame_ptr, AVPacket avpkt)
171	{	175	{
172	const uint8_t *buf = avpkt->data;	176	const uint8_t *buf = avpkt->data;
173	int buf_size = avpkt->size;	177	int buf_size = avpkt->size;
174	const uint8_t *buf_end = buf + buf_size;	178	const uint8_t *buf_end = buf + buf_size;
175	DPCMContext *s = avctx->priv_data;	179	DPCMContext *s = avctx->priv_data;
176	int out = 0;	180	int out = 0, ret;
177	int predictor[2];	181	int predictor[2];
178	int ch = 0;	182	int ch = 0;
179	int stereo = s->channels - 1;	183	int stereo = s->channels - 1;
180	int16_t *output_samples = data;	184	int16_t *output_samples;
181		185
182	/* calculate output size */	186	/* calculate output size */
183	switch(avctx->codec->id) {	187	switch(avctx->codec->id) {
@@ -197,15 +201,18 @@ static int dpcm_decode_frame(AVCodecContext avctx, void data, int *data_size, · 13 unmodified lines
197	out = buf_size;	201	out = buf_size;
198	break;	202	break;
199	}	203	}
200	out *= av_get_bytes_per_sample(avctx->sample_fmt);
201	if (out <= 0) {	204	if (out <= 0) {
202	av_log(avctx, AV_LOG_ERROR, "packet is too small\n");	205	av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
203	return AVERROR(EINVAL);	206	return AVERROR(EINVAL);
204	}	207	}
205	if (*data_size < out) {	208
206	av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");	209	/* get output buffer */
207	return AVERROR(EINVAL);	210	s->frame.nb_samples = out / s->channels;
		211	if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
		212	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		213	return ret;
208	}	214	}
		215	output_samples = (int16_t *)s->frame.data[0];
209		216
210	switch(avctx->codec->id) {	217	switch(avctx->codec->id) {
211		218
@@ -307,7 +314,9 @@ static int dpcm_decode_frame(AVCodecContext avctx, void data, int *data_size, · 95 unmodified lines
307	break;	314	break;
308	}	315	}
309		316
310	*data_size = out;	317	*got_frame_ptr = 1;
		318	(AVFrame )data = s->frame;
		319
311	return buf_size;	320	return buf_size;
312	}	321	}
313		322
@@ -319,6 +328,7 @@ AVCodec ff_ ## name_ ## _decoder = { \ · 5 unmodified lines
319	.priv_data_size = sizeof(DPCMContext), \	328	.priv_data_size = sizeof(DPCMContext), \
320	.init = dpcm_decode_init, \	329	.init = dpcm_decode_init, \
321	.decode = dpcm_decode_frame, \	330	.decode = dpcm_decode_frame, \
		331	.capabilities = CODEC_CAP_DR1, \
322	.long_name = NULL_IF_CONFIG_SMALL(long_name_), \	332	.long_name = NULL_IF_CONFIG_SMALL(long_name_), \
323	}	333	}
324		334

libavcodec/dsicinav.c+18−12

 } CinVideoContext;
 typedef struct CinAudioContext {
+    AVFrame frame;
     int initial_decode_frame;
     int delta;
 } CinAudioContext;
     cin->delta = 0;
     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
+    avcodec_get_frame_defaults(&cin->frame);
+    avctx->coded_frame = &cin->frame;
     return 0;
 }
-static int cinaudio_decode_frame(AVCodecContext *avctx,
+static int cinaudio_decode_frame(AVCodecContext *avctx, void *data,
-                                 void *data, int *data_size,
+                                 int *got_frame_ptr, AVPacket *avpkt)
-                                 AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     CinAudioContext *cin = avctx->priv_data;
     const uint8_t *buf_end = buf + avpkt->size;
-    int16_t *samples = data;
+    int16_t *samples;
-    int delta, out_size;
+    int delta, ret;
-    out_size = (avpkt->size - cin->initial_decode_frame) *
+    /* get output buffer */
-               av_get_bytes_per_sample(avctx->sample_fmt);
+    cin->frame.nb_samples = avpkt->size - cin->initial_decode_frame;
-    if (*data_size < out_size) {
+    if ((ret = avctx->get_buffer(avctx, &cin->frame)) < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-        return AVERROR(EINVAL);
+        return ret;
     }
+    samples = (int16_t *)cin->frame.data[0];
     delta = cin->delta;
     if (cin->initial_decode_frame) {
     }
     cin->delta = delta;
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = cin->frame;
     return avpkt->size;
 }
     .priv_data_size = sizeof(CinAudioContext),
     .init           = cinaudio_decode_init,
     .decode         = cinaudio_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN audio"),
 };

libavcodec/flacdec.c+21−16

     FLACSTREAMINFO
     AVCodecContext *avctx;                  ///< parent AVCodecContext
+    AVFrame frame;
     GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
     int blocksize;                          ///< number of samples in the current frame
     allocate_buffers(s);
     s->got_streaminfo = 1;
+    avcodec_get_frame_defaults(&s->frame);
+    avctx->coded_frame = &s->frame;
     return 0;
 }
     return 0;
 }
-static int flac_decode_frame(AVCodecContext *avctx,
+static int flac_decode_frame(AVCodecContext *avctx, void *data,
-                            void *data, int *data_size,
+                             int *got_frame_ptr, AVPacket *avpkt)
-                            AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     FLACContext *s = avctx->priv_data;
     int i, j = 0, bytes_read = 0;
-    int16_t *samples_16 = data;
+    int16_t *samples_16;
-    int32_t *samples_32 = data;
+    int32_t *samples_32;
-    int alloc_data_size= *data_size;
+    int ret;
-    int output_size;
-    *data_size=0;
+    *got_frame_ptr = 0;
     if (s->max_framesize == 0) {
         s->max_framesize =
     }
     bytes_read = (get_bits_count(&s->gb)+7)/8;
-    /* check if allocated data size is large enough for output */
+    /* get output buffer */
-    output_size = s->blocksize * s->channels *
+    s->frame.nb_samples = s->blocksize;
-                  av_get_bytes_per_sample(avctx->sample_fmt);
+    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
-    if (output_size > alloc_data_size) {
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-        av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
+        return ret;
-                                       "allocated data size\n");
-        return -1;
     }
-    *data_size = output_size;
+    samples_16 = (int16_t *)s->frame.data[0];
+    samples_32 = (int32_t *)s->frame.data[0];
 #define DECORRELATE(left, right)\
             assert(s->channels == 2);\
                buf_size - bytes_read, buf_size);
     }
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = s->frame;
     return bytes_read;
 }
     .init           = flac_decode_init,
     .close          = flac_decode_close,
     .decode         = flac_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 };

libavcodec/g722.h+2−0

 #define AVCODEC_G722_H
 #include <stdint.h>
+#include "avcodec.h"
 #define PREV_SAMPLES_BUF_SIZE 1024
 typedef struct {
+    AVFrame frame;
     int16_t prev_samples[PREV_SAMPLES_BUF_SIZE]; ///< memory of past decoded samples
     int     prev_samples_pos;        ///< the number of values in prev_samples

libavcodec/g722dec.c+17−8

@@ -66,6 +66,9 @@ static av_cold int g722_decode_init(AVCodecContext * avctx) · 65 unmodified lines
66	c->band[1].scale_factor = 2;	66	c->band[1].scale_factor = 2;
67	c->prev_samples_pos = 22;	67	c->prev_samples_pos = 22;
68		68
		69	avcodec_get_frame_defaults(&c->frame);
		70	avctx->coded_frame = &c->frame;
		71
69	return 0;	72	return 0;
70	}	73	}
71		74
@@ -81,20 +84,22 @@ static const int16_t *low_inv_quants[3] = { ff_g722_low_inv_quant6, · 9 unmodified lines
81	ff_g722_low_inv_quant4 };	84	ff_g722_low_inv_quant4 };
82		85
83	static int g722_decode_frame(AVCodecContext avctx, void data,	86	static int g722_decode_frame(AVCodecContext avctx, void data,
84	int data_size, AVPacket avpkt)	87	int got_frame_ptr, AVPacket avpkt)
85	{	88	{
86	G722Context *c = avctx->priv_data;	89	G722Context *c = avctx->priv_data;
87	int16_t *out_buf = data;	90	int16_t *out_buf;
88	int j, out_len;	91	int j, ret;
89	const int skip = 8 - avctx->bits_per_coded_sample;	92	const int skip = 8 - avctx->bits_per_coded_sample;
90	const int16_t *quantizer_table = low_inv_quants[skip];	93	const int16_t *quantizer_table = low_inv_quants[skip];
91	GetBitContext gb;	94	GetBitContext gb;
92		95
93	out_len = avpkt->size * 2 * av_get_bytes_per_sample(avctx->sample_fmt);	96	/* get output buffer */
94	if (*data_size < out_len) {	97	c->frame.nb_samples = avpkt->size * 2;
95	av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");	98	if ((ret = avctx->get_buffer(avctx, &c->frame)) < 0) {
96	return AVERROR(EINVAL);	99	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		100	return ret;
97	}	101	}
		102	out_buf = (int16_t *)c->frame.data[0];
98		103
99	init_get_bits(&gb, avpkt->data, avpkt->size * 8);	104	init_get_bits(&gb, avpkt->data, avpkt->size * 8);
100		105
@@ -128,7 +133,10 @@ static int g722_decode_frame(AVCodecContext avctx, void data, · 27 unmodified lines
128	c->prev_samples_pos = 22;	133	c->prev_samples_pos = 22;
129	}	134	}
130	}	135	}
131	*data_size = out_len;	136
		137	*got_frame_ptr = 1;
		138	(AVFrame )data = c->frame;
		139
132	return avpkt->size;	140	return avpkt->size;
133	}	141	}
134		142
@@ -139,5 +147,6 @@ AVCodec ff_adpcm_g722_decoder = { · 4 unmodified lines
139	.priv_data_size = sizeof(G722Context),	147	.priv_data_size = sizeof(G722Context),
140	.init = g722_decode_init,	148	.init = g722_decode_init,
141	.decode = g722_decode_frame,	149	.decode = g722_decode_frame,
		150	.capabilities = CODEC_CAP_DR1,
142	.long_name = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),	151	.long_name = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),
143	};	152	};

libavcodec/g726.c+19−10

@@ -75,6 +75,7 @@ typedef struct G726Tables { · 74 unmodified lines
75		75
76	typedef struct G726Context {	76	typedef struct G726Context {
77	AVClass *class;	77	AVClass *class;
		78	AVFrame frame;
78	G726Tables tbls; /*< static tables needed for computation /	79	G726Tables tbls; /*< static tables needed for computation /
79		80
80	Float11 sr[2]; /*< prev. reconstructed samples /	81	Float11 sr[2]; /*< prev. reconstructed samples /
@@ -427,26 +428,31 @@ static av_cold int g726_decode_init(AVCodecContext *avctx) · 346 unmodified lines
427		428
428	avctx->sample_fmt = AV_SAMPLE_FMT_S16;	429	avctx->sample_fmt = AV_SAMPLE_FMT_S16;
429		430
		431	avcodec_get_frame_defaults(&c->frame);
		432	avctx->coded_frame = &c->frame;
		433
430	return 0;	434	return 0;
431	}	435	}
432		436
433	static int g726_decode_frame(AVCodecContext *avctx,	437	static int g726_decode_frame(AVCodecContext avctx, void data,
434	void data, int data_size,	438	int got_frame_ptr, AVPacket avpkt)
435	AVPacket *avpkt)
436	{	439	{
437	const uint8_t *buf = avpkt->data;	440	const uint8_t *buf = avpkt->data;
438	int buf_size = avpkt->size;	441	int buf_size = avpkt->size;
439	G726Context *c = avctx->priv_data;	442	G726Context *c = avctx->priv_data;
440	int16_t *samples = data;	443	int16_t *samples;
441	GetBitContext gb;	444	GetBitContext gb;
442	int out_samples, out_size;	445	int out_samples, ret;
443		446
444	out_samples = buf_size * 8 / c->code_size;	447	out_samples = buf_size * 8 / c->code_size;
445	out_size = out_samples * av_get_bytes_per_sample(avctx->sample_fmt);	448
446	if (*data_size < out_size) {	449	/* get output buffer */
447	av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");	450	c->frame.nb_samples = out_samples;
448	return AVERROR(EINVAL);	451	if ((ret = avctx->get_buffer(avctx, &c->frame)) < 0) {
		452	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		453	return ret;
449	}	454	}
		455	samples = (int16_t *)c->frame.data[0];
450		456
451	init_get_bits(&gb, buf, buf_size * 8);	457	init_get_bits(&gb, buf, buf_size * 8);
452		458
@@ -456,7 +462,9 @@ static int g726_decode_frame(AVCodecContext *avctx, · 3 unmodified lines
456	if (get_bits_left(&gb) > 0)	462	if (get_bits_left(&gb) > 0)
457	av_log(avctx, AV_LOG_ERROR, "Frame invalidly split, missing parser?\n");	463	av_log(avctx, AV_LOG_ERROR, "Frame invalidly split, missing parser?\n");
458		464
459	*data_size = out_size;	465	*got_frame_ptr = 1;
		466	(AVFrame )data = c->frame;
		467
460	return buf_size;	468	return buf_size;
461	}	469	}
462		470
@@ -474,6 +482,7 @@ AVCodec ff_adpcm_g726_decoder = { · 11 unmodified lines
474	.init = g726_decode_init,	482	.init = g726_decode_init,
475	.decode = g726_decode_frame,	483	.decode = g726_decode_frame,
476	.flush = g726_decode_flush,	484	.flush = g726_decode_flush,
		485	.capabilities = CODEC_CAP_DR1,
477	.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),	486	.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
478	};	487	};
479	#endif	488	#endif

libavcodec/gsmdec.c+22−10

@@ -32,6 +32,8 @@ · 31 unmodified lines
32		32
33	static av_cold int gsm_init(AVCodecContext *avctx)	33	static av_cold int gsm_init(AVCodecContext *avctx)
34	{	34	{
		35	GSMContext *s = avctx->priv_data;
		36
35	avctx->channels = 1;	37	avctx->channels = 1;
36	if (!avctx->sample_rate)	38	if (!avctx->sample_rate)
37	avctx->sample_rate = 8000;	39	avctx->sample_rate = 8000;
@@ -47,30 +49,35 @@ static av_cold int gsm_init(AVCodecContext *avctx) · 9 unmodified lines
47	avctx->block_align = GSM_MS_BLOCK_SIZE;	49	avctx->block_align = GSM_MS_BLOCK_SIZE;
48	}	50	}
49		51
		52	avcodec_get_frame_defaults(&s->frame);
		53	avctx->coded_frame = &s->frame;
		54
50	return 0;	55	return 0;
51	}	56	}
52		57
53	static int gsm_decode_frame(AVCodecContext avctx, void data,	58	static int gsm_decode_frame(AVCodecContext avctx, void data,
54	int data_size, AVPacket avpkt)	59	int got_frame_ptr, AVPacket avpkt)
55	{	60	{
		61	GSMContext *s = avctx->priv_data;
56	int res;	62	int res;
57	GetBitContext gb;	63	GetBitContext gb;
58	const uint8_t *buf = avpkt->data;	64	const uint8_t *buf = avpkt->data;
59	int buf_size = avpkt->size;	65	int buf_size = avpkt->size;
60	int16_t *samples = data;	66	int16_t *samples;
61	int frame_bytes = avctx->frame_size *
62	av_get_bytes_per_sample(avctx->sample_fmt);
63
64	if (*data_size < frame_bytes) {
65	av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
66	return AVERROR(EINVAL);
67	}
68		67
69	if (buf_size < avctx->block_align) {	68	if (buf_size < avctx->block_align) {
70	av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");	69	av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
71	return AVERROR_INVALIDDATA;	70	return AVERROR_INVALIDDATA;
72	}	71	}
73		72
		73	/* get output buffer */
		74	s->frame.nb_samples = avctx->frame_size;
		75	if ((res = avctx->get_buffer(avctx, &s->frame)) < 0) {
		76	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		77	return res;
		78	}
		79	samples = (int16_t *)s->frame.data[0];
		80
74	switch (avctx->codec_id) {	81	switch (avctx->codec_id) {
75	case CODEC_ID_GSM:	82	case CODEC_ID_GSM:
76	init_get_bits(&gb, buf, buf_size * 8);	83	init_get_bits(&gb, buf, buf_size * 8);
@@ -85,7 +92,10 @@ static int gsm_decode_frame(AVCodecContext avctx, void data, · 8 unmodified lines
85	if (res < 0)	92	if (res < 0)
86	return res;	93	return res;
87	}	94	}
88	*data_size = frame_bytes;	95
		96	*got_frame_ptr = 1;
		97	(AVFrame )data = s->frame;
		98
89	return avctx->block_align;	99	return avctx->block_align;
90	}	100	}
91		101
@@ -103,6 +113,7 @@ AVCodec ff_gsm_decoder = { · 11 unmodified lines
103	.init = gsm_init,	113	.init = gsm_init,
104	.decode = gsm_decode_frame,	114	.decode = gsm_decode_frame,
105	.flush = gsm_flush,	115	.flush = gsm_flush,
		116	.capabilities = CODEC_CAP_DR1,
106	.long_name = NULL_IF_CONFIG_SMALL("GSM"),	117	.long_name = NULL_IF_CONFIG_SMALL("GSM"),
107	};	118	};
108		119
@@ -114,5 +125,6 @@ AVCodec ff_gsm_ms_decoder = { · 5 unmodified lines
114	.init = gsm_init,	125	.init = gsm_init,
115	.decode = gsm_decode_frame,	126	.decode = gsm_decode_frame,
116	.flush = gsm_flush,	127	.flush = gsm_flush,
		128	.capabilities = CODEC_CAP_DR1,
117	.long_name = NULL_IF_CONFIG_SMALL("GSM Microsoft variant"),	129	.long_name = NULL_IF_CONFIG_SMALL("GSM Microsoft variant"),
118	};	130	};

libavcodec/gsmdec_data.h+2−0

 #define AVCODEC_GSMDEC_DATA
 #include <stdint.h>
+#include "avcodec.h"
 // input and output sizes in byte
 #define GSM_BLOCK_SIZE    33
 #define GSM_FRAME_SIZE   160
 typedef struct {
+    AVFrame frame;
     // Contains first 120 elements from the previous frame
     // (used by long_term_synth according to the "lag"),
     // then in the following 160 elements the current

libavcodec/huffyuv.c+4−3

 #if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
 static void draw_slice(HYuvContext *s, int y){
-    int h, cy;
+    int h, cy, i;
-    int offset[4];
+    int offset[AV_NUM_DATA_POINTERS];
     if(s->avctx->draw_horiz_band==NULL)
         return;
     offset[0] = s->picture.linesize[0]*y;
     offset[1] = s->picture.linesize[1]*cy;
     offset[2] = s->picture.linesize[2]*cy;
-    offset[3] = 0;
+    for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
+        offset[i] = 0;
     emms_c();
     s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);

libavcodec/imc.c+19−10

 #define COEFFS 256
 typedef struct {
+    AVFrame frame;
     float old_floor[BANDS];
     float flcoeffs1[BANDS];
     float flcoeffs2[BANDS];
     dsputil_init(&q->dsp, avctx);
     avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
     avctx->channel_layout = AV_CH_LAYOUT_MONO;
+    avcodec_get_frame_defaults(&q->frame);
+    avctx->coded_frame = &q->frame;
     return 0;
 }
     return 0;
 }
-static int imc_decode_frame(AVCodecContext * avctx,
+static int imc_decode_frame(AVCodecContext * avctx, void *data,
-                            void *data, int *data_size,
+                            int *got_frame_ptr, AVPacket *avpkt)
-                            AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     IMCContext *q = avctx->priv_data;
     int stream_format_code;
-    int imc_hdr, i, j, out_size, ret;
+    int imc_hdr, i, j, ret;
     int flag;
     int bits, summer;
     int counter, bitscount;
         return AVERROR_INVALIDDATA;
     }
-    out_size = COEFFS * av_get_bytes_per_sample(avctx->sample_fmt);
+    /* get output buffer */
-    if (*data_size < out_size) {
+    q->frame.nb_samples = COEFFS;
-        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
+    if ((ret = avctx->get_buffer(avctx, &q->frame)) < 0) {
-        return AVERROR(EINVAL);
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        return ret;
     }
+    q->out_samples = (float *)q->frame.data[0];
     q->dsp.bswap16_buf(buf16, (const uint16_t*)buf, IMC_BLOCK_SIZE / 2);
-    q->out_samples = data;
     init_get_bits(&q->gb, (const uint8_t*)buf16, IMC_BLOCK_SIZE * 8);
     /* Check the frame header */
     imc_imdct256(q);
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = q->frame;
     return IMC_BLOCK_SIZE;
 }
     IMCContext *q = avctx->priv_data;
     ff_fft_end(&q->fft);
     return 0;
 }
     .init = imc_decode_init,
     .close = imc_decode_close,
     .decode = imc_decode_frame,
+    .capabilities = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
 };

libavcodec/internal.h+6−3

 typedef struct InternalBuffer {
     int last_pic_num;
-    uint8_t *base[4];
+    uint8_t *base[AV_NUM_DATA_POINTERS];
-    uint8_t *data[4];
+    uint8_t *data[AV_NUM_DATA_POINTERS];
-    int linesize[4];
+    int linesize[AV_NUM_DATA_POINTERS];
     int width;
     int height;
     enum PixelFormat pix_fmt;
+    uint8_t **extended_data;
+    int audio_data_size;
+    int nb_channels;
 } InternalBuffer;
 typedef struct AVCodecInternal {

libavcodec/libgsm.c+40−18

@@ -124,7 +124,14 @@ AVCodec ff_libgsm_ms_encoder = { · 123 unmodified lines
124	.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),	124	.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
125	};	125	};
126		126
		127	typedef struct LibGSMDecodeContext {
		128	AVFrame frame;
		129	struct gsm_state *state;
		130	} LibGSMDecodeContext;
		131
127	static av_cold int libgsm_decode_init(AVCodecContext *avctx) {	132	static av_cold int libgsm_decode_init(AVCodecContext *avctx) {
		133	LibGSMDecodeContext *s = avctx->priv_data;
		134
128	if (avctx->channels > 1) {	135	if (avctx->channels > 1) {
129	av_log(avctx, AV_LOG_ERROR, "Mono required for GSM, got %d channels\n",	136	av_log(avctx, AV_LOG_ERROR, "Mono required for GSM, got %d channels\n",
130	avctx->channels);	137	avctx->channels);
@@ -139,7 +146,7 @@ static av_cold int libgsm_decode_init(AVCodecContext *avctx) { · 8 unmodified lines
139		146
140	avctx->sample_fmt = AV_SAMPLE_FMT_S16;	147	avctx->sample_fmt = AV_SAMPLE_FMT_S16;
141		148
142	avctx->priv_data = gsm_create();	149	s->state = gsm_create();
143		150
144	switch(avctx->codec_id) {	151	switch(avctx->codec_id) {
145	case CODEC_ID_GSM:	152	case CODEC_ID_GSM:
@@ -154,59 +161,72 @@ static av_cold int libgsm_decode_init(AVCodecContext *avctx) { · 8 unmodified lines
154	}	161	}
155	}	162	}
156		163
		164	avcodec_get_frame_defaults(&s->frame);
		165	avctx->coded_frame = &s->frame;
		166
157	return 0;	167	return 0;
158	}	168	}
159		169
160	static av_cold int libgsm_decode_close(AVCodecContext *avctx) {	170	static av_cold int libgsm_decode_close(AVCodecContext *avctx) {
161	gsm_destroy(avctx->priv_data);	171	LibGSMDecodeContext *s = avctx->priv_data;
162	avctx->priv_data = NULL;	172
		173	gsm_destroy(s->state);
		174	s->state = NULL;
163	return 0;	175	return 0;
164	}	176	}
165		177
166	static int libgsm_decode_frame(AVCodecContext *avctx,	178	static int libgsm_decode_frame(AVCodecContext avctx, void data,
167	void data, int data_size,	179	int got_frame_ptr, AVPacket avpkt)
168	AVPacket *avpkt) {	180	{
169	int i, ret;	181	int i, ret;
170	struct gsm_state *s = avctx->priv_data;	182	LibGSMDecodeContext *s = avctx->priv_data;
171	uint8_t *buf = avpkt->data;	183	uint8_t *buf = avpkt->data;
172	int buf_size = avpkt->size;	184	int buf_size = avpkt->size;
173	int16_t *samples = data;	185	int16_t *samples;
174	int out_size = avctx->frame_size * av_get_bytes_per_sample(avctx->sample_fmt);
175
176	if (*data_size < out_size) {
177	av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
178	return AVERROR(EINVAL);
179	}
180		186
181	if (buf_size < avctx->block_align) {	187	if (buf_size < avctx->block_align) {
182	av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");	188	av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
183	return AVERROR_INVALIDDATA;	189	return AVERROR_INVALIDDATA;
184	}	190	}
185		191
		192	/* get output buffer */
		193	s->frame.nb_samples = avctx->frame_size;
		194	if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
		195	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		196	return ret;
		197	}
		198	samples = (int16_t *)s->frame.data[0];
		199
186	for (i = 0; i < avctx->frame_size / GSM_FRAME_SIZE; i++) {	200	for (i = 0; i < avctx->frame_size / GSM_FRAME_SIZE; i++) {
187	if ((ret = gsm_decode(s, buf, samples)) < 0)	201	if ((ret = gsm_decode(s->state, buf, samples)) < 0)
188	return -1;	202	return -1;
189	buf += GSM_BLOCK_SIZE;	203	buf += GSM_BLOCK_SIZE;
190	samples += GSM_FRAME_SIZE;	204	samples += GSM_FRAME_SIZE;
191	}	205	}
192		206
193	*data_size = out_size;	207	*got_frame_ptr = 1;
		208	(AVFrame )data = s->frame;
		209
194	return avctx->block_align;	210	return avctx->block_align;
195	}	211	}
196		212
197	static void libgsm_flush(AVCodecContext *avctx) {	213	static void libgsm_flush(AVCodecContext *avctx) {
198	gsm_destroy(avctx->priv_data);	214	LibGSMDecodeContext *s = avctx->priv_data;
199	avctx->priv_data = gsm_create();	215
		216	gsm_destroy(s->state);
		217	s->state = gsm_create();
200	}	218	}
201		219
202	AVCodec ff_libgsm_decoder = {	220	AVCodec ff_libgsm_decoder = {
203	.name = "libgsm",	221	.name = "libgsm",
204	.type = AVMEDIA_TYPE_AUDIO,	222	.type = AVMEDIA_TYPE_AUDIO,
205	.id = CODEC_ID_GSM,	223	.id = CODEC_ID_GSM,
		224	.priv_data_size = sizeof(LibGSMDecodeContext),
206	.init = libgsm_decode_init,	225	.init = libgsm_decode_init,
207	.close = libgsm_decode_close,	226	.close = libgsm_decode_close,
208	.decode = libgsm_decode_frame,	227	.decode = libgsm_decode_frame,
209	.flush = libgsm_flush,	228	.flush = libgsm_flush,
		229	.capabilities = CODEC_CAP_DR1,
210	.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),	230	.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
211	};	231	};
212		232
@@ -214,9 +234,11 @@ AVCodec ff_libgsm_ms_decoder = { · 1 unmodified line
214	.name = "libgsm_ms",	234	.name = "libgsm_ms",
215	.type = AVMEDIA_TYPE_AUDIO,	235	.type = AVMEDIA_TYPE_AUDIO,
216	.id = CODEC_ID_GSM_MS,	236	.id = CODEC_ID_GSM_MS,
		237	.priv_data_size = sizeof(LibGSMDecodeContext),
217	.init = libgsm_decode_init,	238	.init = libgsm_decode_init,
218	.close = libgsm_decode_close,	239	.close = libgsm_decode_close,
219	.decode = libgsm_decode_frame,	240	.decode = libgsm_decode_frame,
220	.flush = libgsm_flush,	241	.flush = libgsm_flush,
		242	.capabilities = CODEC_CAP_DR1,
221	.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),	243	.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
222	};	244	};

libavcodec/libopencore-amr.c+35−17

@@ -79,6 +79,7 @@ static int get_bitrate_mode(int bitrate, void *log_ctx) · 78 unmodified lines
79		79
80	typedef struct AMRContext {	80	typedef struct AMRContext {
81	AVClass *av_class;	81	AVClass *av_class;
		82	AVFrame frame;
82	void *dec_state;	83	void *dec_state;
83	void *enc_state;	84	void *enc_state;
84	int enc_bitrate;	85	int enc_bitrate;
@@ -112,6 +113,9 @@ static av_cold int amr_nb_decode_init(AVCodecContext *avctx) · 27 unmodified lines
112	return AVERROR(ENOSYS);	113	return AVERROR(ENOSYS);
113	}	114	}
114		115
		116	avcodec_get_frame_defaults(&s->frame);
		117	avctx->coded_frame = &s->frame;
		118
115	return 0;	119	return 0;
116	}	120	}
117		121
@@ -120,26 +124,28 @@ static av_cold int amr_nb_decode_close(AVCodecContext *avctx) · 2 unmodified lines
120	AMRContext *s = avctx->priv_data;	124	AMRContext *s = avctx->priv_data;
121		125
122	Decoder_Interface_exit(s->dec_state);	126	Decoder_Interface_exit(s->dec_state);
		127
123	return 0;	128	return 0;
124	}	129	}
125		130
126	static int amr_nb_decode_frame(AVCodecContext avctx, void data,	131	static int amr_nb_decode_frame(AVCodecContext avctx, void data,
127	int data_size, AVPacket avpkt)	132	int got_frame_ptr, AVPacket avpkt)
128	{	133	{
129	const uint8_t *buf = avpkt->data;	134	const uint8_t *buf = avpkt->data;
130	int buf_size = avpkt->size;	135	int buf_size = avpkt->size;
131	AMRContext *s = avctx->priv_data;	136	AMRContext *s = avctx->priv_data;
132	static const uint8_t block_size[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };	137	static const uint8_t block_size[16] = { 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 };
133	enum Mode dec_mode;	138	enum Mode dec_mode;
134	int packet_size, out_size;	139	int packet_size, ret;
135		140
136	av_dlog(avctx, "amr_decode_frame buf=%p buf_size=%d frame_count=%d!!\n",	141	av_dlog(avctx, "amr_decode_frame buf=%p buf_size=%d frame_count=%d!!\n",
137	buf, buf_size, avctx->frame_number);	142	buf, buf_size, avctx->frame_number);
138		143
139	out_size = 160 * av_get_bytes_per_sample(avctx->sample_fmt);	144	/* get output buffer */
140	if (*data_size < out_size) {	145	s->frame.nb_samples = 160;
141	av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");	146	if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
142	return AVERROR(EINVAL);	147	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		148	return ret;
143	}	149	}
144		150
145	dec_mode = (buf[0] >> 3) & 0x000F;	151	dec_mode = (buf[0] >> 3) & 0x000F;
@@ -154,8 +160,10 @@ static int amr_nb_decode_frame(AVCodecContext avctx, void data, · 8 unmodified lines
154	av_dlog(avctx, "packet_size=%d buf= 0x%X %X %X %X\n",	160	av_dlog(avctx, "packet_size=%d buf= 0x%X %X %X %X\n",
155	packet_size, buf[0], buf[1], buf[2], buf[3]);	161	packet_size, buf[0], buf[1], buf[2], buf[3]);
156	/* call decoder */	162	/* call decoder */
157	Decoder_Interface_Decode(s->dec_state, buf, data, 0);	163	Decoder_Interface_Decode(s->dec_state, buf, (short *)s->frame.data[0], 0);
158	*data_size = out_size;	164
		165	*got_frame_ptr = 1;
		166	(AVFrame )data = s->frame;
159		167
160	return packet_size;	168	return packet_size;
161	}	169	}
@@ -168,6 +176,7 @@ AVCodec ff_libopencore_amrnb_decoder = { · 6 unmodified lines
168	.init = amr_nb_decode_init,	176	.init = amr_nb_decode_init,
169	.close = amr_nb_decode_close,	177	.close = amr_nb_decode_close,
170	.decode = amr_nb_decode_frame,	178	.decode = amr_nb_decode_frame,
		179	.capabilities = CODEC_CAP_DR1,
171	.long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),	180	.long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),
172	};	181	};
173		182
@@ -251,6 +260,7 @@ AVCodec ff_libopencore_amrnb_encoder = { · 77 unmodified lines
251	#include <opencore-amrwb/if_rom.h>	260	#include <opencore-amrwb/if_rom.h>
252		261
253	typedef struct AMRWBContext {	262	typedef struct AMRWBContext {
		263	AVFrame frame;
254	void *state;	264	void *state;
255	} AMRWBContext;	265	} AMRWBContext;
256		266
@@ -267,23 +277,27 @@ static av_cold int amr_wb_decode_init(AVCodecContext *avctx) · 10 unmodified lines
267	return AVERROR(ENOSYS);	277	return AVERROR(ENOSYS);
268	}	278	}
269		279
		280	avcodec_get_frame_defaults(&s->frame);
		281	avctx->coded_frame = &s->frame;
		282
270	return 0;	283	return 0;
271	}	284	}
272		285
273	static int amr_wb_decode_frame(AVCodecContext avctx, void data,	286	static int amr_wb_decode_frame(AVCodecContext avctx, void data,
274	int data_size, AVPacket avpkt)	287	int got_frame_ptr, AVPacket avpkt)
275	{	288	{
276	const uint8_t *buf = avpkt->data;	289	const uint8_t *buf = avpkt->data;
277	int buf_size = avpkt->size;	290	int buf_size = avpkt->size;
278	AMRWBContext *s = avctx->priv_data;	291	AMRWBContext *s = avctx->priv_data;
279	int mode;	292	int mode, ret;
280	int packet_size, out_size;	293	int packet_size;
281	static const uint8_t block_size[16] = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1};	294	static const uint8_t block_size[16] = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 6, 0, 0, 0, 1, 1};
282		295
283	out_size = 320 * av_get_bytes_per_sample(avctx->sample_fmt);	296	/* get output buffer */
284	if (*data_size < out_size) {	297	s->frame.nb_samples = 320;
285	av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");	298	if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
286	return AVERROR(EINVAL);	299	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		300	return ret;
287	}	301	}
288		302
289	mode = (buf[0] >> 3) & 0x000F;	303	mode = (buf[0] >> 3) & 0x000F;
@@ -295,8 +309,11 @@ static int amr_wb_decode_frame(AVCodecContext avctx, void data, · 5 unmodified lines
295	return AVERROR_INVALIDDATA;	309	return AVERROR_INVALIDDATA;
296	}	310	}
297		311
298	D_IF_decode(s->state, buf, data, _good_frame);	312	D_IF_decode(s->state, buf, (short *)s->frame.data[0], _good_frame);
299	*data_size = out_size;	313
		314	*got_frame_ptr = 1;
		315	(AVFrame )data = s->frame;
		316
300	return packet_size;	317	return packet_size;
301	}	318	}
302		319
@@ -316,6 +333,7 @@ AVCodec ff_libopencore_amrwb_decoder = { · 13 unmodified lines
316	.init = amr_wb_decode_init,	333	.init = amr_wb_decode_init,
317	.close = amr_wb_decode_close,	334	.close = amr_wb_decode_close,
318	.decode = amr_wb_decode_frame,	335	.decode = amr_wb_decode_frame,
		336	.capabilities = CODEC_CAP_DR1,
319	.long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Wide-Band"),	337	.long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Wide-Band"),
320	};	338	};
321		339

libavcodec/libspeexdec.c+21−15

 #include "avcodec.h"
 typedef struct {
+    AVFrame frame;
     SpeexBits bits;
     SpeexStereoState stereo;
     void *dec_state;
         s->stereo = (SpeexStereoState)SPEEX_STEREO_STATE_INIT;
         speex_decoder_ctl(s->dec_state, SPEEX_SET_HANDLER, &callback);
     }
+    avcodec_get_frame_defaults(&s->frame);
+    avctx->coded_frame = &s->frame;
     return 0;
 }
-static int libspeex_decode_frame(AVCodecContext *avctx,
+static int libspeex_decode_frame(AVCodecContext *avctx, void *data,
-                                 void *data, int *data_size,
+                                 int *got_frame_ptr, AVPacket *avpkt)
-                                 AVPacket *avpkt)
 {
     uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     LibSpeexContext *s = avctx->priv_data;
-    int16_t *output = data;
+    int16_t *output;
-    int out_size, ret, consumed = 0;
+    int ret, consumed = 0;
-    /* check output buffer size */
+    /* get output buffer */
-    out_size = s->frame_size * avctx->channels *
+    s->frame.nb_samples = s->frame_size;
-               av_get_bytes_per_sample(avctx->sample_fmt);
+    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
-    if (*data_size < out_size) {
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
+        return ret;
-        return AVERROR(EINVAL);
     }
+    output = (int16_t *)s->frame.data[0];
     /* if there is not enough data left for the smallest possible frame,
        reset the libspeex buffer using the current packet, otherwise ignore
     if (speex_bits_remaining(&s->bits) < 43) {
         /* check for flush packet */
         if (!buf || !buf_size) {
-            *data_size = 0;
+            *got_frame_ptr = 0;
             return buf_size;
         }
         /* set new buffer */
     if (avctx->channels == 2)
         speex_decode_stereo_int(output, s->frame_size, &s->stereo);
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = s->frame;
     return consumed;
 }
     .close          = libspeex_decode_close,
     .decode         = libspeex_decode_frame,
     .flush          = libspeex_decode_flush,
-    .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DELAY,
+    .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DELAY | CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("libspeex Speex"),
 };

libavcodec/mace.c+21−12

 } ChannelData;
 typedef struct MACEContext {
+    AVFrame frame;
     ChannelData chd[2];
 } MACEContext;
 static av_cold int mace_decode_init(AVCodecContext * avctx)
 {
+    MACEContext *ctx = avctx->priv_data;
     if (avctx->channels > 2)
         return -1;
     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
+    avcodec_get_frame_defaults(&ctx->frame);
+    avctx->coded_frame = &ctx->frame;
     return 0;
 }
-static int mace_decode_frame(AVCodecContext *avctx,
+static int mace_decode_frame(AVCodecContext *avctx, void *data,
-                              void *data, int *data_size,
+                             int *got_frame_ptr, AVPacket *avpkt)
-                              AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
-    int16_t *samples = data;
+    int16_t *samples;
     MACEContext *ctx = avctx->priv_data;
-    int i, j, k, l;
+    int i, j, k, l, ret;
-    int out_size;
     int is_mace3 = (avctx->codec_id == CODEC_ID_MACE3);
-    out_size = 3 * (buf_size << (1 - is_mace3)) *
+    /* get output buffer */
-               av_get_bytes_per_sample(avctx->sample_fmt);
+    ctx->frame.nb_samples = 3 * (buf_size << (1 - is_mace3)) / avctx->channels;
-    if (*data_size < out_size) {
+    if ((ret = avctx->get_buffer(avctx, &ctx->frame)) < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-        return AVERROR(EINVAL);
+        return ret;
     }
+    samples = (int16_t *)ctx->frame.data[0];
     for(i = 0; i < avctx->channels; i++) {
         int16_t *output = samples + i;
             }
     }
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = ctx->frame;
     return buf_size;
 }
     .priv_data_size = sizeof(MACEContext),
     .init           = mace_decode_init,
     .decode         = mace_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 3:1"),
 };
     .priv_data_size = sizeof(MACEContext),
     .init           = mace_decode_init,
     .decode         = mace_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 6:1"),
 };

libavcodec/mlpdec.c+25−14

@@ -120,6 +120,7 @@ typedef struct SubStream { · 119 unmodified lines
120		120
121	typedef struct MLPDecodeContext {	121	typedef struct MLPDecodeContext {
122	AVCodecContext *avctx;	122	AVCodecContext *avctx;
		123	AVFrame frame;
123		124
124	//! Current access unit being read has a major sync.	125	//! Current access unit being read has a major sync.
125	int is_major_sync_unit;	126	int is_major_sync_unit;
@@ -242,6 +243,9 @@ static av_cold int mlp_decode_init(AVCodecContext *avctx) · 116 unmodified lines
242	m->substream[substr].lossless_check_data = 0xffffffff;	243	m->substream[substr].lossless_check_data = 0xffffffff;
243	dsputil_init(&m->dsp, avctx);	244	dsputil_init(&m->dsp, avctx);
244		245
		246	avcodec_get_frame_defaults(&m->frame);
		247	avctx->coded_frame = &m->frame;
		248
245	return 0;	249	return 0;
246	}	250	}
247		251
@@ -946,13 +950,14 @@ static void rematrix_channels(MLPDecodeContext *m, unsigned int substr) · 698 unmodified lines
946	/** Write the audio data into the output buffer. */	950	/** Write the audio data into the output buffer. */
947		951
948	static int output_data(MLPDecodeContext *m, unsigned int substr,	952	static int output_data(MLPDecodeContext *m, unsigned int substr,
949	uint8_t data, unsigned int data_size)	953	void data, int got_frame_ptr)
950	{	954	{
		955	AVCodecContext *avctx = m->avctx;
951	SubStream *s = &m->substream[substr];	956	SubStream *s = &m->substream[substr];
952	unsigned int i, out_ch = 0;	957	unsigned int i, out_ch = 0;
953	int out_size;	958	int32_t *data_32;
954	int32_t data_32 = (int32_t) data;	959	int16_t *data_16;
955	int16_t data_16 = (int16_t) data;	960	int ret;
956	int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);	961	int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
957		962
958	if (m->avctx->channels != s->max_matrix_channel + 1) {	963	if (m->avctx->channels != s->max_matrix_channel + 1) {
@@ -960,11 +965,14 @@ static int output_data(MLPDecodeContext *m, unsigned int substr, · 1 unmodified line
960	return AVERROR_INVALIDDATA;	965	return AVERROR_INVALIDDATA;
961	}	966	}
962		967
963	out_size = s->blockpos * m->avctx->channels *	968	/* get output buffer */
964	av_get_bytes_per_sample(m->avctx->sample_fmt);	969	m->frame.nb_samples = s->blockpos;
965		970	if ((ret = avctx->get_buffer(avctx, &m->frame)) < 0) {
966	if (*data_size < out_size)	971	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
967	return AVERROR(EINVAL);	972	return ret;
		973	}
		974	data_32 = (int32_t *)m->frame.data[0];
		975	data_16 = (int16_t *)m->frame.data[0];
968		976
969	for (i = 0; i < s->blockpos; i++) {	977	for (i = 0; i < s->blockpos; i++) {
970	for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {	978	for (out_ch = 0; out_ch <= s->max_matrix_channel; out_ch++) {
@@ -977,7 +985,8 @@ static int output_data(MLPDecodeContext *m, unsigned int substr, · 6 unmodified lines
977	}	985	}
978	}	986	}
979		987
980	*data_size = out_size;	988	*got_frame_ptr = 1;
		989	(AVFrame )data = m->frame;
981		990
982	return 0;	991	return 0;
983	}	992	}
@@ -986,8 +995,8 @@ static int output_data(MLPDecodeContext *m, unsigned int substr, · 2 unmodified lines
986	* @return negative on error, 0 if not enough data is present in the input stream,	995	* @return negative on error, 0 if not enough data is present in the input stream,
987	* otherwise the number of bytes consumed. */	996	* otherwise the number of bytes consumed. */
988		997
989	static int read_access_unit(AVCodecContext avctx, void data, int *data_size,	998	static int read_access_unit(AVCodecContext avctx, void data,
990	AVPacket *avpkt)	999	int got_frame_ptr, AVPacket avpkt)
991	{	1000	{
992	const uint8_t *buf = avpkt->data;	1001	const uint8_t *buf = avpkt->data;
993	int buf_size = avpkt->size;	1002	int buf_size = avpkt->size;
@@ -1023,7 +1032,7 @@ static int read_access_unit(AVCodecContext avctx, void data, int *data_size, · 29 unmodified lines
1023	if (!m->params_valid) {	1032	if (!m->params_valid) {
1024	av_log(m->avctx, AV_LOG_WARNING,	1033	av_log(m->avctx, AV_LOG_WARNING,
1025	"Stream parameters not seen; skipping frame.\n");	1034	"Stream parameters not seen; skipping frame.\n");
1026	*data_size = 0;	1035	*got_frame_ptr = 0;
1027	return length;	1036	return length;
1028	}	1037	}
1029		1038
@@ -1168,7 +1177,7 @@ next_substr: · 138 unmodified lines
1168		1177
1169	rematrix_channels(m, m->max_decoded_substream);	1178	rematrix_channels(m, m->max_decoded_substream);
1170		1179
1171	if ((ret = output_data(m, m->max_decoded_substream, data, data_size)) < 0)	1180	if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
1172	return ret;	1181	return ret;
1173		1182
1174	return length;	1183	return length;
@@ -1189,6 +1198,7 @@ AVCodec ff_mlp_decoder = { · 14 unmodified lines
1189	.priv_data_size = sizeof(MLPDecodeContext),	1198	.priv_data_size = sizeof(MLPDecodeContext),
1190	.init = mlp_decode_init,	1199	.init = mlp_decode_init,
1191	.decode = read_access_unit,	1200	.decode = read_access_unit,
		1201	.capabilities = CODEC_CAP_DR1,
1192	.long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),	1202	.long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
1193	};	1203	};
1194		1204
@@ -1200,6 +1210,7 @@ AVCodec ff_truehd_decoder = { · 5 unmodified lines
1200	.priv_data_size = sizeof(MLPDecodeContext),	1210	.priv_data_size = sizeof(MLPDecodeContext),
1201	.init = mlp_decode_init,	1211	.init = mlp_decode_init,
1202	.decode = read_access_unit,	1212	.decode = read_access_unit,
		1213	.capabilities = CODEC_CAP_DR1,
1203	.long_name = NULL_IF_CONFIG_SMALL("TrueHD"),	1214	.long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
1204	};	1215	};
1205	#endif /* CONFIG_TRUEHD_DECODER */	1216	#endif /* CONFIG_TRUEHD_DECODER */

libavcodec/mpc.h+1−0

@@ -50,6 +50,7 @@ typedef struct { · 49 unmodified lines
50	}Band;	50	}Band;
51		51
52	typedef struct {	52	typedef struct {
		53	AVFrame frame;
53	DSPContext dsp;	54	DSPContext dsp;
54	MPADSPContext mpadsp;	55	MPADSPContext mpadsp;
55	GetBitContext gb;	56	GetBitContext gb;

libavcodec/mpc7.c+18−11

@@ -136,6 +136,10 @@ static av_cold int mpc7_decode_init(AVCodecContext * avctx) · 135 unmodified lines
136	}	136	}
137	}	137	}
138	vlc_initialized = 1;	138	vlc_initialized = 1;
		139
		140	avcodec_get_frame_defaults(&c->frame);
		141	avctx->coded_frame = &c->frame;
		142
139	return 0;	143	return 0;
140	}	144	}
141		145
@@ -192,9 +196,8 @@ static int get_scale_idx(GetBitContext *gb, int ref) · 50 unmodified lines
192	return ref + t;	196	return ref + t;
193	}	197	}
194		198
195	static int mpc7_decode_frame(AVCodecContext * avctx,	199	static int mpc7_decode_frame(AVCodecContext * avctx, void *data,
196	void data, int data_size,	200	int got_frame_ptr, AVPacket avpkt)
197	AVPacket *avpkt)
198	{	201	{
199	const uint8_t *buf = avpkt->data;	202	const uint8_t *buf = avpkt->data;
200	int buf_size = avpkt->size;	203	int buf_size = avpkt->size;
@@ -204,7 +207,7 @@ static int mpc7_decode_frame(AVCodecContext * avctx, · 3 unmodified lines
204	int i, ch;	207	int i, ch;
205	int mb = -1;	208	int mb = -1;
206	Band *bands = c->bands;	209	Band *bands = c->bands;
207	int off, out_size;	210	int off, ret;
208	int bits_used, bits_avail;	211	int bits_used, bits_avail;
209		212
210	memset(bands, 0, sizeof(bands) (c->maxbands + 1));	213	memset(bands, 0, sizeof(bands) (c->maxbands + 1));
@@ -213,10 +216,11 @@ static int mpc7_decode_frame(AVCodecContext * avctx, · 2 unmodified lines
213	return AVERROR(EINVAL);	216	return AVERROR(EINVAL);
214	}	217	}
215		218
216	out_size = (buf[1] ? c->lastframelen : MPC_FRAME_SIZE) * 4;	219	/* get output buffer */
217	if (*data_size < out_size) {	220	c->frame.nb_samples = buf[1] ? c->lastframelen : MPC_FRAME_SIZE;
218	av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");	221	if ((ret = avctx->get_buffer(avctx, &c->frame)) < 0) {
219	return AVERROR(EINVAL);	222	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		223	return ret;
220	}	224	}
221		225
222	bits = av_malloc(((buf_size - 1) & ~3) + FF_INPUT_BUFFER_PADDING_SIZE);	226	bits = av_malloc(((buf_size - 1) & ~3) + FF_INPUT_BUFFER_PADDING_SIZE);
@@ -276,7 +280,7 @@ static int mpc7_decode_frame(AVCodecContext * avctx, · 53 unmodified lines
276	for(ch = 0; ch < 2; ch++)	280	for(ch = 0; ch < 2; ch++)
277	idx_to_quant(c, &gb, bands[i].res[ch], c->Q[ch] + off);	281	idx_to_quant(c, &gb, bands[i].res[ch], c->Q[ch] + off);
278		282
279	ff_mpc_dequantize_and_synth(c, mb, data, 2);	283	ff_mpc_dequantize_and_synth(c, mb, c->frame.data[0], 2);
280		284
281	av_free(bits);	285	av_free(bits);
282		286
@@ -288,10 +292,12 @@ static int mpc7_decode_frame(AVCodecContext * avctx, · 5 unmodified lines
288	}	292	}
289	if(c->frames_to_skip){	293	if(c->frames_to_skip){
290	c->frames_to_skip--;	294	c->frames_to_skip--;
291	*data_size = 0;	295	*got_frame_ptr = 0;
292	return buf_size;	296	return buf_size;
293	}	297	}
294	*data_size = out_size;	298
		299	*got_frame_ptr = 1;
		300	(AVFrame )data = c->frame;
295		301
296	return buf_size;	302	return buf_size;
297	}	303	}
@@ -312,5 +318,6 @@ AVCodec ff_mpc7_decoder = { · 14 unmodified lines
312	.init = mpc7_decode_init,	318	.init = mpc7_decode_init,
313	.decode = mpc7_decode_frame,	319	.decode = mpc7_decode_frame,
314	.flush = mpc7_decode_flush,	320	.flush = mpc7_decode_flush,
		321	.capabilities = CODEC_CAP_DR1,
315	.long_name = NULL_IF_CONFIG_SMALL("Musepack SV7"),	322	.long_name = NULL_IF_CONFIG_SMALL("Musepack SV7"),
316	};	323	};

libavcodec/mpc8.c+17−10

@@ -230,12 +230,15 @@ static av_cold int mpc8_decode_init(AVCodecContext * avctx) · 229 unmodified lines
230	&mpc8_q8_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);	230	&mpc8_q8_codes[i], 1, 1, INIT_VLC_USE_NEW_STATIC);
231	}	231	}
232	vlc_initialized = 1;	232	vlc_initialized = 1;
		233
		234	avcodec_get_frame_defaults(&c->frame);
		235	avctx->coded_frame = &c->frame;
		236
233	return 0;	237	return 0;
234	}	238	}
235		239
236	static int mpc8_decode_frame(AVCodecContext * avctx,	240	static int mpc8_decode_frame(AVCodecContext * avctx, void *data,
237	void data, int data_size,	241	int got_frame_ptr, AVPacket avpkt)
238	AVPacket *avpkt)
239	{	242	{
240	const uint8_t *buf = avpkt->data;	243	const uint8_t *buf = avpkt->data;
241	int buf_size = avpkt->size;	244	int buf_size = avpkt->size;
@@ -243,14 +246,15 @@ static int mpc8_decode_frame(AVCodecContext * avctx, · 1 unmodified line
243	GetBitContext gb2, *gb = &gb2;	246	GetBitContext gb2, *gb = &gb2;
244	int i, j, k, ch, cnt, res, t;	247	int i, j, k, ch, cnt, res, t;
245	Band *bands = c->bands;	248	Band *bands = c->bands;
246	int off, out_size;	249	int off;
247	int maxband, keyframe;	250	int maxband, keyframe;
248	int last[2];	251	int last[2];
249		252
250	out_size = MPC_FRAME_SIZE * 2 * avctx->channels;	253	/* get output buffer */
251	if (*data_size < out_size) {	254	c->frame.nb_samples = MPC_FRAME_SIZE;
252	av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");	255	if ((res = avctx->get_buffer(avctx, &c->frame)) < 0) {
253	return AVERROR(EINVAL);	256	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		257	return res;
254	}	258	}
255		259
256	keyframe = c->cur_frame == 0;	260	keyframe = c->cur_frame == 0;
@@ -403,14 +407,16 @@ static int mpc8_decode_frame(AVCodecContext * avctx, · 146 unmodified lines
403	}	407	}
404	}	408	}
405		409
406	ff_mpc_dequantize_and_synth(c, maxband, data, avctx->channels);	410	ff_mpc_dequantize_and_synth(c, maxband, c->frame.data[0], avctx->channels);
407		411
408	c->cur_frame++;	412	c->cur_frame++;
409		413
410	c->last_bits_used = get_bits_count(gb);	414	c->last_bits_used = get_bits_count(gb);
411	if(c->cur_frame >= c->frames)	415	if(c->cur_frame >= c->frames)
412	c->cur_frame = 0;	416	c->cur_frame = 0;
413	*data_size = out_size;	417
		418	*got_frame_ptr = 1;
		419	(AVFrame )data = c->frame;
414		420
415	return c->cur_frame ? c->last_bits_used >> 3 : buf_size;	421	return c->cur_frame ? c->last_bits_used >> 3 : buf_size;
416	}	422	}
@@ -422,5 +428,6 @@ AVCodec ff_mpc8_decoder = { · 5 unmodified lines
422	.priv_data_size = sizeof(MPCContext),	428	.priv_data_size = sizeof(MPCContext),
423	.init = mpc8_decode_init,	429	.init = mpc8_decode_init,
424	.decode = mpc8_decode_frame,	430	.decode = mpc8_decode_frame,
		431	.capabilities = CODEC_CAP_DR1,
425	.long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"),	432	.long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"),
426	};	433	};

libavcodec/mpeg4audio.c+4−3

         avpriv_mpeg4audio_sample_rates[*index];
 }
-int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf, int buf_size)
+int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf,
+                                 int bit_size, int sync_extension)
 {
     GetBitContext gb;
     int specific_config_bitindex;
-    init_get_bits(&gb, buf, buf_size*8);
+    init_get_bits(&gb, buf, bit_size);
     c->object_type = get_object_type(&gb);
     c->sample_rate = get_sample_rate(&gb, &c->sampling_index);
     c->chan_config = get_bits(&gb, 4);
             return -1;
     }
-    if (c->ext_object_type != AOT_SBR) {
+    if (c->ext_object_type != AOT_SBR && sync_extension) {
         while (get_bits_left(&gb) > 15) {
             if (show_bits(&gb, 11) == 0x2b7) { // sync extension
                 get_bits(&gb, 11);

libavcodec/mpeg4audio.h+5−2

 extern const int avpriv_mpeg4audio_sample_rates[16];
 extern const uint8_t ff_mpeg4audio_channels[8];
 /**
  * Parse MPEG-4 systems extradata to retrieve audio configuration.
  * @param[in] c        MPEG4AudioConfig structure to fill.
  * @param[in] buf      Extradata from container.
- * @param[in] buf_size Extradata size.
+ * @param[in] bit_size Extradata size in bits.
+ * @param[in] sync_extension look for a sync extension after config if true.
  * @return On error -1 is returned, on success AudioSpecificConfig bit index in extradata.
  */
-int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf, int buf_size);
+int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf,
+                                 int bit_size, int sync_extension);
 enum AudioObjectType {
     AOT_NULL,

libavcodec/mpegaudiodec.c+57−32

     int err_recognition;
     AVCodecContext* avctx;
     MPADSPContext mpadsp;
+    AVFrame frame;
 } MPADecodeContext;
 #if CONFIG_FLOAT
     if (avctx->codec_id == CODEC_ID_MP3ADU)
         s->adu_mode = 1;
+    avcodec_get_frame_defaults(&s->frame);
+    avctx->coded_frame = &s->frame;
     return 0;
 }
 static int mp_decode_frame(MPADecodeContext *s, OUT_INT *samples,
                            const uint8_t *buf, int buf_size)
 {
-    int i, nb_frames, ch;
+    int i, nb_frames, ch, ret;
     OUT_INT *samples_ptr;
     init_get_bits(&s->gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE) * 8);
         assert(i <= buf_size - HEADER_SIZE && i >= 0);
         memcpy(s->last_buf + s->last_buf_size, s->gb.buffer + buf_size - HEADER_SIZE - i, i);
         s->last_buf_size += i;
+    }
-        break;
+    /* get output buffer */
+    if (!samples) {
+        s->frame.nb_samples = s->avctx->frame_size;
+        if ((ret = s->avctx->get_buffer(s->avctx, &s->frame)) < 0) {
+            av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+            return ret;
+        }
+        samples = (OUT_INT *)s->frame.data[0];
     }
     /* apply the synthesis filter */
     return nb_frames * 32 * sizeof(OUT_INT) * s->nb_channels;
 }
-static int decode_frame(AVCodecContext * avctx, void *data, int *data_size,
+static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
                         AVPacket *avpkt)
 {
     const uint8_t *buf  = avpkt->data;
     MPADecodeContext *s = avctx->priv_data;
     uint32_t header;
     int out_size;
-    OUT_INT *out_samples = data;
     if (buf_size < HEADER_SIZE)
         return AVERROR_INVALIDDATA;
         avctx->bit_rate = s->bit_rate;
     avctx->sub_id = s->layer;
-    if (*data_size < avctx->frame_size * avctx->channels * sizeof(OUT_INT))
-        return AVERROR(EINVAL);
-    *data_size = 0;
     if (s->frame_size <= 0 || s->frame_size > buf_size) {
         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
         return AVERROR_INVALIDDATA;
         buf_size= s->frame_size;
     }
-    out_size = mp_decode_frame(s, out_samples, buf, buf_size);
+    out_size = mp_decode_frame(s, NULL, buf, buf_size);
     if (out_size >= 0) {
-        *data_size         = out_size;
+        *got_frame_ptr   = 1;
+        *(AVFrame *)data = s->frame;
         avctx->sample_rate = s->sample_rate;
         //FIXME maybe move the other codec info stuff from above here too
     } else {
            If there is more data in the packet, just consume the bad frame
            instead of returning an error, which would discard the whole
            packet. */
+        *got_frame_ptr = 0;
         if (buf_size == avpkt->size)
             return out_size;
     }
 }
 #if CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER
-static int decode_frame_adu(AVCodecContext *avctx, void *data, int *data_size,
+static int decode_frame_adu(AVCodecContext *avctx, void *data,
-                            AVPacket *avpkt)
+                            int *got_frame_ptr, AVPacket *avpkt)
 {
     const uint8_t *buf  = avpkt->data;
     int buf_size        = avpkt->size;
     MPADecodeContext *s = avctx->priv_data;
     uint32_t header;
     int len, out_size;
-    OUT_INT *out_samples = data;
     len = buf_size;
         avctx->bit_rate = s->bit_rate;
     avctx->sub_id = s->layer;
-    if (*data_size < avctx->frame_size * avctx->channels * sizeof(OUT_INT))
-        return AVERROR(EINVAL);
     s->frame_size = len;
 #if FF_API_PARSE_FRAME
         out_size = buf_size;
     else
 #endif
-    out_size = mp_decode_frame(s, out_samples, buf, buf_size);
+    out_size = mp_decode_frame(s, NULL, buf, buf_size);
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = s->frame;
-    *data_size = out_size;
     return buf_size;
 }
 #endif /* CONFIG_MP3ADU_DECODER || CONFIG_MP3ADUFLOAT_DECODER */
  * Context for MP3On4 decoder
  */
 typedef struct MP3On4DecodeContext {
+    AVFrame *frame;
     int frames;                     ///< number of mp3 frames per block (number of mp3 decoder instances)
     int syncword;                   ///< syncword patch
     const uint8_t *coff;            ///< channel offsets in output buffer
         return AVERROR_INVALIDDATA;
     }
-    avpriv_mpeg4audio_get_config(&cfg, avctx->extradata, avctx->extradata_size);
+    avpriv_mpeg4audio_get_config(&cfg, avctx->extradata,
+                                 avctx->extradata_size * 8, 1);
     if (!cfg.chan_config || cfg.chan_config > 7) {
         av_log(avctx, AV_LOG_ERROR, "Invalid channel config number.\n");
         return AVERROR_INVALIDDATA;
     // Put decoder context in place to make init_decode() happy
     avctx->priv_data = s->mp3decctx[0];
     decode_init(avctx);
+    s->frame = avctx->coded_frame;
     // Restore mp3on4 context pointer
     avctx->priv_data = s;
     s->mp3decctx[0]->adu_mode = 1; // Set adu mode
 }
-static int decode_frame_mp3on4(AVCodecContext * avctx,
+static int decode_frame_mp3on4(AVCodecContext *avctx, void *data,
-                        void *data, int *data_size,
+                               int *got_frame_ptr, AVPacket *avpkt)
-                        AVPacket *avpkt)
 {
     const uint8_t *buf     = avpkt->data;
     int buf_size           = avpkt->size;
     MPADecodeContext *m;
     int fsize, len = buf_size, out_size = 0;
     uint32_t header;
-    OUT_INT *out_samples = data;
+    OUT_INT *out_samples;
     OUT_INT *outptr, *bp;
-    int fr, j, n, ch;
+    int fr, j, n, ch, ret;
-    if (*data_size < MPA_FRAME_SIZE * avctx->channels * sizeof(OUT_INT)) {
+    /* get output buffer */
-        av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");
+    s->frame->nb_samples = MPA_FRAME_SIZE;
-        return AVERROR(EINVAL);
+    if ((ret = avctx->get_buffer(avctx, s->frame)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        return ret;
     }
+    out_samples = (OUT_INT *)s->frame->data[0];
     // Discard too short frames
     if (buf_size < HEADER_SIZE)
     /* update codec info */
     avctx->sample_rate = s->mp3decctx[0]->sample_rate;
-    *data_size = out_size;
+    s->frame->nb_samples = out_size / (avctx->channels * sizeof(OUT_INT));
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = *s->frame;
     return buf_size;
 }
 #endif /* CONFIG_MP3ON4_DECODER || CONFIG_MP3ON4FLOAT_DECODER */
     .init           = decode_init,
     .decode         = decode_frame,
 #if FF_API_PARSE_FRAME
-    .capabilities   = CODEC_CAP_PARSE_ONLY,
+    .capabilities   = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
+#else
+    .capabilities   = CODEC_CAP_DR1,
 #endif
     .flush          = flush,
     .long_name      = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
     .init           = decode_init,
     .decode         = decode_frame,
 #if FF_API_PARSE_FRAME
-    .capabilities   = CODEC_CAP_PARSE_ONLY,
+    .capabilities   = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
+#else
+    .capabilities   = CODEC_CAP_DR1,
 #endif
     .flush          = flush,
     .long_name      = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
     .init           = decode_init,
     .decode         = decode_frame,
 #if FF_API_PARSE_FRAME
-    .capabilities   = CODEC_CAP_PARSE_ONLY,
+    .capabilities   = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
+#else
+    .capabilities   = CODEC_CAP_DR1,
 #endif
     .flush          = flush,
     .long_name      = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
     .init           = decode_init,
     .decode         = decode_frame_adu,
 #if FF_API_PARSE_FRAME
-    .capabilities   = CODEC_CAP_PARSE_ONLY,
+    .capabilities   = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
+#else
+    .capabilities   = CODEC_CAP_DR1,
 #endif
     .flush          = flush,
     .long_name      = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
     .init           = decode_init_mp3on4,
     .close          = decode_close_mp3on4,
     .decode         = decode_frame_mp3on4,
+    .capabilities   = CODEC_CAP_DR1,
     .flush          = flush_mp3on4,
     .long_name      = NULL_IF_CONFIG_SMALL("MP3onMP4"),
 };

libavcodec/mpegaudiodec_float.c+13−4

     .init           = decode_init,
     .decode         = decode_frame,
 #if FF_API_PARSE_FRAME
-    .capabilities   = CODEC_CAP_PARSE_ONLY,
+    .capabilities   = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
+#else
+    .capabilities   = CODEC_CAP_DR1,
 #endif
     .flush          = flush,
     .long_name      = NULL_IF_CONFIG_SMALL("MP1 (MPEG audio layer 1)"),
     .init           = decode_init,
     .decode         = decode_frame,
 #if FF_API_PARSE_FRAME
-    .capabilities   = CODEC_CAP_PARSE_ONLY,
+    .capabilities   = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
+#else
+    .capabilities   = CODEC_CAP_DR1,
 #endif
     .flush          = flush,
     .long_name      = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
     .init           = decode_init,
     .decode         = decode_frame,
 #if FF_API_PARSE_FRAME
-    .capabilities   = CODEC_CAP_PARSE_ONLY,
+    .capabilities   = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
+#else
+    .capabilities   = CODEC_CAP_DR1,
 #endif
     .flush          = flush,
     .long_name      = NULL_IF_CONFIG_SMALL("MP3 (MPEG audio layer 3)"),
     .init           = decode_init,
     .decode         = decode_frame_adu,
 #if FF_API_PARSE_FRAME
-    .capabilities   = CODEC_CAP_PARSE_ONLY,
+    .capabilities   = CODEC_CAP_PARSE_ONLY | CODEC_CAP_DR1,
+#else
+    .capabilities   = CODEC_CAP_DR1,
 #endif
     .flush          = flush,
     .long_name      = NULL_IF_CONFIG_SMALL("ADU (Application Data Unit) MP3 (MPEG audio layer 3)"),
     .init           = decode_init_mp3on4,
     .close          = decode_close_mp3on4,
     .decode         = decode_frame_mp3on4,
+    .capabilities   = CODEC_CAP_DR1,
     .flush          = flush_mp3on4,
     .long_name      = NULL_IF_CONFIG_SMALL("MP3onMP4"),
 };

libavcodec/mpegvideo.c+6−6

     if (s->avctx->draw_horiz_band) {
         AVFrame *src;
-        int offset[4];
+        int offset[AV_NUM_DATA_POINTERS];
+        int i;
         if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
             src= (AVFrame*)s->current_picture_ptr;
             return;
         if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
-            offset[0]=
+            for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
-            offset[1]=
+                offset[i] = 0;
-            offset[2]=
-            offset[3]= 0;
         }else{
             offset[0]= y * s->linesize;
             offset[1]=
             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
-            offset[3]= 0;
+            for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
+                offset[i] = 0;
         }
         emms_c();

libavcodec/nellymoserdec.c+26−14

@@ -47,6 +47,7 @@ · 46 unmodified lines
47		47
48	typedef struct NellyMoserDecodeContext {	48	typedef struct NellyMoserDecodeContext {
49	AVCodecContext* avctx;	49	AVCodecContext* avctx;
		50	AVFrame frame;
50	float *float_buf;	51	float *float_buf;
51	DECLARE_ALIGNED(16, float, state)[NELLY_BUF_LEN];	52	DECLARE_ALIGNED(16, float, state)[NELLY_BUF_LEN];
52	AVLFG random_state;	53	AVLFG random_state;
@@ -142,33 +143,31 @@ static av_cold int decode_init(AVCodecContext * avctx) { · 89 unmodified lines
142	ff_init_ff_sine_windows(7);	143	ff_init_ff_sine_windows(7);
143		144
144	avctx->channel_layout = AV_CH_LAYOUT_MONO;	145	avctx->channel_layout = AV_CH_LAYOUT_MONO;
		146
		147	avcodec_get_frame_defaults(&s->frame);
		148	avctx->coded_frame = &s->frame;
		149
145	return 0;	150	return 0;
146	}	151	}
147		152
148	static int decode_tag(AVCodecContext * avctx,	153	static int decode_tag(AVCodecContext avctx, void data,
149	void data, int data_size,	154	int got_frame_ptr, AVPacket avpkt)
150	AVPacket *avpkt) {	155	{
151	const uint8_t *buf = avpkt->data;	156	const uint8_t *buf = avpkt->data;
152	const uint8_t *side=av_packet_get_side_data(avpkt, 'F', NULL);	157	const uint8_t *side=av_packet_get_side_data(avpkt, 'F', NULL);
153	int buf_size = avpkt->size;	158	int buf_size = avpkt->size;
154	NellyMoserDecodeContext *s = avctx->priv_data;	159	NellyMoserDecodeContext *s = avctx->priv_data;
155	int data_max = *data_size;	160	int blocks, i, ret;
156	int blocks, i, block_size;	161	int16_t *samples_s16;
157	int16_t *samples_s16 = data;	162	float *samples_flt;
158	float *samples_flt = data;
159	*data_size = 0;
160		163
161	block_size = NELLY_SAMPLES * av_get_bytes_per_sample(avctx->sample_fmt);
162	blocks = buf_size / NELLY_BLOCK_LEN;	164	blocks = buf_size / NELLY_BLOCK_LEN;
163		165
164	if (blocks <= 0) {	166	if (blocks <= 0) {
165	av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");	167	av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
166	return AVERROR_INVALIDDATA;	168	return AVERROR_INVALIDDATA;
167	}	169	}
168	if (data_max < blocks * block_size) {	170
169	av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
170	return AVERROR(EINVAL);
171	}
172	if (buf_size % NELLY_BLOCK_LEN) {	171	if (buf_size % NELLY_BLOCK_LEN) {
173	av_log(avctx, AV_LOG_WARNING, "Leftover bytes: %d.\n",	172	av_log(avctx, AV_LOG_WARNING, "Leftover bytes: %d.\n",
174	buf_size % NELLY_BLOCK_LEN);	173	buf_size % NELLY_BLOCK_LEN);
@@ -183,6 +182,15 @@ static int decode_tag(AVCodecContext * avctx, · 8 unmodified lines
183	if(side && blocks>1 && avctx->sample_rate%11025==0 && (1<<((side[0]>>2)&3)) == blocks)	182	if(side && blocks>1 && avctx->sample_rate%11025==0 && (1<<((side[0]>>2)&3)) == blocks)
184	avctx->sample_rate= 11025*(blocks/2);	183	avctx->sample_rate= 11025*(blocks/2);
185		184
		185	/* get output buffer */
		186	s->frame.nb_samples = NELLY_SAMPLES * blocks;
		187	if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
		188	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		189	return ret;
		190	}
		191	samples_s16 = (int16_t *)s->frame.data[0];
		192	samples_flt = (float *)s->frame.data[0];
		193
186	for (i=0 ; i<blocks ; i++) {	194	for (i=0 ; i<blocks ; i++) {
187	if (avctx->sample_fmt == SAMPLE_FMT_FLT) {	195	if (avctx->sample_fmt == SAMPLE_FMT_FLT) {
188	nelly_decode_block(s, buf, samples_flt);	196	nelly_decode_block(s, buf, samples_flt);
@@ -194,7 +202,9 @@ static int decode_tag(AVCodecContext * avctx, · 5 unmodified lines
194	}	202	}
195	buf += NELLY_BLOCK_LEN;	203	buf += NELLY_BLOCK_LEN;
196	}	204	}
197	data_size = blocks block_size;	205
		206	*got_frame_ptr = 1;
		207	(AVFrame )data = s->frame;
198		208
199	return buf_size;	209	return buf_size;
200	}	210	}
@@ -204,6 +214,7 @@ static av_cold int decode_end(AVCodecContext * avctx) { · 3 unmodified lines
204		214
205	av_freep(&s->float_buf);	215	av_freep(&s->float_buf);
206	ff_mdct_end(&s->imdct_ctx);	216	ff_mdct_end(&s->imdct_ctx);
		217
207	return 0;	218	return 0;
208	}	219	}
209		220
@@ -215,6 +226,7 @@ AVCodec ff_nellymoser_decoder = { · 5 unmodified lines
215	.init = decode_init,	226	.init = decode_init,
216	.close = decode_end,	227	.close = decode_end,
217	.decode = decode_tag,	228	.decode = decode_tag,
		229	.capabilities = CODEC_CAP_DR1,
218	.long_name = NULL_IF_CONFIG_SMALL("Nellymoser Asao"),	230	.long_name = NULL_IF_CONFIG_SMALL("Nellymoser Asao"),
219	.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,	231	.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
220	AV_SAMPLE_FMT_S16,	232	AV_SAMPLE_FMT_S16,

libavcodec/pcm.c+25−17

@@ -192,6 +192,7 @@ static int pcm_encode_frame(AVCodecContext *avctx, · 191 unmodified lines
192	}	192	}
193		193
194	typedef struct PCMDecode {	194	typedef struct PCMDecode {
		195	AVFrame frame;
195	short table[256];	196	short table[256];
196	} PCMDecode;	197	} PCMDecode;
197		198
@@ -223,6 +224,9 @@ static av_cold int pcm_decode_init(AVCodecContext * avctx) · 25 unmodified lines
223	if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)	224	if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
224	avctx->bits_per_raw_sample = av_get_bits_per_sample(avctx->codec->id);	225	avctx->bits_per_raw_sample = av_get_bits_per_sample(avctx->codec->id);
225		226
		227	avcodec_get_frame_defaults(&s->frame);
		228	avctx->coded_frame = &s->frame;
		229
226	return 0;	230	return 0;
227	}	231	}
228		232
@@ -243,22 +247,20 @@ static av_cold int pcm_decode_init(AVCodecContext * avctx) · 14 unmodified lines
243	dst += size / 8; \	247	dst += size / 8; \
244	}	248	}
245		249
246	static int pcm_decode_frame(AVCodecContext *avctx,	250	static int pcm_decode_frame(AVCodecContext avctx, void data,
247	void data, int data_size,	251	int got_frame_ptr, AVPacket avpkt)
248	AVPacket *avpkt)
249	{	252	{
250	const uint8_t *src = avpkt->data;	253	const uint8_t *src = avpkt->data;
251	int buf_size = avpkt->size;	254	int buf_size = avpkt->size;
252	PCMDecode *s = avctx->priv_data;	255	PCMDecode *s = avctx->priv_data;
253	int sample_size, c, n, out_size;	256	int sample_size, c, n, ret, samples_per_block;
254	uint8_t *samples;	257	uint8_t *samples;
255	int32_t *dst_int32_t;	258	int32_t *dst_int32_t;
256		259
257	samples = data;
258
259	sample_size = av_get_bits_per_sample(avctx->codec_id)/8;	260	sample_size = av_get_bits_per_sample(avctx->codec_id)/8;
260		261
261	/* av_get_bits_per_sample returns 0 for CODEC_ID_PCM_DVD */	262	/* av_get_bits_per_sample returns 0 for CODEC_ID_PCM_DVD */
		263	samples_per_block = 1;
262	if (CODEC_ID_PCM_DVD == avctx->codec_id) {	264	if (CODEC_ID_PCM_DVD == avctx->codec_id) {
263	if (avctx->bits_per_coded_sample != 20 &&	265	if (avctx->bits_per_coded_sample != 20 &&
264	avctx->bits_per_coded_sample != 24) {	266	avctx->bits_per_coded_sample != 24) {
@@ -268,10 +270,13 @@ static int pcm_decode_frame(AVCodecContext *avctx, · 3 unmodified lines
268	return AVERROR(EINVAL);	270	return AVERROR(EINVAL);
269	}	271	}
270	/* 2 samples are interleaved per block in PCM_DVD */	272	/* 2 samples are interleaved per block in PCM_DVD */
		273	samples_per_block = 2;
271	sample_size = avctx->bits_per_coded_sample * 2 / 8;	274	sample_size = avctx->bits_per_coded_sample * 2 / 8;
272	} else if (avctx->codec_id == CODEC_ID_PCM_LXF)	275	} else if (avctx->codec_id == CODEC_ID_PCM_LXF) {
273	/* we process 40-bit blocks per channel for LXF */	276	/* we process 40-bit blocks per channel for LXF */
		277	samples_per_block = 2;
274	sample_size = 5;	278	sample_size = 5;
		279	}
275		280
276	if (sample_size == 0) {	281	if (sample_size == 0) {
277	av_log(avctx, AV_LOG_ERROR, "Invalid sample_size\n");	282	av_log(avctx, AV_LOG_ERROR, "Invalid sample_size\n");
@@ -290,14 +295,13 @@ static int pcm_decode_frame(AVCodecContext *avctx, · 12 unmodified lines
290		295
291	n = buf_size/sample_size;	296	n = buf_size/sample_size;
292		297
293	out_size = n * av_get_bytes_per_sample(avctx->sample_fmt);	298	/* get output buffer */
294	if (avctx->codec_id == CODEC_ID_PCM_DVD \|\|	299	s->frame.nb_samples = n * samples_per_block / avctx->channels;
295	avctx->codec_id == CODEC_ID_PCM_LXF)	300	if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
296	out_size *= 2;	301	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
297	if (*data_size < out_size) {	302	return ret;
298	av_log(avctx, AV_LOG_ERROR, "output buffer too small\n");
299	return AVERROR(EINVAL);
300	}	303	}
		304	samples = s->frame.data[0];
301		305
302	switch(avctx->codec->id) {	306	switch(avctx->codec->id) {
303	case CODEC_ID_PCM_U32LE:	307	case CODEC_ID_PCM_U32LE:
@@ -403,7 +407,7 @@ static int pcm_decode_frame(AVCodecContext *avctx, · 99 unmodified lines
403	case CODEC_ID_PCM_DVD:	407	case CODEC_ID_PCM_DVD:
404	{	408	{
405	const uint8_t *src8;	409	const uint8_t *src8;
406	dst_int32_t = data;	410	dst_int32_t = (int32_t *)s->frame.data[0];
407	n /= avctx->channels;	411	n /= avctx->channels;
408	switch (avctx->bits_per_coded_sample) {	412	switch (avctx->bits_per_coded_sample) {
409	case 20:	413	case 20:
@@ -435,7 +439,7 @@ static int pcm_decode_frame(AVCodecContext *avctx, · 25 unmodified lines
435	{	439	{
436	int i;	440	int i;
437	const uint8_t *src8;	441	const uint8_t *src8;
438	dst_int32_t = data;	442	dst_int32_t = (int32_t *)s->frame.data[0];
439	n /= avctx->channels;	443	n /= avctx->channels;
440	//unpack and de-planerize	444	//unpack and de-planerize
441	for (i = 0; i < n; i++) {	445	for (i = 0; i < n; i++) {
@@ -456,7 +460,10 @@ static int pcm_decode_frame(AVCodecContext *avctx, · 14 unmodified lines
456	default:	460	default:
457	return -1;	461	return -1;
458	}	462	}
459	*data_size = out_size;	463
		464	*got_frame_ptr = 1;
		465	(AVFrame )data = s->frame;
		466
460	return buf_size;	467	return buf_size;
461	}	468	}
462		469
@@ -485,6 +492,7 @@ AVCodec ff_ ## name_ ## _decoder = { \ · 22 unmodified lines
485	.priv_data_size = sizeof(PCMDecode), \	492	.priv_data_size = sizeof(PCMDecode), \
486	.init = pcm_decode_init, \	493	.init = pcm_decode_init, \
487	.decode = pcm_decode_frame, \	494	.decode = pcm_decode_frame, \
		495	.capabilities = CODEC_CAP_DR1, \
488	.sample_fmts = (const enum AVSampleFormat[]){sample_fmt_,AV_SAMPLE_FMT_NONE}, \	496	.sample_fmts = (const enum AVSampleFormat[]){sample_fmt_,AV_SAMPLE_FMT_NONE}, \
489	.long_name = NULL_IF_CONFIG_SMALL(long_name_), \	497	.long_name = NULL_IF_CONFIG_SMALL(long_name_), \
490	}	498	}

libavcodec/qcelpdec.c+17−9

 typedef struct
 {
+    AVFrame           avframe;
     GetBitContext     gb;
     qcelp_packet_rate bitrate;
     QCELPFrame        frame;    /**< unpacked data frame */
     for(i=0; i<10; i++)
         q->prev_lspf[i] = (i+1)/11.;
+    avcodec_get_frame_defaults(&q->avframe);
+    avctx->coded_frame = &q->avframe;
     return 0;
 }
         160, 0.9375, &q->postfilter_agc_mem);
 }
-static int qcelp_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
+static int qcelp_decode_frame(AVCodecContext *avctx, void *data,
-                              AVPacket *avpkt)
+                              int *got_frame_ptr, AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     QCELPContext *q = avctx->priv_data;
-    float *outbuffer = data;
+    float *outbuffer;
-    int   i, out_size;
+    int   i, ret;
     float quantized_lspf[10], lpc[10];
     float gain[16];
     float *formant_mem;
-    out_size = 160 * av_get_bytes_per_sample(avctx->sample_fmt);
+    /* get output buffer */
-    if (*data_size < out_size) {
+    q->avframe.nb_samples = 160;
-        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
+    if ((ret = avctx->get_buffer(avctx, &q->avframe)) < 0) {
-        return AVERROR(EINVAL);
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        return ret;
     }
+    outbuffer = (float *)q->avframe.data[0];
     if ((q->bitrate = determine_bitrate(avctx, buf_size, &buf)) == I_F_Q) {
         warn_insufficient_frame_quality(avctx, "bitrate cannot be determined.");
     memcpy(q->prev_lspf, quantized_lspf, sizeof(q->prev_lspf));
     q->prev_bitrate = q->bitrate;
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = q->avframe;
     return buf_size;
 }
     .id     = CODEC_ID_QCELP,
     .init   = qcelp_decode_init,
     .decode = qcelp_decode_frame,
+    .capabilities = CODEC_CAP_DR1,
     .priv_data_size = sizeof(QCELPContext),
     .long_name = NULL_IF_CONFIG_SMALL("QCELP / PureVoice"),
 };

libavcodec/qdm2.c+18−14

@@ -130,6 +130,8 @@ typedef struct { · 129 unmodified lines
130	* QDM2 decoder context	130	* QDM2 decoder context
131	*/	131	*/
132	typedef struct {	132	typedef struct {
		133	AVFrame frame;
		134
133	/// Parameters from codec header, do not change during playback	135	/// Parameters from codec header, do not change during playback
134	int nb_channels; ///< number of channels	136	int nb_channels; ///< number of channels
135	int channels; ///< number of channels	137	int channels; ///< number of channels
@@ -1876,6 +1878,9 @@ static av_cold int qdm2_decode_init(AVCodecContext *avctx) · 1740 unmodified lines
1876		1878
1877	avctx->sample_fmt = AV_SAMPLE_FMT_S16;	1879	avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1878		1880
		1881	avcodec_get_frame_defaults(&s->frame);
		1882	avctx->coded_frame = &s->frame;
		1883
1879	// dump_context(s);	1884	// dump_context(s);
1880	return 0;	1885	return 0;
1881	}	1886	}
@@ -1956,30 +1961,27 @@ static int qdm2_decode (QDM2Context q, const uint8_t in, int16_t *out) · 74 unmodified lines
1956	}	1961	}
1957		1962
1958		1963
1959	static int qdm2_decode_frame(AVCodecContext *avctx,	1964	static int qdm2_decode_frame(AVCodecContext avctx, void data,
1960	void data, int data_size,	1965	int got_frame_ptr, AVPacket avpkt)
1961	AVPacket *avpkt)
1962	{	1966	{
1963	const uint8_t *buf = avpkt->data;	1967	const uint8_t *buf = avpkt->data;
1964	int buf_size = avpkt->size;	1968	int buf_size = avpkt->size;
1965	QDM2Context *s = avctx->priv_data;	1969	QDM2Context *s = avctx->priv_data;
1966	int16_t *out = data;	1970	int16_t *out;
1967	int i, out_size;	1971	int i, ret;
1968		1972
1969	if(!buf)	1973	if(!buf)
1970	return 0;	1974	return 0;
1971	if(buf_size < s->checksum_size)	1975	if(buf_size < s->checksum_size)
1972	return -1;	1976	return -1;
1973		1977
1974	out_size = 16 * s->channels * s->frame_size *	1978	/* get output buffer */
1975	av_get_bytes_per_sample(avctx->sample_fmt);	1979	s->frame.nb_samples = 16 * s->frame_size;
1976	if (*data_size < out_size) {	1980	if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
1977	av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");	1981	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1978	return AVERROR(EINVAL);	1982	return ret;
1979	}	1983	}
1980		1984	out = (int16_t *)s->frame.data[0];
1981	av_log(avctx, AV_LOG_DEBUG, "decode(%d): %p[%d] -> %p[%d]\n",
1982	buf_size, buf, s->checksum_size, data, *data_size);
1983		1985
1984	for (i = 0; i < 16; i++) {	1986	for (i = 0; i < 16; i++) {
1985	if (qdm2_decode(s, buf, out) < 0)	1987	if (qdm2_decode(s, buf, out) < 0)
@@ -1987,7 +1989,8 @@ static int qdm2_decode_frame(AVCodecContext *avctx, · 1 unmodified line
1987	out += s->channels * s->frame_size;	1989	out += s->channels * s->frame_size;
1988	}	1990	}
1989		1991
1990	*data_size = out_size;	1992	*got_frame_ptr = 1;
		1993	(AVFrame )data = s->frame;
1991		1994
1992	return s->checksum_size;	1995	return s->checksum_size;
1993	}	1996	}
@@ -2001,5 +2004,6 @@ AVCodec ff_qdm2_decoder = · 7 unmodified lines
2001	.init = qdm2_decode_init,	2004	.init = qdm2_decode_init,
2002	.close = qdm2_decode_close,	2005	.close = qdm2_decode_close,
2003	.decode = qdm2_decode_frame,	2006	.decode = qdm2_decode_frame,
		2007	.capabilities = CODEC_CAP_DR1,
2004	.long_name = NULL_IF_CONFIG_SMALL("QDesign Music Codec 2"),	2008	.long_name = NULL_IF_CONFIG_SMALL("QDesign Music Codec 2"),
2005	};	2009	};

libavcodec/ra144.h+1−0

@@ -34,6 +34,7 @@ · 33 unmodified lines
34		34
35	typedef struct {	35	typedef struct {
36	AVCodecContext *avctx;	36	AVCodecContext *avctx;
		37	AVFrame frame;
37	LPCContext lpc_ctx;	38	LPCContext lpc_ctx;
38		39
39	unsigned int old_energy; ///< previous frame energy	40	unsigned int old_energy; ///< previous frame energy

libavcodec/ra144dec.c+20−11

     ractx->lpc_coef[1] = ractx->lpc_tables[1];
     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
+    avcodec_get_frame_defaults(&ractx->frame);
+    avctx->coded_frame = &ractx->frame;
     return 0;
 }
 }
 /** Uncompress one block (20 bytes -> 160*2 bytes). */
-static int ra144_decode_frame(AVCodecContext * avctx, void *vdata,
+static int ra144_decode_frame(AVCodecContext * avctx, void *data,
-                              int *data_size, AVPacket *avpkt)
+                              int *got_frame_ptr, AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     uint16_t block_coefs[NBLOCKS][LPC_ORDER]; // LPC coefficients of each sub-block
     unsigned int lpc_refl[LPC_ORDER];         // LPC reflection coefficients of the frame
     int i, j;
-    int out_size;
+    int ret;
-    int16_t *data = vdata;
+    int16_t *samples;
     unsigned int energy;
     RA144Context *ractx = avctx->priv_data;
     GetBitContext gb;
-    out_size = NBLOCKS * BLOCKSIZE * av_get_bytes_per_sample(avctx->sample_fmt);
+    /* get output buffer */
-    if (*data_size < out_size) {
+    ractx->frame.nb_samples = NBLOCKS * BLOCKSIZE;
-        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
+    if ((ret = avctx->get_buffer(avctx, &ractx->frame)) < 0) {
-        return AVERROR(EINVAL);
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        return ret;
     }
+    samples = (int16_t *)ractx->frame.data[0];
     if(buf_size < FRAMESIZE) {
         av_log(avctx, AV_LOG_ERROR,
                "Frame too small (%d bytes). Truncated file?\n", buf_size);
-        *data_size = 0;
+        *got_frame_ptr = 0;
         return buf_size;
     }
     init_get_bits(&gb, buf, FRAMESIZE * 8);
         do_output_subblock(ractx, block_coefs[i], refl_rms[i], &gb);
         for (j=0; j < BLOCKSIZE; j++)
-            *data++ = av_clip_int16(ractx->curr_sblock[j + 10] << 2);
+            *samples++ = av_clip_int16(ractx->curr_sblock[j + 10] << 2);
     }
     ractx->old_energy = energy;
     FFSWAP(unsigned int *, ractx->lpc_coef[0], ractx->lpc_coef[1]);
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = ractx->frame;
     return FRAMESIZE;
 }
     .priv_data_size = sizeof(RA144Context),
     .init           = ra144_decode_init,
     .decode         = ra144_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name      = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K)"),
 };

libavcodec/ra288.c+18−9

 #define RA288_BLOCKS_PER_FRAME 32
 typedef struct {
+    AVFrame frame;
     DSPContext dsp;
     DECLARE_ALIGNED(16, float,   sp_lpc)[FFALIGN(36, 8)];   ///< LPC coefficients for speech data (spec: A)
     DECLARE_ALIGNED(16, float, gain_lpc)[FFALIGN(10, 8)];   ///< LPC coefficients for gain        (spec: GB)
     RA288Context *ractx = avctx->priv_data;
     avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
     dsputil_init(&ractx->dsp, avctx);
+    avcodec_get_frame_defaults(&ractx->frame);
+    avctx->coded_frame = &ractx->frame;
     return 0;
 }
 }
 static int ra288_decode_frame(AVCodecContext * avctx, void *data,
-                              int *data_size, AVPacket *avpkt)
+                              int *got_frame_ptr, AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
-    float *out = data;
+    float *out;
-    int i, out_size;
+    int i, ret;
     RA288Context *ractx = avctx->priv_data;
     GetBitContext gb;
         return AVERROR_INVALIDDATA;
     }
-    out_size = RA288_BLOCK_SIZE * RA288_BLOCKS_PER_FRAME *
+    /* get output buffer */
-               av_get_bytes_per_sample(avctx->sample_fmt);
+    ractx->frame.nb_samples = RA288_BLOCK_SIZE * RA288_BLOCKS_PER_FRAME;
-    if (*data_size < out_size) {
+    if ((ret = avctx->get_buffer(avctx, &ractx->frame)) < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-        return AVERROR(EINVAL);
+        return ret;
     }
+    out = (float *)ractx->frame.data[0];
     init_get_bits(&gb, buf, avctx->block_align * 8);
         }
     }
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = ractx->frame;
     return avctx->block_align;
 }
     .priv_data_size = sizeof(RA288Context),
     .init           = ra288_decode_init,
     .decode         = ra288_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name      = NULL_IF_CONFIG_SMALL("RealAudio 2.0 (28.8K)"),
 };

libavcodec/s302m.c+36−10

 #define AES3_HEADER_LEN 4
+typedef struct S302MDecodeContext {
+    AVFrame frame;
+} S302MDecodeContext;
 static int s302m_parse_frame_header(AVCodecContext *avctx, const uint8_t *buf,
                                     int buf_size)
 {
 }
 static int s302m_decode_frame(AVCodecContext *avctx, void *data,
-                              int *data_size, AVPacket *avpkt)
+                              int *got_frame_ptr, AVPacket *avpkt)
 {
+    S302MDecodeContext *s = avctx->priv_data;
     const uint8_t *buf = avpkt->data;
     int buf_size       = avpkt->size;
+    int block_size, ret;
     int frame_size = s302m_parse_frame_header(avctx, buf, buf_size);
     if (frame_size < 0)
     buf_size -= AES3_HEADER_LEN;
     buf      += AES3_HEADER_LEN;
-    if (*data_size < 4 * buf_size * 8 / (avctx->bits_per_coded_sample + 4))
+    /* get output buffer */
-        return -1;
+    block_size = (avctx->bits_per_coded_sample + 4) / 4;
+    s->frame.nb_samples = 2 * (buf_size / block_size) / avctx->channels;
+    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        return ret;
+    }
+    buf_size = (s->frame.nb_samples * avctx->channels / 2) * block_size;
     if (avctx->bits_per_coded_sample == 24) {
-        uint32_t *o = data;
+        uint32_t *o = (uint32_t *)s->frame.data[0];
         for (; buf_size > 6; buf_size -= 7) {
             *o++ = (av_reverse[buf[2]]        << 24) |
                    (av_reverse[buf[1]]        << 16) |
                    (av_reverse[buf[3] & 0x0f] <<  4);
             buf += 7;
         }
-        *data_size = (uint8_t*) o - (uint8_t*) data;
     } else if (avctx->bits_per_coded_sample == 20) {
-        uint32_t *o = data;
+        uint32_t *o = (uint32_t *)s->frame.data[0];
         for (; buf_size > 5; buf_size -= 6) {
             *o++ = (av_reverse[buf[2] & 0xf0] << 28) |
                    (av_reverse[buf[1]]        << 20) |
                    (av_reverse[buf[3]]        << 12);
             buf += 6;
         }
-        *data_size = (uint8_t*) o - (uint8_t*) data;
     } else {
-        uint16_t *o = data;
+        uint16_t *o = (uint16_t *)s->frame.data[0];
         for (; buf_size > 4; buf_size -= 5) {
             *o++ = (av_reverse[buf[1]]        <<  8) |
                     av_reverse[buf[0]];
                    (av_reverse[buf[2]]        >>  4);
             buf += 5;
         }
-        *data_size = (uint8_t*) o - (uint8_t*) data;
     }
-    return buf - avpkt->data;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = s->frame;
+    return avpkt->size;
+}
+static int s302m_decode_init(AVCodecContext *avctx)
+{
+    S302MDecodeContext *s = avctx->priv_data;
+    avcodec_get_frame_defaults(&s->frame);
+    avctx->coded_frame = &s->frame;
+    return 0;
 }
     .name           = "s302m",
     .type           = AVMEDIA_TYPE_AUDIO,
     .id             = CODEC_ID_S302M,
+    .priv_data_size = sizeof(S302MDecodeContext),
+    .init           = s302m_decode_init,
     .decode         = s302m_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE 302M"),
 };

libavcodec/shorten.c+26−19

 typedef struct ShortenContext {
     AVCodecContext *avctx;
+    AVFrame frame;
     GetBitContext gb;
     int min_framesize, max_framesize;
     s->avctx = avctx;
     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
+    avcodec_get_frame_defaults(&s->frame);
+    avctx->coded_frame = &s->frame;
     return 0;
 }
     return 0;
 }
-static int shorten_decode_frame(AVCodecContext *avctx,
+static int shorten_decode_frame(AVCodecContext *avctx, void *data,
-        void *data, int *data_size,
+                                int *got_frame_ptr, AVPacket *avpkt)
-        AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     ShortenContext *s = avctx->priv_data;
     int i, input_buf_size = 0;
-    int16_t *samples = data;
     int ret;
     /* allocate internal bitstream buffer */
         /* do not decode until buffer has at least max_framesize bytes or
            the end of the file has been reached */
         if (buf_size < s->max_framesize && avpkt->data) {
-            *data_size = 0;
+            *got_frame_ptr = 0;
             return input_buf_size;
         }
     }
     if (!s->got_header) {
         if ((ret = read_header(s)) < 0)
             return ret;
-        *data_size = 0;
+        *got_frame_ptr = 0;
         goto finish_frame;
     }
     /* if quit command was read previously, don't decode anything */
     if (s->got_quit_command) {
-        *data_size = 0;
+        *got_frame_ptr = 0;
         return avpkt->size;
     }
         int len;
         if (get_bits_left(&s->gb) < 3+FNSIZE) {
-            *data_size = 0;
+            *got_frame_ptr = 0;
             break;
         }
         if (cmd > FN_VERBATIM) {
             av_log(avctx, AV_LOG_ERROR, "unknown shorten function %d\n", cmd);
-            *data_size = 0;
+            *got_frame_ptr = 0;
             break;
         }
                     break;
             }
             if (cmd == FN_BLOCKSIZE || cmd == FN_QUIT) {
-                *data_size = 0;
+                *got_frame_ptr = 0;
                 break;
             }
         } else {
             /* if this is the last channel in the block, output the samples */
             s->cur_chan++;
             if (s->cur_chan == s->channels) {
-                int out_size = s->blocksize * s->channels *
+                /* get output buffer */
-                               av_get_bytes_per_sample(avctx->sample_fmt);
+                s->frame.nb_samples = s->blocksize;
-                if (*data_size < out_size) {
+                if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
-                    av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
+                    av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-                    return AVERROR(EINVAL);
+                    return ret;
                 }
-                interleave_buffer(samples, s->channels, s->blocksize, s->decoded);
+                /* interleave output */
-                *data_size = out_size;
+                interleave_buffer((int16_t *)s->frame.data[0], s->channels,
+                                  s->blocksize, s->decoded);
+                *got_frame_ptr   = 1;
+                *(AVFrame *)data = s->frame;
             }
         }
     }
     if (s->cur_chan < s->channels)
-        *data_size = 0;
+        *got_frame_ptr = 0;
 finish_frame:
     s->bitindex = get_bits_count(&s->gb) - 8*((get_bits_count(&s->gb))/8);
     }
     av_freep(&s->bitstream);
     av_freep(&s->coeffs);
     return 0;
 }
     .init           = shorten_decode_init,
     .close          = shorten_decode_close,
     .decode         = shorten_decode_frame,
-    .capabilities   = CODEC_CAP_DELAY,
+    .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_DR1,
     .long_name= NULL_IF_CONFIG_SMALL("Shorten"),
 };

libavcodec/sipr.c+19−15

     avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
+    avcodec_get_frame_defaults(&ctx->frame);
+    avctx->coded_frame = &ctx->frame;
     return 0;
 }
-static int sipr_decode_frame(AVCodecContext *avctx, void *datap,
+static int sipr_decode_frame(AVCodecContext *avctx, void *data,
-                             int *data_size, AVPacket *avpkt)
+                             int *got_frame_ptr, AVPacket *avpkt)
 {
     SiprContext *ctx = avctx->priv_data;
     const uint8_t *buf=avpkt->data;
     SiprParameters parm;
     const SiprModeParam *mode_par = &modes[ctx->mode];
     GetBitContext gb;
-    float *data = datap;
+    float *samples;
     int subframe_size = ctx->mode == MODE_16k ? L_SUBFR_16k : SUBFR_SIZE;
-    int i, out_size;
+    int i, ret;
     ctx->avctx = avctx;
     if (avpkt->size < (mode_par->bits_per_frame >> 3)) {
         return -1;
     }
-    out_size = mode_par->frames_per_packet * subframe_size *
+    /* get output buffer */
-               mode_par->subframe_count *
+    ctx->frame.nb_samples = mode_par->frames_per_packet * subframe_size *
-               av_get_bytes_per_sample(avctx->sample_fmt);
+                            mode_par->subframe_count;
-    if (*data_size < out_size) {
+    if ((ret = avctx->get_buffer(avctx, &ctx->frame)) < 0) {
-        av_log(avctx, AV_LOG_ERROR,
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-               "Error processing packet: output buffer (%d) too small\n",
+        return ret;
-               *data_size);
-        return -1;
     }
+    samples = (float *)ctx->frame.data[0];
     init_get_bits(&gb, buf, mode_par->bits_per_frame);
     for (i = 0; i < mode_par->frames_per_packet; i++) {
         decode_parameters(&parm, &gb, mode_par);
-        ctx->decode_frame(ctx, &parm, data);
+        ctx->decode_frame(ctx, &parm, samples);
-        data += subframe_size * mode_par->subframe_count;
+        samples += subframe_size * mode_par->subframe_count;
     }
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = ctx->frame;
     return mode_par->bits_per_frame >> 3;
 }
     .priv_data_size = sizeof(SiprContext),
     .init           = sipr_decoder_init,
     .decode         = sipr_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("RealAudio SIPR / ACELP.NET"),
 };

libavcodec/smacker.c+31−10

 }
+typedef struct SmackerAudioContext {
+    AVFrame frame;
+} SmackerAudioContext;
 static av_cold int smka_decode_init(AVCodecContext *avctx)
 {
+    SmackerAudioContext *s = avctx->priv_data;
     if (avctx->channels < 1 || avctx->channels > 2) {
         av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
         return AVERROR(EINVAL);
     }
     avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
     avctx->sample_fmt = avctx->bits_per_coded_sample == 8 ? AV_SAMPLE_FMT_U8 : AV_SAMPLE_FMT_S16;
+    avcodec_get_frame_defaults(&s->frame);
+    avctx->coded_frame = &s->frame;
     return 0;
 }
 /**
  * Decode Smacker audio data
  */
-static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
+static int smka_decode_frame(AVCodecContext *avctx, void *data,
+                             int *got_frame_ptr, AVPacket *avpkt)
 {
+    SmackerAudioContext *s = avctx->priv_data;
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     GetBitContext gb;
     HuffContext h[4];
     VLC vlc[4];
-    int16_t *samples = data;
+    int16_t *samples;
-    uint8_t *samples8 = data;
+    uint8_t *samples8;
     int val;
-    int i, res;
+    int i, res, ret;
     int unp_size;
     int bits, stereo;
     int pred[2] = {0, 0};
     if(!get_bits1(&gb)){
         av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
-        *data_size = 0;
+        *got_frame_ptr = 0;
         return 1;
     }
     stereo = get_bits1(&gb);
     bits = get_bits1(&gb);
-    if (unp_size & 0xC0000000 || unp_size > *data_size) {
-        av_log(avctx, AV_LOG_ERROR, "Frame is too large to fit in buffer\n");
-        return -1;
-    }
     if (stereo ^ (avctx->channels != 1)) {
         av_log(avctx, AV_LOG_ERROR, "channels mismatch\n");
         return AVERROR(EINVAL);
         return AVERROR(EINVAL);
     }
+    /* get output buffer */
+    s->frame.nb_samples = unp_size / (avctx->channels * (bits + 1));
+    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        return ret;
+    }
+    samples  = (int16_t *)s->frame.data[0];
+    samples8 =            s->frame.data[0];
     memset(vlc, 0, sizeof(VLC) * 4);
     memset(h, 0, sizeof(HuffContext) * 4);
     // Initialize
         av_free(h[i].values);
     }
-    *data_size = unp_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = s->frame;
     return buf_size;
 }
     .name           = "smackaud",
     .type           = AVMEDIA_TYPE_AUDIO,
     .id             = CODEC_ID_SMACKAUDIO,
+    .priv_data_size = sizeof(SmackerAudioContext),
     .init           = smka_decode_init,
     .decode         = smka_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Smacker audio"),
 };

libavcodec/svq1dec.c+2−1

@@ -195,7 +195,8 @@ static const uint8_t string_table[256] = { · 194 unmodified lines
195		195
196	#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\	196	#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
197	codebook = (const uint32_t *) cbook[level];\	197	codebook = (const uint32_t *) cbook[level];\
198	bit_cache = get_bits (bitbuf, 4*stages);\	198	if (stages > 0)\
		199	bit_cache = get_bits (bitbuf, 4*stages);\
199	/* calculate codebook entries for this vector */\	200	/* calculate codebook entries for this vector */\
200	for (j=0; j < stages; j++) {\	201	for (j=0; j < stages; j++) {\
201	entries[j] = (((bit_cache >> (4(stages - j - 1))) & 0xF) + 16j) << (level + 1);\	202	entries[j] = (((bit_cache >> (4(stages - j - 1))) & 0xF) + 16j) << (level + 1);\

libavcodec/truespeech.c+18−11

  * TrueSpeech decoder context
  */
 typedef struct {
+    AVFrame frame;
     DSPContext dsp;
     /* input data */
     uint8_t buffer[32];
     dsputil_init(&c->dsp, avctx);
+    avcodec_get_frame_defaults(&c->frame);
+    avctx->coded_frame = &c->frame;
     return 0;
 }
         c->prevfilt[i] = c->cvector[i];
 }
-static int truespeech_decode_frame(AVCodecContext *avctx,
+static int truespeech_decode_frame(AVCodecContext *avctx, void *data,
-                void *data, int *data_size,
+                                   int *got_frame_ptr, AVPacket *avpkt)
-                AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     TSContext *c = avctx->priv_data;
     int i, j;
-    short *samples = data;
+    int16_t *samples;
-    int iterations, out_size;
+    int iterations, ret;
     iterations = buf_size / 32;
         return -1;
     }
-    out_size = iterations * 240 * av_get_bytes_per_sample(avctx->sample_fmt);
+    /* get output buffer */
-    if (*data_size < out_size) {
+    c->frame.nb_samples = iterations * 240;
-        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
+    if ((ret = avctx->get_buffer(avctx, &c->frame)) < 0) {
-        return AVERROR(EINVAL);
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        return ret;
     }
+    samples = (int16_t *)c->frame.data[0];
-    memset(samples, 0, out_size);
+    memset(samples, 0, iterations * 240 * sizeof(*samples));
     for(j = 0; j < iterations; j++) {
         truespeech_read_frame(c, buf);
         truespeech_save_prevvec(c);
     }
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = c->frame;
     return buf_size;
 }
     .priv_data_size = sizeof(TSContext),
     .init           = truespeech_decode_init,
     .decode         = truespeech_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("DSP Group TrueSpeech"),
 };

libavcodec/tta.c+18−12

 typedef struct TTAContext {
     AVCodecContext *avctx;
+    AVFrame frame;
     GetBitContext gb;
     int format, channels, bps, data_length;
         return -1;
     }
+    avcodec_get_frame_defaults(&s->frame);
+    avctx->coded_frame = &s->frame;
     return 0;
 }
-static int tta_decode_frame(AVCodecContext *avctx,
+static int tta_decode_frame(AVCodecContext *avctx, void *data,
-        void *data, int *data_size,
+                            int *got_frame_ptr, AVPacket *avpkt)
-        AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     TTAContext *s = avctx->priv_data;
-    int i, out_size;
+    int i, ret;
     int cur_chan = 0, framelen = s->frame_length;
     int32_t *p;
     if (!s->total_frames && s->last_frame_length)
         framelen = s->last_frame_length;
-    out_size = framelen * s->channels * av_get_bytes_per_sample(avctx->sample_fmt);
+    /* get output buffer */
-    if (*data_size < out_size) {
+    s->frame.nb_samples = framelen;
-        av_log(avctx, AV_LOG_ERROR, "Output buffer size is too small.\n");
+    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
-        return -1;
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        return ret;
     }
     // decode directly to output buffer for 24-bit sample format
         // convert to output buffer
         switch(s->bps) {
             case 1: {
-                uint8_t *samples = data;
+                uint8_t *samples = (int16_t *)s->frame.data[0];
                 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
                     *samples++ = *p + 0x80;
                 break;
             }
             case 2: {
-                uint16_t *samples = data;
+                uint16_t *samples = (int16_t *)s->frame.data[0];
                 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
                     *samples++ = *p;
                 break;
             }
             case 3: {
                 // shift samples for 24-bit sample format
-                int32_t *samples = data;
+                int32_t *samples = (int16_t *)s->frame.data[0];
                 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
                     *samples++ <<= 8;
                 // reset decode buffer
                 av_log(s->avctx, AV_LOG_ERROR, "Error, only 16bit samples supported!\n");
         }
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = s->frame;
     return buf_size;
 }
     .init           = tta_decode_init,
     .close          = tta_decode_close,
     .decode         = tta_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
 };

libavcodec/twinvq.c+25−11

 typedef struct TwinContext {
     AVCodecContext *avctx;
+    AVFrame frame;
     DSPContext      dsp;
     FFTContext mdct_ctx[3];
     float *curr_frame;               ///< non-interleaved output
     float *prev_frame;               ///< non-interleaved previous frame
     int last_block_pos[2];
+    int discarded_packets;
     float *cos_tabs[3];
                          i);
     }
+    if (!out)
+        return;
     size2 = tctx->last_block_pos[0];
     size1 = mtab->size - size2;
     if (tctx->avctx->channels == 2) {
 }
 static int twin_decode_frame(AVCodecContext * avctx, void *data,
-                             int *data_size, AVPacket *avpkt)
+                             int *got_frame_ptr, AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     TwinContext *tctx = avctx->priv_data;
     GetBitContext gb;
     const ModeTab *mtab = tctx->mtab;
-    float *out = data;
+    float *out = NULL;
     enum FrameType ftype;
-    int window_type, out_size;
+    int window_type, ret;
     static const enum FrameType wtype_to_ftype_table[] = {
         FT_LONG,   FT_LONG, FT_SHORT, FT_LONG,
         FT_MEDIUM, FT_LONG, FT_LONG,  FT_MEDIUM, FT_MEDIUM
         return AVERROR(EINVAL);
     }
-    out_size = mtab->size * avctx->channels *
+    /* get output buffer */
-               av_get_bytes_per_sample(avctx->sample_fmt);
+    if (tctx->discarded_packets >= 2) {
-    if (*data_size < out_size) {
+        tctx->frame.nb_samples = mtab->size;
-        av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");
+        if ((ret = avctx->get_buffer(avctx, &tctx->frame)) < 0) {
-        return AVERROR(EINVAL);
+            av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+            return ret;
+        }
+        out = (float *)tctx->frame.data[0];
     }
     init_get_bits(&gb, buf, buf_size * 8);
     FFSWAP(float*, tctx->curr_frame, tctx->prev_frame);
-    if (tctx->avctx->frame_number < 2) {
+    if (tctx->discarded_packets < 2) {
-        *data_size=0;
+        tctx->discarded_packets++;
+        *got_frame_ptr = 0;
         return buf_size;
     }
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = tctx->frame;;
     return buf_size;
 }
     memset_float(tctx->bark_hist[0][0], 0.1, FF_ARRAY_ELEMS(tctx->bark_hist));
+    avcodec_get_frame_defaults(&tctx->frame);
+    avctx->coded_frame = &tctx->frame;
     return 0;
 }
     .init           = twin_decode_init,
     .close          = twin_decode_close,
     .decode         = twin_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name      = NULL_IF_CONFIG_SMALL("VQF TwinVQ"),
 };

libavcodec/utils.c+224−33

@@ -127,7 +127,10 @@ void avcodec_set_dimensions(AVCodecContext *s, int width, int height){ · 126 unmodified lines
127		127
128	#define INTERNAL_BUFFER_SIZE (32+1)	128	#define INTERNAL_BUFFER_SIZE (32+1)
129		129
130	void avcodec_align_dimensions2(AVCodecContext s, int width, int *height, int linesize_align[4]){	130	void avcodec_align_dimensions2(AVCodecContext s, int width, int *height,
		131	int linesize_align[AV_NUM_DATA_POINTERS])
		132	{
		133	int i;
131	int w_align= 1;	134	int w_align= 1;
132	int h_align= 1;	135	int h_align= 1;
133		136
@@ -213,10 +216,8 @@ void avcodec_align_dimensions2(AVCodecContext s, int width, int *height, int l · 79 unmodified lines
213	*height+=2; // some of the optimized chroma MC reads one line too much	216	*height+=2; // some of the optimized chroma MC reads one line too much
214	// which is also done in mpeg decoders with lowres > 0	217	// which is also done in mpeg decoders with lowres > 0
215		218
216	linesize_align[0] =	219	for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
217	linesize_align[1] =	220	linesize_align[i] = STRIDE_ALIGN;
218	linesize_align[2] =
219	linesize_align[3] = STRIDE_ALIGN;
220	//STRIDE_ALIGN is 8 for SSE* but this does not work for SVQ1 chroma planes	221	//STRIDE_ALIGN is 8 for SSE* but this does not work for SVQ1 chroma planes
221	//we could change STRIDE_ALIGN to 16 for x86/sse but it would increase the	222	//we could change STRIDE_ALIGN to 16 for x86/sse but it would increase the
222	//picture size unneccessarily in some cases. The solution here is not	223	//picture size unneccessarily in some cases. The solution here is not
@@ -225,16 +226,15 @@ void avcodec_align_dimensions2(AVCodecContext s, int width, int *height, int l · 2 unmodified lines
225	if(s->codec_id == CODEC_ID_SVQ1 \|\| s->codec_id == CODEC_ID_VP5 \|\|	226	if(s->codec_id == CODEC_ID_SVQ1 \|\| s->codec_id == CODEC_ID_VP5 \|\|
226	s->codec_id == CODEC_ID_VP6 \|\| s->codec_id == CODEC_ID_VP6F \|\|	227	s->codec_id == CODEC_ID_VP6 \|\| s->codec_id == CODEC_ID_VP6F \|\|
227	s->codec_id == CODEC_ID_VP6A \|\| s->codec_id == CODEC_ID_DIRAC) {	228	s->codec_id == CODEC_ID_VP6A \|\| s->codec_id == CODEC_ID_DIRAC) {
228	linesize_align[0] =	229	for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
229	linesize_align[1] =	230	linesize_align[i] = 16;
230	linesize_align[2] = 16;
231	}	231	}
232	#endif	232	#endif
233	}	233	}
234		234
235	void avcodec_align_dimensions(AVCodecContext s, int width, int *height){	235	void avcodec_align_dimensions(AVCodecContext s, int width, int *height){
236	int chroma_shift = av_pix_fmt_descriptors[s->pix_fmt].log2_chroma_w;	236	int chroma_shift = av_pix_fmt_descriptors[s->pix_fmt].log2_chroma_w;
237	int linesize_align[4];	237	int linesize_align[AV_NUM_DATA_POINTERS];
238	int align;	238	int align;
239	avcodec_align_dimensions2(s, width, height, linesize_align);	239	avcodec_align_dimensions2(s, width, height, linesize_align);
240	align = FFMAX(linesize_align[0], linesize_align[3]);	240	align = FFMAX(linesize_align[0], linesize_align[3]);
@@ -260,7 +260,108 @@ void ff_init_buffer_info(AVCodecContext s, AVFrame pic) · 19 unmodified lines
260	pic->format = s->pix_fmt;	260	pic->format = s->pix_fmt;
261	}	261	}
262		262
263	int avcodec_default_get_buffer(AVCodecContext s, AVFrame pic){	263	static int audio_get_buffer(AVCodecContext avctx, AVFrame frame)
		264	{
		265	AVCodecInternal *avci = avctx->internal;
		266	InternalBuffer *buf;
		267	int buf_size, ret, i, needs_extended_data;
		268
		269	buf_size = av_samples_get_buffer_size(NULL, avctx->channels,
		270	frame->nb_samples, avctx->sample_fmt,
		271	32);
		272	if (buf_size < 0)
		273	return AVERROR(EINVAL);
		274
		275	needs_extended_data = av_sample_fmt_is_planar(avctx->sample_fmt) &&
		276	avctx->channels > AV_NUM_DATA_POINTERS;
		277
		278	/* allocate InternalBuffer if needed */
		279	if (!avci->buffer) {
		280	avci->buffer = av_mallocz(sizeof(InternalBuffer));
		281	if (!avci->buffer)
		282	return AVERROR(ENOMEM);
		283	}
		284	buf = avci->buffer;
		285
		286	/* if there is a previously-used internal buffer, check its size and
		287	channel count to see if we can reuse it */
		288	if (buf->extended_data) {
		289	/* if current buffer is too small, free it */
		290	if (buf->extended_data[0] && buf_size > buf->audio_data_size) {
		291	av_free(buf->extended_data[0]);
		292	if (buf->extended_data != buf->data)
		293	av_free(&buf->extended_data);
		294	buf->extended_data = NULL;
		295	buf->data[0] = NULL;
		296	}
		297	/* if number of channels has changed, reset and/or free extended data
		298	pointers but leave data buffer in buf->data[0] for reuse */
		299	if (buf->nb_channels != avctx->channels) {
		300	if (buf->extended_data != buf->data)
		301	av_free(buf->extended_data);
		302	buf->extended_data = NULL;
		303	}
		304	}
		305
		306	/* if there is no previous buffer or the previous buffer cannot be used
		307	as-is, allocate a new buffer and/or rearrange the channel pointers */
		308	if (!buf->extended_data) {
		309	/* if the channel pointers will fit, just set extended_data to data,
		310	otherwise allocate the extended_data channel pointers */
		311	if (needs_extended_data) {
		312	buf->extended_data = av_mallocz(avctx->channels *
		313	sizeof(*buf->extended_data));
		314	if (!buf->extended_data)
		315	return AVERROR(ENOMEM);
		316	} else {
		317	buf->extended_data = buf->data;
		318	}
		319
		320	/* if there is a previous buffer and it is large enough, reuse it and
		321	just fill-in new channel pointers and linesize, otherwise allocate
		322	a new buffer */
		323	if (buf->extended_data[0]) {
		324	ret = av_samples_fill_arrays(buf->extended_data, &buf->linesize[0],
		325	buf->extended_data[0], avctx->channels,
		326	frame->nb_samples, avctx->sample_fmt,
		327	32);
		328	} else {
		329	ret = av_samples_alloc(buf->extended_data, &buf->linesize[0],
		330	avctx->channels, frame->nb_samples,
		331	avctx->sample_fmt, 32);
		332	}
		333	if (ret)
		334	return ret;
		335
		336	/* if data was not used for extended_data, we need to copy as many of
		337	the extended_data channel pointers as will fit */
		338	if (needs_extended_data) {
		339	for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
		340	buf->data[i] = buf->extended_data[i];
		341	}
		342	buf->audio_data_size = buf_size;
		343	buf->nb_channels = avctx->channels;
		344	}
		345
		346	/* copy InternalBuffer info to the AVFrame */
		347	frame->type = FF_BUFFER_TYPE_INTERNAL;
		348	frame->extended_data = buf->extended_data;
		349	frame->linesize[0] = buf->linesize[0];
		350	memcpy(frame->data, buf->data, sizeof(frame->data));
		351
		352	if (avctx->pkt) frame->pkt_pts = avctx->pkt->pts;
		353	else frame->pkt_pts = AV_NOPTS_VALUE;
		354	frame->reordered_opaque = avctx->reordered_opaque;
		355
		356	if (avctx->debug & FF_DEBUG_BUFFERS)
		357	av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p, "
		358	"internal audio buffer used\n", frame);
		359
		360	return 0;
		361	}
		362
		363	static int video_get_buffer(AVCodecContext s, AVFrame pic)
		364	{
264	int i;	365	int i;
265	int w= s->width;	366	int w= s->width;
266	int h= s->height;	367	int h= s->height;
@@ -295,7 +396,7 @@ int avcodec_default_get_buffer(AVCodecContext s, AVFrame pic){ · 28 unmodified lines
295	return -1;	396	return -1;
296	}	397	}
297		398
298	for(i=0; i<4; i++){	399	for (i = 0; i < AV_NUM_DATA_POINTERS; i++) {
299	av_freep(&buf->base[i]);	400	av_freep(&buf->base[i]);
300	buf->data[i]= NULL;	401	buf->data[i]= NULL;
301	}	402	}
@@ -310,7 +411,7 @@ int avcodec_default_get_buffer(AVCodecContext s, AVFrame pic){ · 8 unmodified lines
310	int tmpsize;	411	int tmpsize;
311	int unaligned;	412	int unaligned;
312	AVPicture picture;	413	AVPicture picture;
313	int stride_align[4];	414	int stride_align[AV_NUM_DATA_POINTERS];
314	const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;	415	const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
315		416
316	avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);	417	avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
@@ -363,6 +464,10 @@ int avcodec_default_get_buffer(AVCodecContext s, AVFrame pic){ · 46 unmodified lines
363	else	464	else
364	buf->data[i] = buf->base[i] + FFALIGN((buf->linesize[i]EDGE_WIDTH>>v_shift) + (pixel_sizeEDGE_WIDTH>>h_shift), stride_align[i]);	465	buf->data[i] = buf->base[i] + FFALIGN((buf->linesize[i]EDGE_WIDTH>>v_shift) + (pixel_sizeEDGE_WIDTH>>h_shift), stride_align[i]);
365	}	466	}
		467	for (; i < AV_NUM_DATA_POINTERS; i++) {
		468	buf->base[i] = buf->data[i] = NULL;
		469	buf->linesize[i] = 0;
		470	}
366	if(size[1] && !size[2])	471	if(size[1] && !size[2])
367	ff_set_systematic_pal2((uint32_t*)buf->data[1], s->pix_fmt);	472	ff_set_systematic_pal2((uint32_t*)buf->data[1], s->pix_fmt);
368	buf->width = s->width;	473	buf->width = s->width;
@@ -372,11 +477,12 @@ int avcodec_default_get_buffer(AVCodecContext s, AVFrame pic){ · 3 unmodified lines
372	}	477	}
373	pic->type= FF_BUFFER_TYPE_INTERNAL;	478	pic->type= FF_BUFFER_TYPE_INTERNAL;
374		479
375	for(i=0; i<4; i++){	480	for (i = 0; i < AV_NUM_DATA_POINTERS; i++) {
376	pic->base[i]= buf->base[i];	481	pic->base[i]= buf->base[i];
377	pic->data[i]= buf->data[i];	482	pic->data[i]= buf->data[i];
378	pic->linesize[i]= buf->linesize[i];	483	pic->linesize[i]= buf->linesize[i];
379	}	484	}
		485	pic->extended_data = pic->data;
380	avci->buffer_count++;	486	avci->buffer_count++;
381		487
382	if (s->pkt) {	488	if (s->pkt) {
@@ -399,11 +505,25 @@ int avcodec_default_get_buffer(AVCodecContext s, AVFrame pic){ · 16 unmodified lines
399	return 0;	505	return 0;
400	}	506	}
401		507
		508	int avcodec_default_get_buffer(AVCodecContext avctx, AVFrame frame)
		509	{
		510	switch (avctx->codec_type) {
		511	case AVMEDIA_TYPE_VIDEO:
		512	return video_get_buffer(avctx, frame);
		513	case AVMEDIA_TYPE_AUDIO:
		514	return audio_get_buffer(avctx, frame);
		515	default:
		516	return -1;
		517	}
		518	}
		519
402	void avcodec_default_release_buffer(AVCodecContext s, AVFrame pic){	520	void avcodec_default_release_buffer(AVCodecContext s, AVFrame pic){
403	int i;	521	int i;
404	InternalBuffer buf, last;	522	InternalBuffer buf, last;
405	AVCodecInternal *avci = s->internal;	523	AVCodecInternal *avci = s->internal;
406		524
		525	assert(s->codec_type == AVMEDIA_TYPE_VIDEO);
		526
407	assert(pic->type==FF_BUFFER_TYPE_INTERNAL);	527	assert(pic->type==FF_BUFFER_TYPE_INTERNAL);
408	assert(avci->buffer_count);	528	assert(avci->buffer_count);
409		529
@@ -421,7 +541,7 @@ void avcodec_default_release_buffer(AVCodecContext s, AVFrame pic){ · 11 unmodified lines
421	FFSWAP(InternalBuffer, buf, last);	541	FFSWAP(InternalBuffer, buf, last);
422	}	542	}
423		543
424	for(i=0; i<4; i++){	544	for (i = 0; i < AV_NUM_DATA_POINTERS; i++) {
425	pic->data[i]=NULL;	545	pic->data[i]=NULL;
426	// pic->base[i]=NULL;	546	// pic->base[i]=NULL;
427	}	547	}
@@ -436,6 +556,8 @@ int avcodec_default_reget_buffer(AVCodecContext s, AVFrame pic){ · 8 unmodified lines
436	AVFrame temp_pic;	556	AVFrame temp_pic;
437	int i;	557	int i;
438		558
		559	assert(s->codec_type == AVMEDIA_TYPE_VIDEO);
		560
439	/* If no picture return a new buffer */	561	/* If no picture return a new buffer */
440	if(pic->data[0] == NULL) {	562	if(pic->data[0] == NULL) {
441	/* We will copy from buffer, so must be readable */	563	/* We will copy from buffer, so must be readable */
@@ -455,7 +577,7 @@ int avcodec_default_reget_buffer(AVCodecContext s, AVFrame pic){ · 13 unmodified lines
455	* Not internal type and reget_buffer not overridden, emulate cr buffer	577	* Not internal type and reget_buffer not overridden, emulate cr buffer
456	*/	578	*/
457	temp_pic = *pic;	579	temp_pic = *pic;
458	for(i = 0; i < 4; i++)	580	for(i = 0; i < AV_NUM_DATA_POINTERS; i++)
459	pic->data[i] = pic->base[i] = NULL;	581	pic->data[i] = pic->base[i] = NULL;
460	pic->opaque = NULL;	582	pic->opaque = NULL;
461	/* Allocate new frame */	583	/* Allocate new frame */
@@ -862,36 +984,73 @@ int attribute_align_arg avcodec_decode_video2(AVCodecContext avctx, AVFrame pi · 400 unmodified lines
862	return ret;	984	return ret;
863	}	985	}
864		986
		987	#if FF_API_OLD_DECODE_AUDIO
865	int attribute_align_arg avcodec_decode_audio3(AVCodecContext avctx, int16_t samples,	988	int attribute_align_arg avcodec_decode_audio3(AVCodecContext avctx, int16_t samples,
866	int *frame_size_ptr,	989	int *frame_size_ptr,
867	AVPacket *avpkt)	990	AVPacket *avpkt)
868	{	991	{
869	int ret;	992	AVFrame frame;
		993	int ret, got_frame = 0;
		994
		995	if (avctx->get_buffer != avcodec_default_get_buffer) {
		996	av_log(avctx, AV_LOG_ERROR, "A custom get_buffer() cannot be used with "
		997	"avcodec_decode_audio3()\n");
		998	return AVERROR(EINVAL);
		999	}
		1000
		1001	ret = avcodec_decode_audio4(avctx, &frame, &got_frame, avpkt);
		1002
		1003	if (ret >= 0 && got_frame) {
		1004	int ch, plane_size;
		1005	int planar = av_sample_fmt_is_planar(avctx->sample_fmt);
		1006	int data_size = av_samples_get_buffer_size(&plane_size, avctx->channels,
		1007	frame.nb_samples,
		1008	avctx->sample_fmt, 1);
		1009	if (*frame_size_ptr < data_size) {
		1010	av_log(avctx, AV_LOG_ERROR, "output buffer size is too small for "
		1011	"the current frame (%d < %d)\n", *frame_size_ptr, data_size);
		1012	return AVERROR(EINVAL);
		1013	}
		1014
		1015	memcpy(samples, frame.extended_data[0], plane_size);
		1016
		1017	if (planar && avctx->channels > 1) {
		1018	uint8_t out = ((uint8_t )samples) + plane_size;
		1019	for (ch = 1; ch < avctx->channels; ch++) {
		1020	memcpy(out, frame.extended_data[ch], plane_size);
		1021	out += plane_size;
		1022	}
		1023	}
		1024	*frame_size_ptr = data_size;
		1025	} else {
		1026	*frame_size_ptr = 0;
		1027	}
		1028	return ret;
		1029	}
		1030	#endif
		1031
		1032	int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx,
		1033	AVFrame *frame,
		1034	int *got_frame_ptr,
		1035	AVPacket *avpkt)
		1036	{
		1037	int ret = 0;
		1038
		1039	*got_frame_ptr = 0;
870		1040
871	if (!avpkt->data && avpkt->size) {	1041	if (!avpkt->data && avpkt->size) {
872	av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");	1042	av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
873	return AVERROR(EINVAL);	1043	return AVERROR(EINVAL);
874	}	1044	}
875		1045
876	if((avctx->codec->capabilities & CODEC_CAP_DELAY) \|\| avpkt->size){	1046	if ((avctx->codec->capabilities & CODEC_CAP_DELAY) \|\| avpkt->size) {
877	av_packet_split_side_data(avpkt);	1047	av_packet_split_side_data(avpkt);
878	avctx->pkt = avpkt;	1048	avctx->pkt = avpkt;
879	//FIXME remove the check below _after_ ensuring that all audio check that the available space is enough	1049	ret = avctx->codec->decode(avctx, frame, got_frame_ptr, avpkt);
880	if(*frame_size_ptr < AVCODEC_MAX_AUDIO_FRAME_SIZE){	1050	if (ret >= 0 && *got_frame_ptr) {
881	av_log(avctx, AV_LOG_ERROR, "buffer smaller than AVCODEC_MAX_AUDIO_FRAME_SIZE\n");	1051	avctx->frame_number++;
882	return -1;	1052	frame->pkt_dts = avpkt->dts;
883	}
884	if(*frame_size_ptr < FF_MIN_BUFFER_SIZE \|\|
885	frame_size_ptr < avctx->channels avctx->frame_size * sizeof(int16_t)){
886	av_log(avctx, AV_LOG_ERROR, "buffer %d too small\n", *frame_size_ptr);
887	return -1;
888	}	1053	}
889
890	ret = avctx->codec->decode(avctx, samples, frame_size_ptr, avpkt);
891	avctx->frame_number++;
892	}else{
893	ret= 0;
894	*frame_size_ptr=0;
895	}	1054	}
896	return ret;	1055	return ret;
897	}	1056	}
@@ -1230,7 +1389,8 @@ void avcodec_flush_buffers(AVCodecContext *avctx) · 332 unmodified lines
1230	avctx->codec->flush(avctx);	1389	avctx->codec->flush(avctx);
1231	}	1390	}
1232		1391
1233	void avcodec_default_free_buffers(AVCodecContext *s){	1392	static void video_free_buffers(AVCodecContext *s)
		1393	{
1234	AVCodecInternal *avci = s->internal;	1394	AVCodecInternal *avci = s->internal;
1235	int i, j;	1395	int i, j;
1236		1396
@@ -1252,6 +1412,37 @@ void avcodec_default_free_buffers(AVCodecContext *s){ · 15 unmodified lines
1252	avci->buffer_count=0;	1412	avci->buffer_count=0;
1253	}	1413	}
1254		1414
		1415	static void audio_free_buffers(AVCodecContext *avctx)
		1416	{
		1417	AVCodecInternal *avci = avctx->internal;
		1418	InternalBuffer *buf;
		1419
		1420	if (!avci->buffer)
		1421	return;
		1422	buf = avci->buffer;
		1423
		1424	if (buf->extended_data) {
		1425	av_free(buf->extended_data[0]);
		1426	if (buf->extended_data != buf->data)
		1427	av_free(buf->extended_data);
		1428	}
		1429	av_freep(&avci->buffer);
		1430	}
		1431
		1432	void avcodec_default_free_buffers(AVCodecContext *avctx)
		1433	{
		1434	switch (avctx->codec_type) {
		1435	case AVMEDIA_TYPE_VIDEO:
		1436	video_free_buffers(avctx);
		1437	break;
		1438	case AVMEDIA_TYPE_AUDIO:
		1439	audio_free_buffers(avctx);
		1440	break;
		1441	default:
		1442	break;
		1443	}
		1444	}
		1445
1255	#if FF_API_OLD_FF_PICT_TYPES	1446	#if FF_API_OLD_FF_PICT_TYPES
1256	char av_get_pict_type_char(int pict_type){	1447	char av_get_pict_type_char(int pict_type){
1257	return av_get_picture_type_char(pict_type);	1448	return av_get_picture_type_char(pict_type);

libavcodec/version.h+8−3

@@ -21,8 +21,8 @@ · 20 unmodified lines
21	#define AVCODEC_VERSION_H	21	#define AVCODEC_VERSION_H
22		22
23	#define LIBAVCODEC_VERSION_MAJOR 53	23	#define LIBAVCODEC_VERSION_MAJOR 53
24	#define LIBAVCODEC_VERSION_MINOR 39	24	#define LIBAVCODEC_VERSION_MINOR 40
25	#define LIBAVCODEC_VERSION_MICRO 1	25	#define LIBAVCODEC_VERSION_MICRO 0
26		26
27	#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \	27	#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
28	LIBAVCODEC_VERSION_MINOR, \	28	LIBAVCODEC_VERSION_MINOR, \
@@ -110,6 +110,11 @@ · 81 unmodified lines
110	#ifndef FF_API_TIFFENC_COMPLEVEL	110	#ifndef FF_API_TIFFENC_COMPLEVEL
111	#define FF_API_TIFFENC_COMPLEVEL (LIBAVCODEC_VERSION_MAJOR < 54)	111	#define FF_API_TIFFENC_COMPLEVEL (LIBAVCODEC_VERSION_MAJOR < 54)
112	#endif	112	#endif
113		113	#ifndef FF_API_DATA_POINTERS
		114	#define FF_API_DATA_POINTERS (LIBAVCODEC_VERSION_MAJOR < 54)
		115	#endif
		116	#ifndef FF_API_OLD_DECODE_AUDIO
		117	#define FF_API_OLD_DECODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 54)
		118	#endif
114		119
115	#endif /* AVCODEC_VERSION_H */	120	#endif /* AVCODEC_VERSION_H */

libavcodec/vmdav.c+23−12

@@ -466,6 +466,7 @@ static av_cold int vmdvideo_decode_end(AVCodecContext *avctx) · 465 unmodified lines
466	#define BLOCK_TYPE_SILENCE 3	466	#define BLOCK_TYPE_SILENCE 3
467		467
468	typedef struct VmdAudioContext {	468	typedef struct VmdAudioContext {
		469	AVFrame frame;
469	int out_bps;	470	int out_bps;
470	int chunk_size;	471	int chunk_size;
471	} VmdAudioContext;	472	} VmdAudioContext;
@@ -507,6 +508,9 @@ static av_cold int vmdaudio_decode_init(AVCodecContext *avctx) · 35 unmodified lines
507		508
508	s->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2);	509	s->chunk_size = avctx->block_align + avctx->channels * (s->out_bps == 2);
509		510
		511	avcodec_get_frame_defaults(&s->frame);
		512	avctx->coded_frame = &s->frame;
		513
510	av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "	514	av_log(avctx, AV_LOG_DEBUG, "%d channels, %d bits/sample, "
511	"block align = %d, sample rate = %d\n",	515	"block align = %d, sample rate = %d\n",
512	avctx->channels, avctx->bits_per_coded_sample, avctx->block_align,	516	avctx->channels, avctx->bits_per_coded_sample, avctx->block_align,
@@ -544,22 +548,21 @@ static void decode_audio_s16(int16_t out, const uint8_t buf, int buf_size, · 31 unmodified lines
544	}	548	}
545	}	549	}
546		550
547	static int vmdaudio_decode_frame(AVCodecContext *avctx,	551	static int vmdaudio_decode_frame(AVCodecContext avctx, void data,
548	void data, int data_size,	552	int got_frame_ptr, AVPacket avpkt)
549	AVPacket *avpkt)
550	{	553	{
551	const uint8_t *buf = avpkt->data;	554	const uint8_t *buf = avpkt->data;
552	const uint8_t *buf_end;	555	const uint8_t *buf_end;
553	int buf_size = avpkt->size;	556	int buf_size = avpkt->size;
554	VmdAudioContext *s = avctx->priv_data;	557	VmdAudioContext *s = avctx->priv_data;
555	int block_type, silent_chunks, audio_chunks;	558	int block_type, silent_chunks, audio_chunks;
556	int nb_samples, out_size;	559	int ret;
557	uint8_t *output_samples_u8 = data;	560	uint8_t *output_samples_u8;
558	int16_t *output_samples_s16 = data;	561	int16_t *output_samples_s16;
559		562
560	if (buf_size < 16) {	563	if (buf_size < 16) {
561	av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");	564	av_log(avctx, AV_LOG_WARNING, "skipping small junk packet\n");
562	*data_size = 0;	565	*got_frame_ptr = 0;
563	return buf_size;	566	return buf_size;
564	}	567	}
565		568
@@ -590,10 +593,15 @@ static int vmdaudio_decode_frame(AVCodecContext *avctx, · 24 unmodified lines
590		593
591	/* ensure output buffer is large enough */	594	/* ensure output buffer is large enough */
592	audio_chunks = buf_size / s->chunk_size;	595	audio_chunks = buf_size / s->chunk_size;
593	nb_samples = ((silent_chunks + audio_chunks) * avctx->block_align) / avctx->channels;	596
594	out_size = nb_samples * avctx->channels * s->out_bps;	597	/* get output buffer */
595	if (*data_size < out_size)	598	s->frame.nb_samples = ((silent_chunks + audio_chunks) * avctx->block_align) / avctx->channels;
596	return -1;	599	if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
		600	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		601	return ret;
		602	}
		603	output_samples_u8 = s->frame.data[0];
		604	output_samples_s16 = (int16_t *)s->frame.data[0];
597		605
598	/* decode silent chunks */	606	/* decode silent chunks */
599	if (silent_chunks > 0) {	607	if (silent_chunks > 0) {
@@ -623,7 +631,9 @@ static int vmdaudio_decode_frame(AVCodecContext *avctx, · 23 unmodified lines
623	}	631	}
624	}	632	}
625		633
626	*data_size = out_size;	634	*got_frame_ptr = 1;
		635	(AVFrame )data = s->frame;
		636
627	return avpkt->size;	637	return avpkt->size;
628	}	638	}
629		639
@@ -651,5 +661,6 @@ AVCodec ff_vmdaudio_decoder = { · 21 unmodified lines
651	.priv_data_size = sizeof(VmdAudioContext),	661	.priv_data_size = sizeof(VmdAudioContext),
652	.init = vmdaudio_decode_init,	662	.init = vmdaudio_decode_init,
653	.decode = vmdaudio_decode_frame,	663	.decode = vmdaudio_decode_frame,
		664	.capabilities = CODEC_CAP_DR1,
654	.long_name = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),	665	.long_name = NULL_IF_CONFIG_SMALL("Sierra VMD audio"),
655	};	666	};

libavcodec/vorbisdec.c+20−13

 typedef struct vorbis_context_s {
     AVCodecContext *avccontext;
+    AVFrame frame;
     GetBitContext gb;
     DSPContext dsp;
     FmtConvertContext fmt_conv;
     avccontext->sample_rate = vc->audio_samplerate;
     avccontext->frame_size  = FFMIN(vc->blocksize[0], vc->blocksize[1]) >> 2;
+    avcodec_get_frame_defaults(&vc->frame);
+    avccontext->coded_frame = &vc->frame;
     return 0;
 }
 // Return the decoded audio packet through the standard api
-static int vorbis_decode_frame(AVCodecContext *avccontext,
+static int vorbis_decode_frame(AVCodecContext *avccontext, void *data,
-                               void *data, int *data_size,
+                               int *got_frame_ptr, AVPacket *avpkt)
-                               AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
     int buf_size       = avpkt->size;
     vorbis_context *vc = avccontext->priv_data;
     GetBitContext *gb = &(vc->gb);
     const float *channel_ptrs[255];
-    int i, len, out_size;
+    int i, len, ret;
     av_dlog(NULL, "packet length %d \n", buf_size);
     if (!vc->first_frame) {
         vc->first_frame = 1;
-        *data_size = 0;
+        *got_frame_ptr = 0;
         return buf_size;
     }
     av_dlog(NULL, "parsed %d bytes %d bits, returned %d samples (*ch*bits) \n",
             get_bits_count(gb) / 8, get_bits_count(gb) % 8, len);
-    out_size = len * vc->audio_channels *
+    /* get output buffer */
-               av_get_bytes_per_sample(avccontext->sample_fmt);
+    vc->frame.nb_samples = len;
-    if (*data_size < out_size) {
+    if ((ret = avccontext->get_buffer(avccontext, &vc->frame)) < 0) {
-        av_log(avccontext, AV_LOG_ERROR, "output buffer is too small\n");
+        av_log(avccontext, AV_LOG_ERROR, "get_buffer() failed\n");
-        return AVERROR(EINVAL);
+        return ret;
     }
     if (vc->audio_channels > 8) {
     }
     if (avccontext->sample_fmt == AV_SAMPLE_FMT_FLT)
-        vc->fmt_conv.float_interleave(data, channel_ptrs, len, vc->audio_channels);
+        vc->fmt_conv.float_interleave((float *)vc->frame.data[0], channel_ptrs,
+                                      len, vc->audio_channels);
     else
-        vc->fmt_conv.float_to_int16_interleave(data, channel_ptrs, len,
+        vc->fmt_conv.float_to_int16_interleave((int16_t *)vc->frame.data[0],
+                                               channel_ptrs, len,
                                                vc->audio_channels);
-    *data_size = out_size;
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = vc->frame;
     return buf_size;
 }
     .init           = vorbis_decode_init,
     .close          = vorbis_decode_close,
     .decode         = vorbis_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Vorbis"),
     .channel_layouts = ff_vorbis_channel_layouts,
     .sample_fmts = (const enum AVSampleFormat[]) {

libavcodec/vp3.c+4−3

  */
 static void vp3_draw_horiz_band(Vp3DecodeContext *s, int y)
 {
-    int h, cy;
+    int h, cy, i;
-    int offset[4];
+    int offset[AV_NUM_DATA_POINTERS];
     if (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
         int y_flipped = s->flipped_image ? s->avctx->height-y : y;
     offset[0] = s->current_frame.linesize[0]*y;
     offset[1] = s->current_frame.linesize[1]*cy;
     offset[2] = s->current_frame.linesize[2]*cy;
-    offset[3] = 0;
+    for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
+        offset[i] = 0;
     emms_c();
     s->avctx->draw_horiz_band(s->avctx, &s->current_frame, offset, y, 3, h);

libavcodec/vp8.c+5−3

     int ret;
     if ((ret = ff_thread_get_buffer(s->avctx, f)) < 0)
         return ret;
-    if (s->num_maps_to_be_freed) {
+    if (s->num_maps_to_be_freed && !s->maps_are_invalid) {
-        assert(!s->maps_are_invalid);
         f->ref_index[0] = s->segmentation_maps[--s->num_maps_to_be_freed];
     } else if (!(f->ref_index[0] = av_mallocz(s->mb_width * s->mb_height))) {
         ff_thread_release_buffer(s->avctx, f);
     VP8Context *s = avctx->priv_data;
     int ret, mb_x, mb_y, i, y, referenced;
     enum AVDiscard skip_thresh;
-    AVFrame *av_uninit(curframe), *prev_frame = s->framep[VP56_FRAME_CURRENT];
+    AVFrame *av_uninit(curframe), *prev_frame;
     release_queued_segmaps(s, 0);
     if ((ret = decode_frame_header(s, avpkt->data, avpkt->size)) < 0)
         return ret;
+    prev_frame = s->framep[VP56_FRAME_CURRENT];
     referenced = s->update_last || s->update_golden == VP56_FRAME_CURRENT
                                 || s->update_altref == VP56_FRAME_CURRENT;
     if (s->macroblocks_base &&
         (s_src->mb_width != s->mb_width || s_src->mb_height != s->mb_height)) {
         free_buffers(s);
+        s->maps_are_invalid = 1;
     }
     s->prob[0] = s_src->prob[!s_src->update_probabilities];

libavcodec/wavpack.c+44−72

@@ -115,8 +115,6 @@ typedef struct WavpackFrameContext { · 114 unmodified lines
115	int float_shift;	115	int float_shift;
116	int float_max_exp;	116	int float_max_exp;
117	WvChannel ch[2];	117	WvChannel ch[2];
118	int samples_left;
119	int max_samples;
120	int pos;	118	int pos;
121	SavedContext sc, extra_sc;	119	SavedContext sc, extra_sc;
122	} WavpackFrameContext;	120	} WavpackFrameContext;
@@ -125,6 +123,7 @@ typedef struct WavpackFrameContext { · 2 unmodified lines
125		123
126	typedef struct WavpackContext {	124	typedef struct WavpackContext {
127	AVCodecContext *avctx;	125	AVCodecContext *avctx;
		126	AVFrame frame;
128		127
129	WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];	128	WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
130	int fdec_num;	129	int fdec_num;
@@ -133,7 +132,6 @@ typedef struct WavpackContext { · 2 unmodified lines
133	int mkv_mode;	132	int mkv_mode;
134	int block;	133	int block;
135	int samples;	134	int samples;
136	int samples_left;
137	int ch_offset;	135	int ch_offset;
138	} WavpackContext;	136	} WavpackContext;
139		137
@@ -485,7 +483,6 @@ static float wv_get_value_float(WavpackFrameContext s, uint32_t crc, int S) · 345 unmodified lines
485	static void wv_reset_saved_context(WavpackFrameContext *s)	483	static void wv_reset_saved_context(WavpackFrameContext *s)
486	{	484	{
487	s->pos = 0;	485	s->pos = 0;
488	s->samples_left = 0;
489	s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;	486	s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
490	}	487	}
491		488
@@ -502,8 +499,7 @@ static inline int wv_unpack_stereo(WavpackFrameContext s, GetBitContext gb, vo · 10 unmodified lines
502	float *dstfl = dst;	499	float *dstfl = dst;
503	const int channel_pad = s->avctx->channels - 2;	500	const int channel_pad = s->avctx->channels - 2;
504		501
505	if(s->samples_left == s->samples)	502	s->one = s->zero = s->zeroes = 0;
506	s->one = s->zero = s->zeroes = 0;
507	do{	503	do{
508	L = wv_get_value(s, gb, 0, &last);	504	L = wv_get_value(s, gb, 0, &last);
509	if(last) break;	505	if(last) break;
@@ -594,13 +590,8 @@ static inline int wv_unpack_stereo(WavpackFrameContext s, GetBitContext gb, vo · 84 unmodified lines
594	dst16 += channel_pad;	590	dst16 += channel_pad;
595	}	591	}
596	count++;	592	count++;
597	}while(!last && count < s->max_samples);	593	} while (!last && count < s->samples);
598		594
599	if (last)
600	s->samples_left = 0;
601	else
602	s->samples_left -= count;
603	if(!s->samples_left){
604	wv_reset_saved_context(s);	595	wv_reset_saved_context(s);
605	if(crc != s->CRC){	596	if(crc != s->CRC){
606	av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");	597	av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
@@ -610,15 +601,7 @@ static inline int wv_unpack_stereo(WavpackFrameContext s, GetBitContext gb, vo · 3 unmodified lines
610	av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");	601	av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
611	return -1;	602	return -1;
612	}	603	}
613	}else{	604
614	s->pos = pos;
615	s->sc.crc = crc;
616	s->sc.bits_used = get_bits_count(&s->gb);
617	if(s->got_extra_bits){
618	s->extra_sc.crc = crc_extra_bits;
619	s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
620	}
621	}
622	return count * 2;	605	return count * 2;
623	}	606	}
624		607
@@ -635,8 +618,7 @@ static inline int wv_unpack_mono(WavpackFrameContext s, GetBitContext gb, void · 10 unmodified lines
635	float *dstfl = dst;	618	float *dstfl = dst;
636	const int channel_stride = s->avctx->channels;	619	const int channel_stride = s->avctx->channels;
637		620
638	if(s->samples_left == s->samples)	621	s->one = s->zero = s->zeroes = 0;
639	s->one = s->zero = s->zeroes = 0;
640	do{	622	do{
641	T = wv_get_value(s, gb, 0, &last);	623	T = wv_get_value(s, gb, 0, &last);
642	S = 0;	624	S = 0;
@@ -675,13 +657,8 @@ static inline int wv_unpack_mono(WavpackFrameContext s, GetBitContext gb, void · 32 unmodified lines
675	dst16 += channel_stride;	657	dst16 += channel_stride;
676	}	658	}
677	count++;	659	count++;
678	}while(!last && count < s->max_samples);	660	} while (!last && count < s->samples);
679		661
680	if (last)
681	s->samples_left = 0;
682	else
683	s->samples_left -= count;
684	if(!s->samples_left){
685	wv_reset_saved_context(s);	662	wv_reset_saved_context(s);
686	if(crc != s->CRC){	663	if(crc != s->CRC){
687	av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");	664	av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
@@ -691,15 +668,7 @@ static inline int wv_unpack_mono(WavpackFrameContext s, GetBitContext gb, void · 3 unmodified lines
691	av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");	668	av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
692	return -1;	669	return -1;
693	}	670	}
694	}else{	671
695	s->pos = pos;
696	s->sc.crc = crc;
697	s->sc.bits_used = get_bits_count(&s->gb);
698	if(s->got_extra_bits){
699	s->extra_sc.crc = crc_extra_bits;
700	s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
701	}
702	}
703	return count;	672	return count;
704	}	673	}
705		674
@@ -743,6 +712,9 @@ static av_cold int wavpack_decode_init(AVCodecContext *avctx) · 37 unmodified lines
743		712
744	s->fdec_num = 0;	713	s->fdec_num = 0;
745		714
		715	avcodec_get_frame_defaults(&s->frame);
		716	avctx->coded_frame = &s->frame;
		717
746	return 0;	718	return 0;
747	}	719	}
748		720
@@ -759,7 +731,7 @@ static av_cold int wavpack_decode_end(AVCodecContext *avctx) · 10 unmodified lines
759	}	731	}
760		732
761	static int wavpack_decode_block(AVCodecContext *avctx, int block_no,	733	static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
762	void data, int data_size,	734	void data, int got_frame_ptr,
763	const uint8_t *buf, int buf_size)	735	const uint8_t *buf, int buf_size)
764	{	736	{
765	WavpackContext *wc = avctx->priv_data;	737	WavpackContext *wc = avctx->priv_data;
@@ -774,7 +746,7 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no, · 8 unmodified lines
774	int bpp, chan, chmask;	746	int bpp, chan, chmask;
775		747
776	if (buf_size == 0){	748	if (buf_size == 0){
777	*data_size = 0;	749	*got_frame_ptr = 0;
778	return 0;	750	return 0;
779	}	751	}
780		752
@@ -789,18 +761,16 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no, · 8 unmodified lines
789	return -1;	761	return -1;
790	}	762	}
791		763
792	if(!s->samples_left){
793	memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));	764	memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
794	memset(s->ch, 0, sizeof(s->ch));	765	memset(s->ch, 0, sizeof(s->ch));
795	s->extra_bits = 0;	766	s->extra_bits = 0;
796	s->and = s->or = s->shift = 0;	767	s->and = s->or = s->shift = 0;
797	s->got_extra_bits = 0;	768	s->got_extra_bits = 0;
798	}
799		769
800	if(!wc->mkv_mode){	770	if(!wc->mkv_mode){
801	s->samples = AV_RL32(buf); buf += 4;	771	s->samples = AV_RL32(buf); buf += 4;
802	if(!s->samples){	772	if(!s->samples){
803	*data_size = 0;	773	*got_frame_ptr = 0;
804	return 0;	774	return 0;
805	}	775	}
806	}else{	776	}else{
@@ -829,13 +799,6 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no, · 22 unmodified lines
829		799
830	wc->ch_offset += 1 + s->stereo;	800	wc->ch_offset += 1 + s->stereo;
831		801
832	s->max_samples = data_size / (bpp avctx->channels);
833	s->max_samples = FFMIN(s->max_samples, s->samples);
834	if(s->samples_left > 0){
835	s->max_samples = FFMIN(s->max_samples, s->samples_left);
836	buf = buf_end;
837	}
838
839	// parse metadata blocks	802	// parse metadata blocks
840	while(buf < buf_end){	803	while(buf < buf_end){
841	id = *buf++;	804	id = *buf++;
@@ -1064,7 +1027,7 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no, · 222 unmodified lines
1064	}	1027	}
1065	if(id & WP_IDF_ODD) buf++;	1028	if(id & WP_IDF_ODD) buf++;
1066	}	1029	}
1067	if(!s->samples_left){	1030
1068	if(!got_terms){	1031	if(!got_terms){
1069	av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");	1032	av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
1070	return -1;	1033	return -1;
@@ -1101,16 +1064,6 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no, · 30 unmodified lines
1101	s->got_extra_bits = 0;	1064	s->got_extra_bits = 0;
1102	}	1065	}
1103	}	1066	}
1104	s->samples_left = s->samples;
1105	}else{
1106	init_get_bits(&s->gb, orig_buf + s->sc.offset, s->sc.size);
1107	skip_bits_long(&s->gb, s->sc.bits_used);
1108	if(s->got_extra_bits){
1109	init_get_bits(&s->gb_extra_bits, orig_buf + s->extra_sc.offset,
1110	s->extra_sc.size);
1111	skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
1112	}
1113	}
1114		1067
1115	if(s->stereo_in){	1068	if(s->stereo_in){
1116	if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)	1069	if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
@@ -1167,7 +1120,7 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no, · 50 unmodified lines
1167	}	1120	}
1168	}	1121	}
1169		1122
1170	wc->samples_left = s->samples_left;	1123	*got_frame_ptr = 1;
1171		1124
1172	return samplecount * bpp;	1125	return samplecount * bpp;
1173	}	1126	}
@@ -1181,23 +1134,40 @@ static void wavpack_decode_flush(AVCodecContext *avctx) · 7 unmodified lines
1181	wv_reset_saved_context(s->fdec[i]);	1134	wv_reset_saved_context(s->fdec[i]);
1182	}	1135	}
1183		1136
1184	static int wavpack_decode_frame(AVCodecContext *avctx,	1137	static int wavpack_decode_frame(AVCodecContext avctx, void data,
1185	void data, int data_size,	1138	int got_frame_ptr, AVPacket avpkt)
1186	AVPacket *avpkt)
1187	{	1139	{
1188	WavpackContext *s = avctx->priv_data;	1140	WavpackContext *s = avctx->priv_data;
1189	const uint8_t *buf = avpkt->data;	1141	const uint8_t *buf = avpkt->data;
1190	int buf_size = avpkt->size;	1142	int buf_size = avpkt->size;
1191	int frame_size;	1143	int frame_size, ret;
1192	int samplecount = 0;	1144	int samplecount = 0;
1193		1145
1194	s->block = 0;	1146	s->block = 0;
1195	s->samples_left = 0;
1196	s->ch_offset = 0;	1147	s->ch_offset = 0;
1197		1148
		1149	/* determine number of samples */
1198	if(s->mkv_mode){	1150	if(s->mkv_mode){
1199	s->samples = AV_RL32(buf); buf += 4;	1151	s->samples = AV_RL32(buf); buf += 4;
		1152	} else {
		1153	if (s->multichannel)
		1154	s->samples = AV_RL32(buf + 4);
		1155	else
		1156	s->samples = AV_RL32(buf);
		1157	}
		1158	if (s->samples <= 0) {
		1159	av_log(avctx, AV_LOG_ERROR, "Invalid number of samples: %d\n",
		1160	s->samples);
		1161	return AVERROR(EINVAL);
		1162	}
		1163
		1164	/* get output buffer */
		1165	s->frame.nb_samples = s->samples;
		1166	if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
		1167	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		1168	return ret;
1200	}	1169	}
		1170
1201	while(buf_size > 0){	1171	while(buf_size > 0){
1202	if(!s->multichannel){	1172	if(!s->multichannel){
1203	frame_size = buf_size;	1173	frame_size = buf_size;
@@ -1216,17 +1186,19 @@ static int wavpack_decode_frame(AVCodecContext *avctx, · 12 unmodified lines
1216	wavpack_decode_flush(avctx);	1186	wavpack_decode_flush(avctx);
1217	return -1;	1187	return -1;
1218	}	1188	}
1219	if((samplecount = wavpack_decode_block(avctx, s->block, data,	1189	if((samplecount = wavpack_decode_block(avctx, s->block, s->frame.data[0],
1220	data_size, buf, frame_size)) < 0) {	1190	got_frame_ptr, buf, frame_size)) < 0) {
1221	wavpack_decode_flush(avctx);	1191	wavpack_decode_flush(avctx);
1222	return -1;	1192	return -1;
1223	}	1193	}
1224	s->block++;	1194	s->block++;
1225	buf += frame_size; buf_size -= frame_size;	1195	buf += frame_size; buf_size -= frame_size;
1226	}	1196	}
1227	data_size = samplecount avctx->channels;
1228		1197
1229	return s->samples_left > 0 ? 0 : avpkt->size;	1198	if (*got_frame_ptr)
		1199	(AVFrame )data = s->frame;
		1200
		1201	return avpkt->size;
1230	}	1202	}
1231		1203
1232	AVCodec ff_wavpack_decoder = {	1204	AVCodec ff_wavpack_decoder = {
@@ -1238,6 +1210,6 @@ AVCodec ff_wavpack_decoder = { · 5 unmodified lines
1238	.close = wavpack_decode_end,	1210	.close = wavpack_decode_end,
1239	.decode = wavpack_decode_frame,	1211	.decode = wavpack_decode_frame,
1240	.flush = wavpack_decode_flush,	1212	.flush = wavpack_decode_flush,
1241	.capabilities = CODEC_CAP_SUBFRAMES,	1213	.capabilities = CODEC_CAP_SUBFRAMES \| CODEC_CAP_DR1,
1242	.long_name = NULL_IF_CONFIG_SMALL("WavPack"),	1214	.long_name = NULL_IF_CONFIG_SMALL("WavPack"),
1243	};	1215	};

libavcodec/wma.h+1−0

@@ -65,6 +65,7 @@ typedef struct CoefVLCTable { · 64 unmodified lines
65		65
66	typedef struct WMACodecContext {	66	typedef struct WMACodecContext {
67	AVCodecContext* avctx;	67	AVCodecContext* avctx;
		68	AVFrame frame;
68	GetBitContext gb;	69	GetBitContext gb;
69	PutBitContext pb;	70	PutBitContext pb;
70	int sample_rate;	71	int sample_rate;

libavcodec/wmadec.c+19−12

@@ -136,6 +136,10 @@ static int wma_decode_init(AVCodecContext * avctx) · 135 unmodified lines
136	}	136	}
137		137
138	avctx->sample_fmt = AV_SAMPLE_FMT_S16;	138	avctx->sample_fmt = AV_SAMPLE_FMT_S16;
		139
		140	avcodec_get_frame_defaults(&s->frame);
		141	avctx->coded_frame = &s->frame;
		142
139	return 0;	143	return 0;
140	}	144	}
141		145
@@ -814,14 +818,13 @@ static int wma_decode_frame(WMACodecContext s, int16_t samples) · 672 unmodified lines
814	return 0;	818	return 0;
815	}	819	}
816		820
817	static int wma_decode_superframe(AVCodecContext *avctx,	821	static int wma_decode_superframe(AVCodecContext avctx, void data,
818	void data, int data_size,	822	int got_frame_ptr, AVPacket avpkt)
819	AVPacket *avpkt)
820	{	823	{
821	const uint8_t *buf = avpkt->data;	824	const uint8_t *buf = avpkt->data;
822	int buf_size = avpkt->size;	825	int buf_size = avpkt->size;
823	WMACodecContext *s = avctx->priv_data;	826	WMACodecContext *s = avctx->priv_data;
824	int nb_frames, bit_offset, i, pos, len, out_size;	827	int nb_frames, bit_offset, i, pos, len, ret;
825	uint8_t *q;	828	uint8_t *q;
826	int16_t *samples;	829	int16_t *samples;
827		830
@@ -836,8 +839,6 @@ static int wma_decode_superframe(AVCodecContext *avctx, · 8 unmodified lines
836	if(s->block_align)	839	if(s->block_align)
837	buf_size = s->block_align;	840	buf_size = s->block_align;
838		841
839	samples = data;
840
841	init_get_bits(&s->gb, buf, buf_size*8);	842	init_get_bits(&s->gb, buf, buf_size*8);
842		843
843	if (s->use_bit_reservoir) {	844	if (s->use_bit_reservoir) {
@@ -848,12 +849,13 @@ static int wma_decode_superframe(AVCodecContext *avctx, · 4 unmodified lines
848	nb_frames = 1;	849	nb_frames = 1;
849	}	850	}
850		851
851	out_size = nb_frames * s->frame_len * s->nb_channels *	852	/* get output buffer */
852	av_get_bytes_per_sample(avctx->sample_fmt);	853	s->frame.nb_samples = nb_frames * s->frame_len;
853	if (*data_size < out_size) {	854	if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
854	av_log(s->avctx, AV_LOG_ERROR, "Insufficient output space\n");	855	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
855	goto fail;	856	return ret;
856	}	857	}
		858	samples = (int16_t *)s->frame.data[0];
857		859
858	if (s->use_bit_reservoir) {	860	if (s->use_bit_reservoir) {
859	bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);	861	bit_offset = get_bits(&s->gb, s->byte_offset_bits + 3);
@@ -920,7 +922,10 @@ static int wma_decode_superframe(AVCodecContext *avctx, · 60 unmodified lines
920	}	922	}
921		923
922	//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d outbytes:%d eaten:%d\n", s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len, (int8_t )samples - (int8_t )data, s->block_align);	924	//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d outbytes:%d eaten:%d\n", s->frame_len_bits, s->block_len_bits, s->frame_len, s->block_len, (int8_t )samples - (int8_t )data, s->block_align);
923	*data_size = out_size;	925
		926	*got_frame_ptr = 1;
		927	(AVFrame )data = s->frame;
		928
924	return buf_size;	929	return buf_size;
925	fail:	930	fail:
926	/* when error, we reset the bit reservoir */	931	/* when error, we reset the bit reservoir */
@@ -945,6 +950,7 @@ AVCodec ff_wmav1_decoder = { · 18 unmodified lines
945	.close = ff_wma_end,	950	.close = ff_wma_end,
946	.decode = wma_decode_superframe,	951	.decode = wma_decode_superframe,
947	.flush = flush,	952	.flush = flush,
		953	.capabilities = CODEC_CAP_DR1,
948	.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),	954	.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 1"),
949	};	955	};
950		956
@@ -957,5 +963,6 @@ AVCodec ff_wmav2_decoder = { · 6 unmodified lines
957	.close = ff_wma_end,	963	.close = ff_wma_end,
958	.decode = wma_decode_superframe,	964	.decode = wma_decode_superframe,
959	.flush = flush,	965	.flush = flush,
		966	.capabilities = CODEC_CAP_DR1,
960	.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),	967	.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 2"),
961	};	968	};

libavcodec/wmaprodec.c+36−27

@@ -167,6 +167,7 @@ typedef struct { · 166 unmodified lines
167	typedef struct WMAProDecodeCtx {	167	typedef struct WMAProDecodeCtx {
168	/* generic decoder variables */	168	/* generic decoder variables */
169	AVCodecContext* avctx; ///< codec context for av_log	169	AVCodecContext* avctx; ///< codec context for av_log
		170	AVFrame frame; ///< AVFrame for decoded output
170	DSPContext dsp; ///< accelerated DSP functions	171	DSPContext dsp; ///< accelerated DSP functions
171	FmtConvertContext fmt_conv;	172	FmtConvertContext fmt_conv;
172	uint8_t frame_data[MAX_FRAMESIZE +	173	uint8_t frame_data[MAX_FRAMESIZE +
@@ -209,8 +210,6 @@ typedef struct WMAProDecodeCtx { · 36 unmodified lines
209	uint32_t frame_num; ///< current frame number (not used for decoding)	210	uint32_t frame_num; ///< current frame number (not used for decoding)
210	GetBitContext gb; ///< bitstream reader context	211	GetBitContext gb; ///< bitstream reader context
211	int buf_bit_size; ///< buffer size in bits	212	int buf_bit_size; ///< buffer size in bits
212	float* samples; ///< current samplebuffer pointer
213	float* samples_end; ///< maximum samplebuffer pointer
214	uint8_t drc_gain; ///< gain for the DRC tool	213	uint8_t drc_gain; ///< gain for the DRC tool
215	int8_t skip_frame; ///< skip output step	214	int8_t skip_frame; ///< skip output step
216	int8_t parsed_all_subframes; ///< all subframes decoded?	215	int8_t parsed_all_subframes; ///< all subframes decoded?
@@ -453,6 +452,10 @@ static av_cold int decode_init(AVCodecContext *avctx) · 236 unmodified lines
453	dump_context(s);	452	dump_context(s);
454		453
455	avctx->channel_layout = channel_mask;	454	avctx->channel_layout = channel_mask;
		455
		456	avcodec_get_frame_defaults(&s->frame);
		457	avctx->coded_frame = &s->frame;
		458
456	return 0;	459	return 0;
457	}	460	}
458		461
@@ -1279,22 +1282,15 @@ static int decode_subframe(WMAProDecodeCtx *s) · 820 unmodified lines
1279	*@return 0 if the trailer bit indicates that this is the last frame,	1282	*@return 0 if the trailer bit indicates that this is the last frame,
1280	* 1 if there are additional frames	1283	* 1 if there are additional frames
1281	*/	1284	*/
1282	static int decode_frame(WMAProDecodeCtx *s)	1285	static int decode_frame(WMAProDecodeCtx s, int got_frame_ptr)
1283	{	1286	{
		1287	AVCodecContext *avctx = s->avctx;
1284	GetBitContext* gb = &s->gb;	1288	GetBitContext* gb = &s->gb;
1285	int more_frames = 0;	1289	int more_frames = 0;
1286	int len = 0;	1290	int len = 0;
1287	int i;	1291	int i, ret;
1288	const float *out_ptr[WMAPRO_MAX_CHANNELS];	1292	const float *out_ptr[WMAPRO_MAX_CHANNELS];
1289		1293	float *samples;
1290	/** check for potential output buffer overflow */
1291	if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) {
1292	/** return an error if no frame could be decoded at all */
1293	av_log(s->avctx, AV_LOG_ERROR,
1294	"not enough space for the output samples\n");
1295	s->packet_loss = 1;
1296	return 0;
1297	}
1298		1294
1299	/** get frame length */	1295	/** get frame length */
1300	if (s->len_prefix)	1296	if (s->len_prefix)
@@ -1360,10 +1356,19 @@ static int decode_frame(WMAProDecodeCtx *s) · 59 unmodified lines
1360	}	1356	}
1361	}	1357	}
1362		1358
		1359	/* get output buffer */
		1360	s->frame.nb_samples = s->samples_per_frame;
		1361	if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
		1362	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
		1363	s->packet_loss = 1;
		1364	return 0;
		1365	}
		1366	samples = (float *)s->frame.data[0];
		1367
1363	/** interleave samples and write them to the output buffer */	1368	/** interleave samples and write them to the output buffer */
1364	for (i = 0; i < s->num_channels; i++)	1369	for (i = 0; i < s->num_channels; i++)
1365	out_ptr[i] = s->channel[i].out;	1370	out_ptr[i] = s->channel[i].out;
1366	s->fmt_conv.float_interleave(s->samples, out_ptr, s->samples_per_frame,	1371	s->fmt_conv.float_interleave(samples, out_ptr, s->samples_per_frame,
1367	s->num_channels);	1372	s->num_channels);
1368		1373
1369	for (i = 0; i < s->num_channels; i++) {	1374	for (i = 0; i < s->num_channels; i++) {
@@ -1375,8 +1380,10 @@ static int decode_frame(WMAProDecodeCtx *s) · 5 unmodified lines
1375		1380
1376	if (s->skip_frame) {	1381	if (s->skip_frame) {
1377	s->skip_frame = 0;	1382	s->skip_frame = 0;
1378	} else	1383	*got_frame_ptr = 0;
1379	s->samples += s->num_channels * s->samples_per_frame;	1384	} else {
		1385	*got_frame_ptr = 1;
		1386	}
1380		1387
1381	if (s->len_prefix) {	1388	if (s->len_prefix) {
1382	if (len != (get_bits_count(gb) - s->frame_offset) + 2) {	1389	if (len != (get_bits_count(gb) - s->frame_offset) + 2) {
@@ -1473,8 +1480,8 @@ static void save_bits(WMAProDecodeCtx s, GetBitContext gb, int len, · 90 unmodified lines
1473	*@param avpkt input packet	1480	*@param avpkt input packet
1474	*@return number of bytes that were read from the input buffer	1481	*@return number of bytes that were read from the input buffer
1475	*/	1482	*/
1476	static int decode_packet(AVCodecContext *avctx,	1483	static int decode_packet(AVCodecContext avctx, void data,
1477	void data, int data_size, AVPacket* avpkt)	1484	int got_frame_ptr, AVPacket avpkt)
1478	{	1485	{
1479	WMAProDecodeCtx *s = avctx->priv_data;	1486	WMAProDecodeCtx *s = avctx->priv_data;
1480	GetBitContext* gb = &s->pgb;	1487	GetBitContext* gb = &s->pgb;
@@ -1483,9 +1490,7 @@ static int decode_packet(AVCodecContext *avctx, · 2 unmodified lines
1483	int num_bits_prev_frame;	1490	int num_bits_prev_frame;
1484	int packet_sequence_number;	1491	int packet_sequence_number;
1485		1492
1486	s->samples = data;	1493	*got_frame_ptr = 0;
1487	s->samples_end = (float)((int8_t)data + *data_size);
1488	*data_size = 0;
1489		1494
1490	if (s->packet_done \|\| s->packet_loss) {	1495	if (s->packet_done \|\| s->packet_loss) {
1491	s->packet_done = 0;	1496	s->packet_done = 0;
@@ -1532,7 +1537,7 @@ static int decode_packet(AVCodecContext *avctx, · 40 unmodified lines
1532		1537
1533	/** decode the cross packet frame if it is valid */	1538	/** decode the cross packet frame if it is valid */
1534	if (!s->packet_loss)	1539	if (!s->packet_loss)
1535	decode_frame(s);	1540	decode_frame(s, got_frame_ptr);
1536	} else if (s->num_saved_bits - s->frame_offset) {	1541	} else if (s->num_saved_bits - s->frame_offset) {
1537	av_dlog(avctx, "ignoring %x previously saved bits\n",	1542	av_dlog(avctx, "ignoring %x previously saved bits\n",
1538	s->num_saved_bits - s->frame_offset);	1543	s->num_saved_bits - s->frame_offset);
@@ -1555,7 +1560,7 @@ static int decode_packet(AVCodecContext *avctx, · 16 unmodified lines
1555	(frame_size = show_bits(gb, s->log2_frame_size)) &&	1560	(frame_size = show_bits(gb, s->log2_frame_size)) &&
1556	frame_size <= remaining_bits(s, gb)) {	1561	frame_size <= remaining_bits(s, gb)) {
1557	save_bits(s, gb, frame_size, 0);	1562	save_bits(s, gb, frame_size, 0);
1558	s->packet_done = !decode_frame(s);	1563	s->packet_done = !decode_frame(s, got_frame_ptr);
1559	} else if (!s->len_prefix	1564	} else if (!s->len_prefix
1560	&& s->num_saved_bits > get_bits_count(&s->gb)) {	1565	&& s->num_saved_bits > get_bits_count(&s->gb)) {
1561	/** when the frames do not have a length prefix, we don't know	1566	/** when the frames do not have a length prefix, we don't know
@@ -1565,7 +1570,7 @@ static int decode_packet(AVCodecContext *avctx, · 3 unmodified lines
1565	therefore we save the incoming packet first, then we append	1570	therefore we save the incoming packet first, then we append
1566	the "previous frame" data from the next packet so that	1571	the "previous frame" data from the next packet so that
1567	we get a buffer that only contains full frames */	1572	we get a buffer that only contains full frames */
1568	s->packet_done = !decode_frame(s);	1573	s->packet_done = !decode_frame(s, got_frame_ptr);
1569	} else	1574	} else
1570	s->packet_done = 1;	1575	s->packet_done = 1;
1571	}	1576	}
@@ -1577,10 +1582,14 @@ static int decode_packet(AVCodecContext *avctx, · 5 unmodified lines
1577	save_bits(s, gb, remaining_bits(s, gb), 0);	1582	save_bits(s, gb, remaining_bits(s, gb), 0);
1578	}	1583	}
1579		1584
1580	data_size = (int8_t )s->samples - (int8_t *)data;
1581	s->packet_offset = get_bits_count(gb) & 7;	1585	s->packet_offset = get_bits_count(gb) & 7;
		1586	if (s->packet_loss)
		1587	return AVERROR_INVALIDDATA;
		1588
		1589	if (*got_frame_ptr)
		1590	(AVFrame )data = s->frame;
1582		1591
1583	return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;	1592	return get_bits_count(gb) >> 3;
1584	}	1593	}
1585		1594
1586	/**	1595	/**
@@ -1611,7 +1620,7 @@ AVCodec ff_wmapro_decoder = { · 24 unmodified lines
1611	.init = decode_init,	1620	.init = decode_init,
1612	.close = decode_end,	1621	.close = decode_end,
1613	.decode = decode_packet,	1622	.decode = decode_packet,
1614	.capabilities = CODEC_CAP_SUBFRAMES,	1623	.capabilities = CODEC_CAP_SUBFRAMES \| CODEC_CAP_DR1,
1615	.flush= flush,	1624	.flush= flush,
1616	.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),	1625	.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
1617	};	1626	};

libavcodec/wmavoice.c+26−20

      * @name Global values specified in the stream header / extradata or used all over.
      * @{
      */
+    AVFrame frame;
     GetBitContext gb;             ///< packet bitreader. During decoder init,
                                   ///< it contains the extradata from the
                                   ///< demuxer. During decoding, it contains
     ctx->sample_fmt             = AV_SAMPLE_FMT_FLT;
+    avcodec_get_frame_defaults(&s->frame);
+    ctx->coded_frame = &s->frame;
     return 0;
 }
  * @return 0 on success, <0 on error or 1 if there was not enough data to
  *         fully parse the superframe
  */
-static int synth_superframe(AVCodecContext *ctx,
+static int synth_superframe(AVCodecContext *ctx, int *got_frame_ptr)
-                            float *samples, int *data_size)
 {
     WMAVoiceContext *s = ctx->priv_data;
     GetBitContext *gb = &s->gb, s_gb;
-    int n, res, out_size, n_samples = 480;
+    int n, res, n_samples = 480;
     double lsps[MAX_FRAMES][MAX_LSPS];
     const double *mean_lsf = s->lsps == 16 ?
         wmavoice_mean_lsf16[s->lsp_def_mode] : wmavoice_mean_lsf10[s->lsp_def_mode];
     float excitation[MAX_SIGNAL_HISTORY + MAX_SFRAMESIZE + 12];
     float synth[MAX_LSPS + MAX_SFRAMESIZE];
+    float *samples;
     memcpy(synth,      s->synth_history,
            s->lsps             * sizeof(*synth));
     }
     if ((res = check_bits_for_superframe(gb, s)) == 1) {
-        *data_size = 0;
+        *got_frame_ptr = 0;
         return 1;
     }
             stabilize_lsps(lsps[n], s->lsps);
     }
-    out_size = n_samples * av_get_bytes_per_sample(ctx->sample_fmt);
+    /* get output buffer */
-    if (*data_size < out_size) {
+    s->frame.nb_samples = 480;
-        av_log(ctx, AV_LOG_ERROR,
+    if ((res = ctx->get_buffer(ctx, &s->frame)) < 0) {
-               "Output buffer too small (%d given - %d needed)\n",
+        av_log(ctx, AV_LOG_ERROR, "get_buffer() failed\n");
-               *data_size, out_size);
+        return res;
-        return -1;
     }
+    s->frame.nb_samples = n_samples;
+    samples = (float *)s->frame.data[0];
     /* Parse frames, optionally preceeded by per-frame (independent) LSPs. */
     for (n = 0; n < 3; n++) {
                                lsps[n], n == 0 ? s->prev_lsps : lsps[n - 1],
                                &excitation[s->history_nsamples + n * MAX_FRAMESIZE],
                                &synth[s->lsps + n * MAX_FRAMESIZE]))) {
-            *data_size = 0;
+            *got_frame_ptr = 0;
             return res;
         }
     }
         skip_bits(gb, 10 * (res + 1));
     }
-    /* Specify nr. of output samples */
+    *got_frame_ptr = 1;
-    *data_size = out_size;
     /* Update history */
     memcpy(s->prev_lsps,           lsps[2],
  * For more information about frames, see #synth_superframe().
  */
 static int wmavoice_decode_packet(AVCodecContext *ctx, void *data,
-                                  int *data_size, AVPacket *avpkt)
+                                  int *got_frame_ptr, AVPacket *avpkt)
 {
     WMAVoiceContext *s = ctx->priv_data;
     GetBitContext *gb = &s->gb;
      * capping the packet size at ctx->block_align. */
     for (size = avpkt->size; size > ctx->block_align; size -= ctx->block_align);
     if (!size) {
-        *data_size = 0;
+        *got_frame_ptr = 0;
         return 0;
     }
     init_get_bits(&s->gb, avpkt->data, size << 3);
                 copy_bits(&s->pb, avpkt->data, size, gb, s->spillover_nbits);
                 flush_put_bits(&s->pb);
                 s->sframe_cache_size += s->spillover_nbits;
-                if ((res = synth_superframe(ctx, data, data_size)) == 0 &&
+                if ((res = synth_superframe(ctx, got_frame_ptr)) == 0 &&
-                    *data_size > 0) {
+                    *got_frame_ptr) {
                     cnt += s->spillover_nbits;
                     s->skip_bits_next = cnt & 7;
+                    *(AVFrame *)data = s->frame;
                     return cnt >> 3;
                 } else
                     skip_bits_long (gb, s->spillover_nbits - cnt +
     s->sframe_cache_size = 0;
     s->skip_bits_next = 0;
     pos = get_bits_left(gb);
-    if ((res = synth_superframe(ctx, data, data_size)) < 0) {
+    if ((res = synth_superframe(ctx, got_frame_ptr)) < 0) {
         return res;
-    } else if (*data_size > 0) {
+    } else if (*got_frame_ptr) {
         int cnt = get_bits_count(gb);
         s->skip_bits_next = cnt & 7;
+        *(AVFrame *)data = s->frame;
         return cnt >> 3;
     } else if ((s->sframe_cache_size = pos) > 0) {
         /* rewind bit reader to start of last (incomplete) superframe... */
     .init           = wmavoice_decode_init,
     .close          = wmavoice_decode_end,
     .decode         = wmavoice_decode_packet,
-    .capabilities   = CODEC_CAP_SUBFRAMES,
+    .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
     .flush     = wmavoice_flush,
     .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Voice"),
 };

libavcodec/ws-snd1.c+29−9

      0,  1,  2,  3,  4,  5,  6,  8
 };
+typedef struct WSSndContext {
+    AVFrame frame;
+} WSSndContext;
 static av_cold int ws_snd_decode_init(AVCodecContext *avctx)
 {
+    WSSndContext *s = avctx->priv_data;
     if (avctx->channels != 1) {
         av_log_ask_for_sample(avctx, "unsupported number of channels\n");
         return AVERROR(EINVAL);
     }
     avctx->sample_fmt = AV_SAMPLE_FMT_U8;
+    avcodec_get_frame_defaults(&s->frame);
+    avctx->coded_frame = &s->frame;
     return 0;
 }
 static int ws_snd_decode_frame(AVCodecContext *avctx, void *data,
-                               int *data_size, AVPacket *avpkt)
+                               int *got_frame_ptr, AVPacket *avpkt)
 {
+    WSSndContext *s = avctx->priv_data;
     const uint8_t *buf = avpkt->data;
     int buf_size       = avpkt->size;
-    int in_size, out_size;
+    int in_size, out_size, ret;
     int sample = 128;
-    uint8_t *samples = data;
+    uint8_t *samples;
     uint8_t *samples_end;
     if (!buf_size)
     in_size  = AV_RL16(&buf[2]);
     buf += 4;
-    if (out_size > *data_size) {
-        av_log(avctx, AV_LOG_ERROR, "Frame is too large to fit in buffer\n");
-        return -1;
-    }
     if (in_size > buf_size) {
         av_log(avctx, AV_LOG_ERROR, "Frame data is larger than input buffer\n");
         return -1;
     }
+    /* get output buffer */
+    s->frame.nb_samples = out_size;
+    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        return ret;
+    }
+    samples     = s->frame.data[0];
     samples_end = samples + out_size;
     if (in_size == out_size) {
         memcpy(samples, buf, out_size);
-        *data_size = out_size;
+        *got_frame_ptr   = 1;
+        *(AVFrame *)data = s->frame;
         return buf_size;
     }
         }
     }
-    *data_size = samples - (uint8_t *)data;
+    s->frame.nb_samples = samples - s->frame.data[0];
+    *got_frame_ptr   = 1;
+    *(AVFrame *)data = s->frame;
     return buf_size;
 }
     .name           = "ws_snd1",
     .type           = AVMEDIA_TYPE_AUDIO,
     .id             = CODEC_ID_WESTWOOD_SND1,
+    .priv_data_size = sizeof(WSSndContext),
     .init           = ws_snd_decode_init,
     .decode         = ws_snd_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
     .long_name = NULL_IF_CONFIG_SMALL("Westwood Audio (SND1)"),
 };

libavformat/adtsenc.c+1−1

@@ -37,7 +37,7 @@ int ff_adts_decode_extradata(AVFormatContext s, ADTSContext adts, uint8_t *buf · 36 unmodified lines
37	int off;	37	int off;
38		38
39	init_get_bits(&gb, buf, size * 8);	39	init_get_bits(&gb, buf, size * 8);
40	off = avpriv_mpeg4audio_get_config(&m4ac, buf, size);	40	off = avpriv_mpeg4audio_get_config(&m4ac, buf, size * 8, 1);
41	if (off < 0)	41	if (off < 0)
42	return off;	42	return off;
43	skip_bits_long(&gb, off);	43	skip_bits_long(&gb, off);

libavformat/asfdec.c+1−1

@@ -1182,7 +1182,7 @@ static int64_t asf_read_pts(AVFormatContext s, int stream_index, int64_t ppos, · 1181 unmodified lines
1182	return AV_NOPTS_VALUE;	1182	return AV_NOPTS_VALUE;
1183	}	1183	}
1184		1184
1185	pts= pkt->dts;	1185	pts = pkt->dts;
1186		1186
1187	av_free_packet(pkt);	1187	av_free_packet(pkt);
1188	if(pkt->flags&AV_PKT_FLAG_KEY){	1188	if(pkt->flags&AV_PKT_FLAG_KEY){

libavformat/flvdec.c+1−1

@@ -550,7 +550,7 @@ static int flv_read_packet(AVFormatContext s, AVPacket pkt) · 549 unmodified lines
550	if (st->codec->codec_id == CODEC_ID_AAC) {	550	if (st->codec->codec_id == CODEC_ID_AAC) {
551	MPEG4AudioConfig cfg;	551	MPEG4AudioConfig cfg;
552	avpriv_mpeg4audio_get_config(&cfg, st->codec->extradata,	552	avpriv_mpeg4audio_get_config(&cfg, st->codec->extradata,
553	st->codec->extradata_size);	553	st->codec->extradata_size * 8, 1);
554	st->codec->channels = cfg.channels;	554	st->codec->channels = cfg.channels;
555	if (cfg.ext_sample_rate)	555	if (cfg.ext_sample_rate)
556	st->codec->sample_rate = cfg.ext_sample_rate;	556	st->codec->sample_rate = cfg.ext_sample_rate;

libavformat/isom.c+1−1

@@ -438,7 +438,7 @@ int ff_mp4_read_dec_config_descr(AVFormatContext fc, AVStream st, AVIOContext · 437 unmodified lines
438	if (st->codec->codec_id == CODEC_ID_AAC) {	438	if (st->codec->codec_id == CODEC_ID_AAC) {
439	MPEG4AudioConfig cfg;	439	MPEG4AudioConfig cfg;
440	avpriv_mpeg4audio_get_config(&cfg, st->codec->extradata,	440	avpriv_mpeg4audio_get_config(&cfg, st->codec->extradata,
441	st->codec->extradata_size);	441	st->codec->extradata_size * 8, 1);
442	st->codec->channels = cfg.channels;	442	st->codec->channels = cfg.channels;
443	if (cfg.object_type == 29 && cfg.sampling_index < 3) // old mp3on4	443	if (cfg.object_type == 29 && cfg.sampling_index < 3) // old mp3on4
444	st->codec->sample_rate = avpriv_mpa_freq_tab[cfg.sampling_index];	444	st->codec->sample_rate = avpriv_mpa_freq_tab[cfg.sampling_index];

libavformat/latmenc.c+1−1

@@ -55,7 +55,7 @@ static int latm_decode_extradata(LATMContext ctx, uint8_t buf, int size) · 54 unmodified lines
55	MPEG4AudioConfig m4ac;	55	MPEG4AudioConfig m4ac;
56		56
57	init_get_bits(&gb, buf, size * 8);	57	init_get_bits(&gb, buf, size * 8);
58	ctx->off = avpriv_mpeg4audio_get_config(&m4ac, buf, size);	58	ctx->off = avpriv_mpeg4audio_get_config(&m4ac, buf, size * 8, 1);
59	if (ctx->off < 0)	59	if (ctx->off < 0)
60	return ctx->off;	60	return ctx->off;
61	skip_bits_long(&gb, ctx->off);	61	skip_bits_long(&gb, ctx->off);

libavformat/matroskaenc.c+2−1

@@ -448,7 +448,8 @@ static void get_aac_sample_rates(AVFormatContext s, AVCodecContext codec, int · 447 unmodified lines
448	{	448	{
449	MPEG4AudioConfig mp4ac;	449	MPEG4AudioConfig mp4ac;
450		450
451	if (avpriv_mpeg4audio_get_config(&mp4ac, codec->extradata, codec->extradata_size) < 0) {	451	if (avpriv_mpeg4audio_get_config(&mp4ac, codec->extradata,
		452	codec->extradata_size * 8, 1) < 0) {
452	av_log(s, AV_LOG_WARNING, "Error parsing AAC extradata, unable to determine samplerate.\n");	453	av_log(s, AV_LOG_WARNING, "Error parsing AAC extradata, unable to determine samplerate.\n");
453	return;	454	return;
454	}	455	}

libavformat/nullenc.c+1−1

@@ -32,5 +32,5 @@ AVOutputFormat ff_null_muxer = { · 31 unmodified lines
32	.audio_codec = AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE),	32	.audio_codec = AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE),
33	.video_codec = CODEC_ID_RAWVIDEO,	33	.video_codec = CODEC_ID_RAWVIDEO,
34	.write_packet = null_write_packet,	34	.write_packet = null_write_packet,
35	.flags = AVFMT_NOFILE \| AVFMT_NOTIMESTAMPS,	35	.flags = AVFMT_NOFILE \| AVFMT_NOTIMESTAMPS \| AVFMT_RAWPICTURE,
36	};	36	};

libavformat/rtsp.c+3−0

     struct sockaddr_storage addr;
     AVIOContext pb;
     socklen_t addrlen = sizeof(addr);
+    RTSPState *rt = s->priv_data;
     if (!ff_network_init())
         return AVERROR(EIO);
     /* sdp_read_header initializes this again */
     ff_network_close();
+    rt->media_type_mask = (1 << (AVMEDIA_TYPE_DATA+1)) - 1;
     ret = sdp_read_header(s, ap);
     s->pb = NULL;
     return ret;

Merge remote-tracking branch 'qatar/master'

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code