sigrid/ffmpeg

configure+1−1

@@ -107,7 +107,7 @@ Configuration options: · 106 unmodified lines
107	--disable-mdct disable MDCT code	107	--disable-mdct disable MDCT code
108	--disable-rdft disable RDFT code	108	--disable-rdft disable RDFT code
109	--enable-vaapi enable VAAPI code	109	--enable-vaapi enable VAAPI code
110	--disable-vdpau disable VDPAU code	110	--enable-vdpau enable VDPAU code
111	--disable-dxva2 disable DXVA2 code	111	--disable-dxva2 disable DXVA2 code
112	--enable-runtime-cpudetect detect cpu capabilities at runtime (bigger binary)	112	--enable-runtime-cpudetect detect cpu capabilities at runtime (bigger binary)
113	--enable-hardcoded-tables use hardcoded tables instead of runtime generation	113	--enable-hardcoded-tables use hardcoded tables instead of runtime generation

doc/APIchanges+4−0

@@ -50,6 +50,10 @@ API changes, most recent first: · 49 unmodified lines
50	2011-05-XX - XXXXXX - lavfi 2.6.0 - avcodec.h	50	2011-05-XX - XXXXXX - lavfi 2.6.0 - avcodec.h
51	Add avfilter_get_video_buffer_ref_from_frame() to libavfilter/avcodec.h.	51	Add avfilter_get_video_buffer_ref_from_frame() to libavfilter/avcodec.h.
52		52
		53	2011-06-07 - a6703fa - lavu 51.4.0 - av_get_bytes_per_sample()
		54	Add av_get_bytes_per_sample() in libavutil/samplefmt.h.
		55	Deprecate av_get_bits_per_sample_fmt().
		56
53	2011-06-xx - xxxxxxx - lavu 51.3.0 - opt.h	57	2011-06-xx - xxxxxxx - lavu 51.3.0 - opt.h
54	Add av_opt_free convenience function.	58	Add av_opt_free convenience function.
55		59

ffplay.c+4−8

@@ -54,9 +54,6 @@ · 53 unmodified lines
54	const char program_name[] = "ffplay";	54	const char program_name[] = "ffplay";
55	const int program_birth_year = 2003;	55	const int program_birth_year = 2003;
56		56
57	//#define DEBUG
58	//#define DEBUG_SYNC
59
60	#define MAX_QUEUE_SIZE (15 * 1024 * 1024)	57	#define MAX_QUEUE_SIZE (15 * 1024 * 1024)
61	#define MIN_AUDIOQ_SIZE (20 * 16 * 1024)	58	#define MIN_AUDIOQ_SIZE (20 * 16 * 1024)
62	#define MIN_FRAMES 5	59	#define MIN_FRAMES 5
@@ -1052,10 +1049,9 @@ static double compute_target_time(double frame_current_pts, VideoState *is) · 989 unmodified lines
1052	}	1049	}
1053	}	1050	}
1054	is->frame_timer += delay;	1051	is->frame_timer += delay;
1055	#if defined(DEBUG_SYNC)	1052
1056	printf("video: delay=%0.3f actual_delay=%0.3f pts=%0.3f A-V=%f\n",	1053	av_dlog(NULL, "video: delay=%0.3f pts=%0.3f A-V=%f\n",
1057	delay, actual_delay, frame_current_pts, -diff);	1054	delay, frame_current_pts, -diff);
1058	#endif
1059		1055
1060	return is->frame_timer;	1056	return is->frame_timer;
1061	}	1057	}
@@ -2033,7 +2029,7 @@ static int audio_decode_frame(VideoState is, double pts_ptr) · 971 unmodified lines
2033	n = 2 * dec->channels;	2029	n = 2 * dec->channels;
2034	is->audio_clock += (double)data_size /	2030	is->audio_clock += (double)data_size /
2035	(double)(n * dec->sample_rate);	2031	(double)(n * dec->sample_rate);
2036	#if defined(DEBUG_SYNC)	2032	#ifdef DEBUG
2037	{	2033	{
2038	static double last_clock;	2034	static double last_clock;
2039	printf("audio: delay=%0.3f clock=%0.3f pts=%0.3f\n",	2035	printf("audio: delay=%0.3f clock=%0.3f pts=%0.3f\n",

libavcodec/Makefile+2−1

 OBJS-$(CONFIG_DVVIDEO_ENCODER)         += dv.o dvdata.o
 OBJS-$(CONFIG_DXA_DECODER)             += dxa.o
 OBJS-$(CONFIG_EAC3_DECODER)            += eac3dec.o eac3dec_data.o
-OBJS-$(CONFIG_EAC3_ENCODER)            += ac3enc_float.o ac3tab.o ac3.o kbdwin.o
+OBJS-$(CONFIG_EAC3_ENCODER)            += eac3enc.o ac3enc_float.o ac3tab.o \
+                                          ac3.o kbdwin.o
 OBJS-$(CONFIG_EACMV_DECODER)           += eacmv.o
 OBJS-$(CONFIG_EAMAD_DECODER)           += eamad.o eaidct.o mpeg12.o \
                                           mpeg12data.o mpegvideo.o  \

libavcodec/aac_tablegen.h+1−1

@@ -29,7 +29,7 @@ · 28 unmodified lines
29	#include "libavcodec/aac_tables.h"	29	#include "libavcodec/aac_tables.h"
30	#else	30	#else
31	#include "libavutil/mathematics.h"	31	#include "libavutil/mathematics.h"
32	#include "libavcodec/aac.h"	32	#include "aac.h"
33	float ff_aac_pow2sf_tab[428];	33	float ff_aac_pow2sf_tab[428];
34		34
35	void ff_aac_tableinit(void)	35	void ff_aac_tableinit(void)

libavcodec/ac3.h+0−1

@@ -164,7 +164,6 @@ typedef struct AC3EncOptions { · 163 unmodified lines
164	int cpl_start;	164	int cpl_start;
165	} AC3EncOptions;	165	} AC3EncOptions;
166		166
167
168	void ff_ac3_common_init(void);	167	void ff_ac3_common_init(void);
169		168
170	extern const int64_t ff_ac3_channel_layouts[];	169	extern const int64_t ff_ac3_channel_layouts[];

libavcodec/ac3enc.c+6−251

@@ -26,7 +26,6 @@ · 25 unmodified lines
26	* The simplest AC-3 encoder.	26	* The simplest AC-3 encoder.
27	*/	27	*/
28		28
29	//#define DEBUG
30	//#define ASSERT_LEVEL 2	29	//#define ASSERT_LEVEL 2
31		30
32	#include <stdint.h>	31	#include <stdint.h>
@@ -44,153 +43,8 @@ · 11 unmodified lines
44	#include "audioconvert.h"	43	#include "audioconvert.h"
45	#include "fft.h"	44	#include "fft.h"
46		45
47		46	#include "ac3enc.h"
48	#ifndef CONFIG_AC3ENC_FLOAT	47	#include "eac3enc.h"
49	#define CONFIG_AC3ENC_FLOAT 0
50	#endif
51
52
53	/** Maximum number of exponent groups. +1 for separate DC exponent. */
54	#define AC3_MAX_EXP_GROUPS 85
55
56	#if CONFIG_AC3ENC_FLOAT
57	#define MAC_COEF(d,a,b) ((d)+=(a)*(b))
58	typedef float SampleType;
59	typedef float CoefType;
60	typedef float CoefSumType;
61	#else
62	#define MAC_COEF(d,a,b) MAC64(d,a,b)
63	typedef int16_t SampleType;
64	typedef int32_t CoefType;
65	typedef int64_t CoefSumType;
66	#endif
67
68	typedef struct AC3MDCTContext {
69	const SampleType *window; ///< MDCT window function
70	FFTContext fft; ///< FFT context for MDCT calculation
71	} AC3MDCTContext;
72
73
74	/**
75	* Data for a single audio block.
76	*/
77	typedef struct AC3Block {
78	CoefType **mdct_coef; ///< MDCT coefficients
79	int32_t **fixed_coef; ///< fixed-point MDCT coefficients
80	uint8_t **exp; ///< original exponents
81	uint8_t **grouped_exp; ///< grouped exponents
82	int16_t **psd; ///< psd per frequency bin
83	int16_t **band_psd; ///< psd per critical band
84	int16_t **mask; ///< masking curve
85	uint16_t **qmant; ///< quantized mantissas
86	uint8_t **cpl_coord_exp; ///< coupling coord exponents (cplcoexp)
87	uint8_t **cpl_coord_mant; ///< coupling coord mantissas (cplcomant)
88	uint8_t coeff_shift[AC3_MAX_CHANNELS]; ///< fixed-point coefficient shift values
89	uint8_t new_rematrixing_strategy; ///< send new rematrixing flags in this block
90	int num_rematrixing_bands; ///< number of rematrixing bands
91	uint8_t rematrixing_flags[4]; ///< rematrixing flags
92	int new_cpl_strategy; ///< send new coupling strategy
93	int cpl_in_use; ///< coupling in use for this block (cplinu)
94	uint8_t channel_in_cpl[AC3_MAX_CHANNELS]; ///< channel in coupling (chincpl)
95	int num_cpl_channels; ///< number of channels in coupling
96	uint8_t new_cpl_coords; ///< send new coupling coordinates (cplcoe)
97	uint8_t cpl_master_exp[AC3_MAX_CHANNELS]; ///< coupling coord master exponents (mstrcplco)
98	int new_snr_offsets; ///< send new SNR offsets
99	int new_cpl_leak; ///< send new coupling leak info
100	int end_freq[AC3_MAX_CHANNELS]; ///< end frequency bin (endmant)
101	} AC3Block;
102
103	/**
104	* AC-3 encoder private context.
105	*/
106	typedef struct AC3EncodeContext {
107	AVClass *av_class; ///< AVClass used for AVOption
108	AC3EncOptions options; ///< encoding options
109	PutBitContext pb; ///< bitstream writer context
110	DSPContext dsp;
111	AC3DSPContext ac3dsp; ///< AC-3 optimized functions
112	AC3MDCTContext mdct; ///< MDCT context
113
114	AC3Block blocks[AC3_MAX_BLOCKS]; ///< per-block info
115
116	int eac3; ///< indicates if this is E-AC-3 vs. AC-3
117	int bitstream_id; ///< bitstream id (bsid)
118	int bitstream_mode; ///< bitstream mode (bsmod)
119
120	int bit_rate; ///< target bit rate, in bits-per-second
121	int sample_rate; ///< sampling frequency, in Hz
122
123	int frame_size_min; ///< minimum frame size in case rounding is necessary
124	int frame_size; ///< current frame size in bytes
125	int frame_size_code; ///< frame size code (frmsizecod)
126	uint16_t crc_inv[2];
127	int64_t bits_written; ///< bit count (used to avg. bitrate)
128	int64_t samples_written; ///< sample count (used to avg. bitrate)
129
130	int fbw_channels; ///< number of full-bandwidth channels (nfchans)
131	int channels; ///< total number of channels (nchans)
132	int lfe_on; ///< indicates if there is an LFE channel (lfeon)
133	int lfe_channel; ///< channel index of the LFE channel
134	int has_center; ///< indicates if there is a center channel
135	int has_surround; ///< indicates if there are one or more surround channels
136	int channel_mode; ///< channel mode (acmod)
137	const uint8_t *channel_map; ///< channel map used to reorder channels
138
139	int center_mix_level; ///< center mix level code
140	int surround_mix_level; ///< surround mix level code
141	int ltrt_center_mix_level; ///< Lt/Rt center mix level code
142	int ltrt_surround_mix_level; ///< Lt/Rt surround mix level code
143	int loro_center_mix_level; ///< Lo/Ro center mix level code
144	int loro_surround_mix_level; ///< Lo/Ro surround mix level code
145
146	int cutoff; ///< user-specified cutoff frequency, in Hz
147	int bandwidth_code; ///< bandwidth code (0 to 60) (chbwcod)
148	int start_freq[AC3_MAX_CHANNELS]; ///< start frequency bin (strtmant)
149	int cpl_end_freq; ///< coupling channel end frequency bin
150
151	int cpl_on; ///< coupling turned on for this frame
152	int cpl_enabled; ///< coupling enabled for all frames
153	int num_cpl_subbands; ///< number of coupling subbands (ncplsubnd)
154	int num_cpl_bands; ///< number of coupling bands (ncplbnd)
155	uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS]; ///< number of coeffs in each coupling band
156
157	int rematrixing_enabled; ///< stereo rematrixing enabled
158
159	/* bitrate allocation control */
160	int slow_gain_code; ///< slow gain code (sgaincod)
161	int slow_decay_code; ///< slow decay code (sdcycod)
162	int fast_decay_code; ///< fast decay code (fdcycod)
163	int db_per_bit_code; ///< dB/bit code (dbpbcod)
164	int floor_code; ///< floor code (floorcod)
165	AC3BitAllocParameters bit_alloc; ///< bit allocation parameters
166	int coarse_snr_offset; ///< coarse SNR offsets (csnroffst)
167	int fast_gain_code[AC3_MAX_CHANNELS]; ///< fast gain codes (signal-to-mask ratio) (fgaincod)
168	int fine_snr_offset[AC3_MAX_CHANNELS]; ///< fine SNR offsets (fsnroffst)
169	int frame_bits_fixed; ///< number of non-coefficient bits for fixed parameters
170	int frame_bits; ///< all frame bits except exponents and mantissas
171	int exponent_bits; ///< number of bits used for exponents
172
173	SampleType **planar_samples;
174	uint8_t *bap_buffer;
175	uint8_t *bap1_buffer;
176	CoefType *mdct_coef_buffer;
177	int32_t *fixed_coef_buffer;
178	uint8_t *exp_buffer;
179	uint8_t *grouped_exp_buffer;
180	int16_t *psd_buffer;
181	int16_t *band_psd_buffer;
182	int16_t *mask_buffer;
183	uint16_t *qmant_buffer;
184	uint8_t *cpl_coord_exp_buffer;
185	uint8_t *cpl_coord_mant_buffer;
186
187	uint8_t exp_strategy[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< exponent strategies
188	uint8_t exp_ref_block[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< reference blocks for EXP_REUSE
189	uint8_t *ref_bap [AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< bit allocation pointers (bap)
190	int ref_bap_set; ///< indicates if ref_bap pointers have been set
191
192	DECLARE_ALIGNED(32, SampleType, windowed_samples)[AC3_WINDOW_SIZE];
193	} AC3EncodeContext;
194		48
195	typedef struct AC3Mant {	49	typedef struct AC3Mant {
196	uint16_t qmant1_ptr, qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4	50	uint16_t qmant1_ptr, qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4
@@ -715,34 +569,8 @@ static void apply_channel_coupling(AC3EncodeContext *s) · 518 unmodified lines
715	}	569	}
716	}	570	}
717		571
718	if (s->eac3) {	572	if (CONFIG_EAC3_ENCODER && s->eac3)
719	/* set first cpl coords */	573	ff_eac3_set_cpl_states(s);
720	int first_cpl_coords[AC3_MAX_CHANNELS];
721	for (ch = 1; ch <= s->fbw_channels; ch++)
722	first_cpl_coords[ch] = 1;
723	for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
724	AC3Block *block = &s->blocks[blk];
725	for (ch = 1; ch <= s->fbw_channels; ch++) {
726	if (block->channel_in_cpl[ch]) {
727	if (first_cpl_coords[ch]) {
728	block->new_cpl_coords = 2;
729	first_cpl_coords[ch] = 0;
730	}
731	} else {
732	first_cpl_coords[ch] = 1;
733	}
734	}
735	}
736
737	/* set first cpl leak */
738	for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
739	AC3Block *block = &s->blocks[blk];
740	if (block->cpl_in_use) {
741	block->new_cpl_leak = 2;
742	break;
743	}
744	}
745	}
746	#endif /* CONFIG_AC3ENC_FLOAT */	574	#endif /* CONFIG_AC3ENC_FLOAT */
747	}	575	}
748		576
@@ -1879,79 +1707,6 @@ static void ac3_output_frame_header(AC3EncodeContext *s) · 1130 unmodified lines
1879	}	1707	}
1880		1708
1881		1709
1882	/**
1883	* Write the E-AC-3 frame header to the output bitstream.
1884	*/
1885	static void eac3_output_frame_header(AC3EncodeContext *s)
1886	{
1887	int blk, ch;
1888	AC3EncOptions *opt = &s->options;
1889
1890	put_bits(&s->pb, 16, 0x0b77); /* sync word */
1891
1892	/* BSI header */
1893	put_bits(&s->pb, 2, 0); /* stream type = independent */
1894	put_bits(&s->pb, 3, 0); /* substream id = 0 */
1895	put_bits(&s->pb, 11, (s->frame_size / 2) - 1); /* frame size */
1896	if (s->bit_alloc.sr_shift) {
1897	put_bits(&s->pb, 2, 0x3); /* fscod2 */
1898	put_bits(&s->pb, 2, s->bit_alloc.sr_code); /* sample rate code */
1899	} else {
1900	put_bits(&s->pb, 2, s->bit_alloc.sr_code); /* sample rate code */
1901	put_bits(&s->pb, 2, 0x3); /* number of blocks = 6 */
1902	}
1903	put_bits(&s->pb, 3, s->channel_mode); /* audio coding mode */
1904	put_bits(&s->pb, 1, s->lfe_on); /* LFE channel indicator */
1905	put_bits(&s->pb, 5, s->bitstream_id); /* bitstream id (EAC3=16) */
1906	put_bits(&s->pb, 5, -opt->dialogue_level); /* dialogue normalization level */
1907	put_bits(&s->pb, 1, 0); /* no compression gain */
1908	put_bits(&s->pb, 1, 0); /* no mixing metadata */
1909	/* TODO: mixing metadata */
1910	put_bits(&s->pb, 1, 0); /* no info metadata */
1911	/* TODO: info metadata */
1912	put_bits(&s->pb, 1, 0); /* no additional bit stream info */
1913
1914	/* frame header */
1915	put_bits(&s->pb, 1, 1); /* exponent strategy syntax = each block */
1916	put_bits(&s->pb, 1, 0); /* aht enabled = no */
1917	put_bits(&s->pb, 2, 0); /* snr offset strategy = 1 */
1918	put_bits(&s->pb, 1, 0); /* transient pre-noise processing enabled = no */
1919	put_bits(&s->pb, 1, 0); /* block switch syntax enabled = no */
1920	put_bits(&s->pb, 1, 0); /* dither flag syntax enabled = no */
1921	put_bits(&s->pb, 1, 0); /* bit allocation model syntax enabled = no */
1922	put_bits(&s->pb, 1, 0); /* fast gain codes enabled = no */
1923	put_bits(&s->pb, 1, 0); /* dba syntax enabled = no */
1924	put_bits(&s->pb, 1, 0); /* skip field syntax enabled = no */
1925	put_bits(&s->pb, 1, 0); /* spx enabled = no */
1926	/* coupling strategy use flags */
1927	if (s->channel_mode > AC3_CHMODE_MONO) {
1928	put_bits(&s->pb, 1, s->blocks[0].cpl_in_use);
1929	for (blk = 1; blk < AC3_MAX_BLOCKS; blk++) {
1930	AC3Block *block = &s->blocks[blk];
1931	put_bits(&s->pb, 1, block->new_cpl_strategy);
1932	if (block->new_cpl_strategy)
1933	put_bits(&s->pb, 1, block->cpl_in_use);
1934	}
1935	}
1936	/* exponent strategy */
1937	for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
1938	for (ch = !s->blocks[blk].cpl_in_use; ch <= s->fbw_channels; ch++)
1939	put_bits(&s->pb, 2, s->exp_strategy[ch][blk]);
1940	if (s->lfe_on) {
1941	for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
1942	put_bits(&s->pb, 1, s->exp_strategy[s->lfe_channel][blk]);
1943	}
1944	/* E-AC-3 to AC-3 converter exponent strategy (unfortunately not optional...) */
1945	for (ch = 1; ch <= s->fbw_channels; ch++)
1946	put_bits(&s->pb, 5, 0);
1947	/* snr offsets */
1948	put_bits(&s->pb, 6, s->coarse_snr_offset);
1949	put_bits(&s->pb, 4, s->fine_snr_offset[1]);
1950	/* block start info */
1951	put_bits(&s->pb, 1, 0);
1952	}
1953
1954
1955	/**	1710	/**
1956	* Write one audio block to the output bitstream.	1711	* Write one audio block to the output bitstream.
1957	*/	1712	*/
@@ -2235,8 +1990,8 @@ static void output_frame(AC3EncodeContext s, unsigned char frame) · 277 unmodified lines
2235		1990
2236	init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE);	1991	init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE);
2237		1992
2238	if (s->eac3)	1993	if (CONFIG_EAC3_ENCODER && s->eac3)
2239	eac3_output_frame_header(s);	1994	ff_eac3_output_frame_header(s);
2240	else	1995	else
2241	ac3_output_frame_header(s);	1996	ac3_output_frame_header(s);
2242		1997

libavcodec/ac3enc.h+214−0

@@ -0,0 +1,214 @@
	1	/*
	2	* AC-3 encoder & E-AC-3 encoder common header
	3	* Copyright (c) 2000 Fabrice Bellard
	4	* Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com>
	5	*
	6	* This file is part of Libav.
	7	*
	8	* Libav is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License as published by the Free Software Foundation; either
	11	* version 2.1 of the License, or (at your option) any later version.
	12	*
	13	* Libav is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* Lesser General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU Lesser General Public
	19	* License along with Libav; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	21	*/
	22
	23	/**
	24	* @file
	25	* AC-3 encoder & E-AC-3 encoder common header
	26	*/
	27
	28	#ifndef AVCODEC_AC3ENC_H
	29	#define AVCODEC_AC3ENC_H
	30
	31	#include <stdint.h>
	32	#include "ac3.h"
	33	#include "ac3dsp.h"
	34	#include "avcodec.h"
	35	#include "dsputil.h"
	36	#include "put_bits.h"
	37	#include "fft.h"
	38
	39	#ifndef CONFIG_AC3ENC_FLOAT
	40	#define CONFIG_AC3ENC_FLOAT 0
	41	#endif
	42
	43	#if CONFIG_AC3ENC_FLOAT
	44	#define MAC_COEF(d,a,b) ((d)+=(a)*(b))
	45	typedef float SampleType;
	46	typedef float CoefType;
	47	typedef float CoefSumType;
	48	#else
	49	#define MAC_COEF(d,a,b) MAC64(d,a,b)
	50	typedef int16_t SampleType;
	51	typedef int32_t CoefType;
	52	typedef int64_t CoefSumType;
	53	#endif
	54
	55	typedef struct AC3MDCTContext {
	56	const SampleType *window; ///< MDCT window function
	57	FFTContext fft; ///< FFT context for MDCT calculation
	58	} AC3MDCTContext;
	59	#if 0
	60	/**
	61	* Encoding Options used by AVOption.
	62	*/
	63	typedef struct AC3EncOptions {
	64	/* AC-3 metadata options*/
	65	int dialogue_level;
	66	int bitstream_mode;
	67	float center_mix_level;
	68	float surround_mix_level;
	69	int dolby_surround_mode;
	70	int audio_production_info;
	71	int mixing_level;
	72	int room_type;
	73	int copyright;
	74	int original;
	75	int extended_bsi_1;
	76	int preferred_stereo_downmix;
	77	float ltrt_center_mix_level;
	78	float ltrt_surround_mix_level;
	79	float loro_center_mix_level;
	80	float loro_surround_mix_level;
	81	int extended_bsi_2;
	82	int dolby_surround_ex_mode;
	83	int dolby_headphone_mode;
	84	int ad_converter_type;
	85
	86	/* other encoding options */
	87	int allow_per_frame_metadata;
	88	int stereo_rematrixing;
	89	int channel_coupling;
	90	int cpl_start;
	91	} AC3EncOptions;
	92	#endif
	93	/**
	94	* Data for a single audio block.
	95	*/
	96	typedef struct AC3Block {
	97	CoefType **mdct_coef; ///< MDCT coefficients
	98	int32_t **fixed_coef; ///< fixed-point MDCT coefficients
	99	uint8_t **exp; ///< original exponents
	100	uint8_t **grouped_exp; ///< grouped exponents
	101	int16_t **psd; ///< psd per frequency bin
	102	int16_t **band_psd; ///< psd per critical band
	103	int16_t **mask; ///< masking curve
	104	uint16_t **qmant; ///< quantized mantissas
	105	uint8_t **cpl_coord_exp; ///< coupling coord exponents (cplcoexp)
	106	uint8_t **cpl_coord_mant; ///< coupling coord mantissas (cplcomant)
	107	uint8_t coeff_shift[AC3_MAX_CHANNELS]; ///< fixed-point coefficient shift values
	108	uint8_t new_rematrixing_strategy; ///< send new rematrixing flags in this block
	109	int num_rematrixing_bands; ///< number of rematrixing bands
	110	uint8_t rematrixing_flags[4]; ///< rematrixing flags
	111	int new_cpl_strategy; ///< send new coupling strategy
	112	int cpl_in_use; ///< coupling in use for this block (cplinu)
	113	uint8_t channel_in_cpl[AC3_MAX_CHANNELS]; ///< channel in coupling (chincpl)
	114	int num_cpl_channels; ///< number of channels in coupling
	115	uint8_t new_cpl_coords; ///< send new coupling coordinates (cplcoe)
	116	uint8_t cpl_master_exp[AC3_MAX_CHANNELS]; ///< coupling coord master exponents (mstrcplco)
	117	int new_snr_offsets; ///< send new SNR offsets
	118	int new_cpl_leak; ///< send new coupling leak info
	119	int end_freq[AC3_MAX_CHANNELS]; ///< end frequency bin (endmant)
	120	} AC3Block;
	121
	122	/**
	123	* AC-3 encoder private context.
	124	*/
	125	typedef struct AC3EncodeContext {
	126	AVClass *av_class; ///< AVClass used for AVOption
	127	AC3EncOptions options; ///< encoding options
	128	PutBitContext pb; ///< bitstream writer context
	129	DSPContext dsp;
	130	AC3DSPContext ac3dsp; ///< AC-3 optimized functions
	131	AC3MDCTContext mdct; ///< MDCT context
	132
	133	AC3Block blocks[AC3_MAX_BLOCKS]; ///< per-block info
	134
	135	int eac3; ///< indicates if this is E-AC-3 vs. AC-3
	136	int bitstream_id; ///< bitstream id (bsid)
	137	int bitstream_mode; ///< bitstream mode (bsmod)
	138
	139	int bit_rate; ///< target bit rate, in bits-per-second
	140	int sample_rate; ///< sampling frequency, in Hz
	141
	142	int frame_size_min; ///< minimum frame size in case rounding is necessary
	143	int frame_size; ///< current frame size in bytes
	144	int frame_size_code; ///< frame size code (frmsizecod)
	145	uint16_t crc_inv[2];
	146	int64_t bits_written; ///< bit count (used to avg. bitrate)
	147	int64_t samples_written; ///< sample count (used to avg. bitrate)
	148
	149	int fbw_channels; ///< number of full-bandwidth channels (nfchans)
	150	int channels; ///< total number of channels (nchans)
	151	int lfe_on; ///< indicates if there is an LFE channel (lfeon)
	152	int lfe_channel; ///< channel index of the LFE channel
	153	int has_center; ///< indicates if there is a center channel
	154	int has_surround; ///< indicates if there are one or more surround channels
	155	int channel_mode; ///< channel mode (acmod)
	156	const uint8_t *channel_map; ///< channel map used to reorder channels
	157
	158	int center_mix_level; ///< center mix level code
	159	int surround_mix_level; ///< surround mix level code
	160	int ltrt_center_mix_level; ///< Lt/Rt center mix level code
	161	int ltrt_surround_mix_level; ///< Lt/Rt surround mix level code
	162	int loro_center_mix_level; ///< Lo/Ro center mix level code
	163	int loro_surround_mix_level; ///< Lo/Ro surround mix level code
	164
	165	int cutoff; ///< user-specified cutoff frequency, in Hz
	166	int bandwidth_code; ///< bandwidth code (0 to 60) (chbwcod)
	167	int start_freq[AC3_MAX_CHANNELS]; ///< start frequency bin (strtmant)
	168	int cpl_end_freq; ///< coupling channel end frequency bin
	169
	170	int cpl_on; ///< coupling turned on for this frame
	171	int cpl_enabled; ///< coupling enabled for all frames
	172	int num_cpl_subbands; ///< number of coupling subbands (ncplsubnd)
	173	int num_cpl_bands; ///< number of coupling bands (ncplbnd)
	174	uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS]; ///< number of coeffs in each coupling band
	175
	176	int rematrixing_enabled; ///< stereo rematrixing enabled
	177
	178	/* bitrate allocation control */
	179	int slow_gain_code; ///< slow gain code (sgaincod)
	180	int slow_decay_code; ///< slow decay code (sdcycod)
	181	int fast_decay_code; ///< fast decay code (fdcycod)
	182	int db_per_bit_code; ///< dB/bit code (dbpbcod)
	183	int floor_code; ///< floor code (floorcod)
	184	AC3BitAllocParameters bit_alloc; ///< bit allocation parameters
	185	int coarse_snr_offset; ///< coarse SNR offsets (csnroffst)
	186	int fast_gain_code[AC3_MAX_CHANNELS]; ///< fast gain codes (signal-to-mask ratio) (fgaincod)
	187	int fine_snr_offset[AC3_MAX_CHANNELS]; ///< fine SNR offsets (fsnroffst)
	188	int frame_bits_fixed; ///< number of non-coefficient bits for fixed parameters
	189	int frame_bits; ///< all frame bits except exponents and mantissas
	190	int exponent_bits; ///< number of bits used for exponents
	191
	192	SampleType **planar_samples;
	193	uint8_t *bap_buffer;
	194	uint8_t *bap1_buffer;
	195	CoefType *mdct_coef_buffer;
	196	int32_t *fixed_coef_buffer;
	197	uint8_t *exp_buffer;
	198	uint8_t *grouped_exp_buffer;
	199	int16_t *psd_buffer;
	200	int16_t *band_psd_buffer;
	201	int16_t *mask_buffer;
	202	uint16_t *qmant_buffer;
	203	uint8_t *cpl_coord_exp_buffer;
	204	uint8_t *cpl_coord_mant_buffer;
	205
	206	uint8_t exp_strategy[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< exponent strategies
	207	uint8_t exp_ref_block[AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< reference blocks for EXP_REUSE
	208	uint8_t *ref_bap [AC3_MAX_CHANNELS][AC3_MAX_BLOCKS]; ///< bit allocation pointers (bap)
	209	int ref_bap_set; ///< indicates if ref_bap pointers have been set
	210
	211	DECLARE_ALIGNED(32, SampleType, windowed_samples)[AC3_WINDOW_SIZE];
	212	} AC3EncodeContext;
	213
	214	#endif /* AVCODEC_AC3ENC_H */

libavcodec/bitstream.c+6−20

 /* VLC decoding */
-//#define DEBUG_VLC
 #define GET_DATA(v, table, i, wrap, size) \
 {\
     const uint8_t *ptr = (const uint8_t *)table + i * wrap;\
     table_size = 1 << table_nb_bits;
     table_index = alloc_table(vlc, table_size, flags & INIT_VLC_USE_NEW_STATIC);
-#ifdef DEBUG_VLC
+    av_dlog(NULL, "new table index=%d size=%d\n", table_index, table_size);
-    av_log(NULL,AV_LOG_DEBUG,"new table index=%d size=%d\n",
-           table_index, table_size);
-#endif
     if (table_index < 0)
         return -1;
     table = &vlc->table[table_index];
         n = codes[i].bits;
         code = codes[i].code;
         symbol = codes[i].symbol;
-#if defined(DEBUG_VLC) && 0
+        av_dlog(NULL, "i=%d n=%d code=0x%x\n", i, n, code);
-        av_log(NULL,AV_LOG_DEBUG,"i=%d n=%d code=0x%x\n", i, n, code);
-#endif
         if (n <= table_nb_bits) {
             /* no need to add another table */
             j = code >> (32 - table_nb_bits);
                 inc = 1 << n;
             }
             for (k = 0; k < nb; k++) {
-#ifdef DEBUG_VLC
+                av_dlog(NULL, "%4x: code=%d n=%d\n", j, i, n);
-                av_log(NULL, AV_LOG_DEBUG, "%4x: code=%d n=%d\n",
-                       j, i, n);
-#endif
                 if (table[j][1] /*bits*/ != 0) {
                     av_log(NULL, AV_LOG_ERROR, "incorrect codes\n");
                     return -1;
             subtable_bits = FFMIN(subtable_bits, table_nb_bits);
             j = (flags & INIT_VLC_LE) ? bitswap_32(code_prefix) >> (32 - table_nb_bits) : code_prefix;
             table[j][1] = -subtable_bits;
-#ifdef DEBUG_VLC
+            av_dlog(NULL, "%4x: n=%d (subtable)\n",
-            av_log(NULL,AV_LOG_DEBUG,"%4x: n=%d (subtable)\n",
+                    j, codes[i].bits + table_nb_bits);
-                   j, codes[i].bits + table_nb_bits);
-#endif
             index = build_table(vlc, subtable_bits, k-i, codes+i, flags);
             if (index < 0)
                 return -1;
         vlc->table_size = 0;
     }
-#ifdef DEBUG_VLC
+    av_dlog(NULL, "build table nb_codes=%d\n", nb_codes);
-    av_log(NULL,AV_LOG_DEBUG,"build table nb_codes=%d\n", nb_codes);
-#endif
     buf = av_malloc((nb_codes+1)*sizeof(VLCcode));

libavcodec/dnxhdenc.h+3−2

@@ -25,8 +25,9 @@ · 24 unmodified lines
25	#define AVCODEC_DNXHDENC_H	25	#define AVCODEC_DNXHDENC_H
26		26
27	#include <stdint.h>	27	#include <stdint.h>
28	#include "libavcodec/mpegvideo.h"	28
29	#include "libavcodec/dnxhddata.h"	29	#include "mpegvideo.h"
		30	#include "dnxhddata.h"
30		31
31	typedef struct {	32	typedef struct {
32	uint16_t mb;	33	uint16_t mb;

libavcodec/dv.c+7−21

     return dvvideo_init(avctx);
 }
-// #define VLC_DEBUG
-// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
 typedef struct BlockInfo {
     const uint32_t *factor_table;
     const uint8_t *scan_table;
     /* get the AC coefficients until last_index is reached */
     for (;;) {
-#ifdef VLC_DEBUG
+        av_dlog(NULL, "%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16),
-        printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
+                re_index);
-#endif
         /* our own optimized GET_RL_VLC */
         index   = NEG_USR32(re_cache, TEX_VLC_BITS);
         vlc_len = dv_rl_vlc[index].len;
         }
         re_index += vlc_len;
-#ifdef VLC_DEBUG
+        av_dlog(NULL, "run=%d level=%d\n", run, level);
-        printf("run=%d level=%d\n", run, level);
-#endif
         pos += run;
         if (pos >= 64)
             break;
             mb->pos               = 0;
             mb->partial_bit_count = 0;
-#ifdef VLC_DEBUG
+            av_dlog(avctx, "MB block: %d, %d ", mb_index, j);
-            printf("MB block: %d, %d ", mb_index, j);
-#endif
             dv_decode_ac(&gb, mb, block);
             /* write the remaining bits  in a new buffer only if the
         }
         /* pass 2 : we can do it just after */
-#ifdef VLC_DEBUG
+        av_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
-        printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
-#endif
         block = block1;
         mb    = mb1;
         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
     }
     /* we need a pass other the whole video segment */
-#ifdef VLC_DEBUG
+    av_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
-    printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
-#endif
     block = &sblock[0][0];
     mb    = mb_data;
     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
     for (mb_index = 0; mb_index < 5; mb_index++) {
         for (j = 0; j < s->sys->bpm; j++) {
             if (mb->pos < 64) {
-#ifdef VLC_DEBUG
+                av_dlog(avctx, "start %d:%d\n", mb_index, j);
-                printf("start %d:%d\n", mb_index, j);
-#endif
                 dv_decode_ac(&gb, mb, block);
             }
             if (mb->pos >= 64 && mb->pos < 127)

libavcodec/dvbsub_parser.c+4−12

 #include "dsputil.h"
 #include "get_bits.h"
-//#define DEBUG
-//#define DEBUG_PACKET_CONTENTS
 /* Parser (mostly) copied from dvdsub.c */
 #define PARSE_BUF_SIZE  (65536)
 {
     DVBSubParseContext *pc = s->priv_data;
     uint8_t *p, *p_end;
-    int len, buf_pos = 0;
+    int i, len, buf_pos = 0;
     av_dlog(avctx, "DVB parse packet pts=%"PRIx64", lpts=%"PRIx64", cpts=%"PRIx64":\n",
             s->pts, s->last_pts, s->cur_frame_pts[s->cur_frame_start_index]);
-#ifdef DEBUG_PACKET_CONTENTS
-    int i;
     for (i=0; i < buf_size; i++)
     {
-        av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
+        av_dlog(avctx, "%02x ", buf[i]);
         if (i % 16 == 15)
-            av_log(avctx, AV_LOG_INFO, "\n");
+            av_dlog(avctx, "\n");
     }
     if (i % 16 != 0)
-        av_log(avctx, AV_LOG_INFO, "\n");
+        av_dlog(avctx, "\n");
-#endif
     *poutbuf = NULL;
     *poutbuf_size = 0;

libavcodec/dvbsubdec.c+16−32

 #include "bytestream.h"
 #include "libavutil/colorspace.h"
-//#define DEBUG
-//#define DEBUG_PACKET_CONTENTS
-//#define DEBUG_SAVE_IMAGES
 #define DVBSUB_PAGE_SEGMENT     0x10
 #define DVBSUB_REGION_SEGMENT   0x11
 #define DVBSUB_CLUT_SEGMENT     0x12
 #define cm (ff_cropTbl + MAX_NEG_CROP)
-#ifdef DEBUG_SAVE_IMAGES
+#ifdef DEBUG
 #undef fprintf
 #if 0
 static void png_save(const char *filename, uint8_t *bitmap, int w, int h,
     av_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,
             top_bottom ? "bottom" : "top");
-#ifdef DEBUG_PACKET_CONTENTS
     for (i = 0; i < buf_size; i++) {
         if (i % 16 == 0)
-            av_log(avctx, AV_LOG_INFO, "0x%08p: ", buf+i);
+            av_dlog(avctx, "0x%8p: ", buf+i);
-        av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
+        av_dlog(avctx, "%02x ", buf[i]);
         if (i % 16 == 15)
-            av_log(avctx, AV_LOG_INFO, "\n");
+            av_dlog(avctx, "\n");
     }
     if (i % 16)
-        av_log(avctx, AV_LOG_INFO, "\n");
+        av_dlog(avctx, "\n");
-#endif
     if (region == 0)
         return;
     DVBSubContext *ctx = avctx->priv_data;
     const uint8_t *buf_end = buf + buf_size;
-    int clut_id;
+    int i, clut_id;
     DVBSubCLUT *clut;
     int entry_id, depth , full_range;
     int y, cr, cb, alpha;
     int r, g, b, r_add, g_add, b_add;
-#ifdef DEBUG_PACKET_CONTENTS
+    av_dlog(avctx, "DVB clut packet:\n");
-    int i;
-    av_log(avctx, AV_LOG_INFO, "DVB clut packet:\n");
     for (i=0; i < buf_size; i++) {
-        av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
+        av_dlog(avctx, "%02x ", buf[i]);
         if (i % 16 == 15)
-            av_log(avctx, AV_LOG_INFO, "\n");
+            av_dlog(avctx, "\n");
     }
     if (i % 16)
-        av_log(avctx, AV_LOG_INFO, "\n");
+        av_dlog(avctx, "\n");
-#endif
     clut_id = *buf++;
     buf += 1;
 }
-#ifdef DEBUG_SAVE_IMAGES
+#ifdef DEBUG
 static void save_display_set(DVBSubContext *ctx)
 {
     DVBSubRegion *region;
     sub->num_rects = i;
-#ifdef DEBUG_SAVE_IMAGES
+#ifdef DEBUG
     save_display_set(ctx);
 #endif
     int segment_type;
     int page_id;
     int segment_length;
-#ifdef DEBUG_PACKET_CONTENTS
     int i;
-    av_log(avctx, AV_LOG_INFO, "DVB sub packet:\n");
+    av_dlog(avctx, "DVB sub packet:\n");
     for (i=0; i < buf_size; i++) {
-        av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
+        av_dlog(avctx, "%02x ", buf[i]);
         if (i % 16 == 15)
-            av_log(avctx, AV_LOG_INFO, "\n");
+            av_dlog(avctx, "\n");
     }
     if (i % 16)
-        av_log(avctx, AV_LOG_INFO, "\n");
+        av_dlog(avctx, "\n");
-#endif
     if (buf_size <= 6 || *buf != 0x0f) {
         av_dlog(avctx, "incomplete or broken packet");

libavcodec/eac3enc.c+131−0

@@ -0,0 +1,131 @@
	1	/*
	2	* E-AC-3 encoder
	3	* Copyright (c) 2011 Justin Ruggles <justin.ruggles@gmail.com>
	4	*
	5	* This file is part of Libav.
	6	*
	7	* Libav is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* Libav is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with Libav; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	/**
	23	* @file
	24	* E-AC-3 encoder
	25	*/
	26
	27	#define CONFIG_AC3ENC_FLOAT 1
	28	#include "ac3enc.h"
	29	#include "eac3enc.h"
	30
	31	void ff_eac3_set_cpl_states(AC3EncodeContext *s)
	32	{
	33	int ch, blk;
	34	int first_cpl_coords[AC3_MAX_CHANNELS];
	35
	36	/* set first cpl coords */
	37	for (ch = 1; ch <= s->fbw_channels; ch++)
	38	first_cpl_coords[ch] = 1;
	39	for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
	40	AC3Block *block = &s->blocks[blk];
	41	for (ch = 1; ch <= s->fbw_channels; ch++) {
	42	if (block->channel_in_cpl[ch]) {
	43	if (first_cpl_coords[ch]) {
	44	block->new_cpl_coords = 2;
	45	first_cpl_coords[ch] = 0;
	46	}
	47	} else {
	48	first_cpl_coords[ch] = 1;
	49	}
	50	}
	51	}
	52
	53	/* set first cpl leak */
	54	for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
	55	AC3Block *block = &s->blocks[blk];
	56	if (block->cpl_in_use) {
	57	block->new_cpl_leak = 2;
	58	break;
	59	}
	60	}
	61	}
	62
	63
	64	void ff_eac3_output_frame_header(AC3EncodeContext *s)
	65	{
	66	int blk, ch;
	67	AC3EncOptions *opt = &s->options;
	68
	69	put_bits(&s->pb, 16, 0x0b77); /* sync word */
	70
	71	/* BSI header */
	72	put_bits(&s->pb, 2, 0); /* stream type = independent */
	73	put_bits(&s->pb, 3, 0); /* substream id = 0 */
	74	put_bits(&s->pb, 11, (s->frame_size / 2) - 1); /* frame size */
	75	if (s->bit_alloc.sr_shift) {
	76	put_bits(&s->pb, 2, 0x3); /* fscod2 */
	77	put_bits(&s->pb, 2, s->bit_alloc.sr_code); /* sample rate code */
	78	} else {
	79	put_bits(&s->pb, 2, s->bit_alloc.sr_code); /* sample rate code */
	80	put_bits(&s->pb, 2, 0x3); /* number of blocks = 6 */
	81	}
	82	put_bits(&s->pb, 3, s->channel_mode); /* audio coding mode */
	83	put_bits(&s->pb, 1, s->lfe_on); /* LFE channel indicator */
	84	put_bits(&s->pb, 5, s->bitstream_id); /* bitstream id (EAC3=16) */
	85	put_bits(&s->pb, 5, -opt->dialogue_level); /* dialogue normalization level */
	86	put_bits(&s->pb, 1, 0); /* no compression gain */
	87	put_bits(&s->pb, 1, 0); /* no mixing metadata */
	88	/* TODO: mixing metadata */
	89	put_bits(&s->pb, 1, 0); /* no info metadata */
	90	/* TODO: info metadata */
	91	put_bits(&s->pb, 1, 0); /* no additional bit stream info */
	92
	93	/* frame header */
	94	put_bits(&s->pb, 1, 1); /* exponent strategy syntax = each block */
	95	put_bits(&s->pb, 1, 0); /* aht enabled = no */
	96	put_bits(&s->pb, 2, 0); /* snr offset strategy = 1 */
	97	put_bits(&s->pb, 1, 0); /* transient pre-noise processing enabled = no */
	98	put_bits(&s->pb, 1, 0); /* block switch syntax enabled = no */
	99	put_bits(&s->pb, 1, 0); /* dither flag syntax enabled = no */
	100	put_bits(&s->pb, 1, 0); /* bit allocation model syntax enabled = no */
	101	put_bits(&s->pb, 1, 0); /* fast gain codes enabled = no */
	102	put_bits(&s->pb, 1, 0); /* dba syntax enabled = no */
	103	put_bits(&s->pb, 1, 0); /* skip field syntax enabled = no */
	104	put_bits(&s->pb, 1, 0); /* spx enabled = no */
	105	/* coupling strategy use flags */
	106	if (s->channel_mode > AC3_CHMODE_MONO) {
	107	put_bits(&s->pb, 1, s->blocks[0].cpl_in_use);
	108	for (blk = 1; blk < AC3_MAX_BLOCKS; blk++) {
	109	AC3Block *block = &s->blocks[blk];
	110	put_bits(&s->pb, 1, block->new_cpl_strategy);
	111	if (block->new_cpl_strategy)
	112	put_bits(&s->pb, 1, block->cpl_in_use);
	113	}
	114	}
	115	/* exponent strategy */
	116	for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
	117	for (ch = !s->blocks[blk].cpl_in_use; ch <= s->fbw_channels; ch++)
	118	put_bits(&s->pb, 2, s->exp_strategy[ch][blk]);
	119	if (s->lfe_on) {
	120	for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
	121	put_bits(&s->pb, 1, s->exp_strategy[s->lfe_channel][blk]);
	122	}
	123	/* E-AC-3 to AC-3 converter exponent strategy (unfortunately not optional...) */
	124	for (ch = 1; ch <= s->fbw_channels; ch++)
	125	put_bits(&s->pb, 5, 0);
	126	/* snr offsets */
	127	put_bits(&s->pb, 6, s->coarse_snr_offset);
	128	put_bits(&s->pb, 4, s->fine_snr_offset[1]);
	129	/* block start info */
	130	put_bits(&s->pb, 1, 0);
	131	}

libavcodec/eac3enc.h+44−0

@@ -0,0 +1,44 @@
	1	/*
	2	* E-AC-3 encoder
	3	* Copyright (c) 2011 Justin Ruggles <justin.ruggles@gmail.com>
	4	*
	5	* This file is part of Libav.
	6	*
	7	* Libav is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* Libav is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with Libav; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	/**
	23	* @file
	24	* E-AC-3 encoder
	25	*/
	26
	27	#ifndef AVCODEC_EAC3ENC_H
	28	#define AVCODEC_EAC3ENC_H
	29
	30	#include "ac3enc.h"
	31
	32	/**
	33	* Set coupling states.
	34	* This determines whether certain flags must be written to the bitstream or
	35	* whether they will be implicitly already known by the decoder.
	36	*/
	37	void ff_eac3_set_cpl_states(AC3EncodeContext *s);
	38
	39	/**
	40	* Write the E-AC-3 frame header to the output bitstream.
	41	*/
	42	void ff_eac3_output_frame_header(AC3EncodeContext *s);
	43
	44	#endif /* AVCODEC_EAC3ENC_H */

libavcodec/iirfilter.c+0−2

@@ -151,8 +151,6 @@ static int biquad_init_coeffs(void avc, struct FFIIRFilterCoeffs c, · 150 unmodified lines
151	// during filtering, the delay state will include the gain multiplication	151	// during filtering, the delay state will include the gain multiplication
152	c->cx[0] = lrintf(x0 / c->gain);	152	c->cx[0] = lrintf(x0 / c->gain);
153	c->cx[1] = lrintf(x1 / c->gain);	153	c->cx[1] = lrintf(x1 / c->gain);
154	c->cy[0] /= c->gain;
155	c->cy[1] /= c->gain;
156		154
157	return 0;	155	return 0;
158	}	156	}

libavcodec/mlpdsp.c+1−1

@@ -19,8 +19,8 @@ · 18 unmodified lines
19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20	*/	20	*/
21		21
22	#include "libavcodec/mlp.h"
23	#include "dsputil.h"	22	#include "dsputil.h"
		23	#include "mlp.h"
24		24
25	static void ff_mlp_filter_channel(int32_t state, const int32_t coeff,	25	static void ff_mlp_filter_channel(int32_t state, const int32_t coeff,
26	int firorder, int iirorder,	26	int firorder, int iirorder,

libavcodec/pgssubdec.c+4−9

 #include "libavutil/colorspace.h"
 #include "libavutil/imgutils.h"
-//#define DEBUG_PACKET_CONTENTS
 #define RGBA(r,g,b,a) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
 enum SegmentType {
     const uint8_t *buf_end;
     uint8_t       segment_type;
     int           segment_length;
-#ifdef DEBUG_PACKET_CONTENTS
     int i;
-    av_log(avctx, AV_LOG_INFO, "PGS sub packet:\n");
+    av_dlog(avctx, "PGS sub packet:\n");
     for (i = 0; i < buf_size; i++) {
-        av_log(avctx, AV_LOG_INFO, "%02x ", buf[i]);
+        av_dlog(avctx, "%02x ", buf[i]);
         if (i % 16 == 15)
-            av_log(avctx, AV_LOG_INFO, "\n");
+            av_dlog(avctx, "\n");
     }
     if (i & 15)
-        av_log(avctx, AV_LOG_INFO, "\n");
+        av_dlog(avctx, "\n");
-#endif
     *data_size = 0;

libavcodec/ppc/h264_template_altivec.c+1−2

@@ -18,8 +18,7 @@ · 17 unmodified lines
18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19	*/	19	*/
20		20
21	//#define DEBUG_ALIGNMENT	21	#ifdef DEBUG
22	#ifdef DEBUG_ALIGNMENT
23	#define ASSERT_ALIGNED(ptr) assert(((unsigned long)ptr&0x0000000F));	22	#define ASSERT_ALIGNED(ptr) assert(((unsigned long)ptr&0x0000000F));
24	#else	23	#else
25	#define ASSERT_ALIGNED(ptr) ;	24	#define ASSERT_ALIGNED(ptr) ;

libavcodec/shorten.c+0−2

  *
  */
-#define DEBUG
 #include <limits.h>
 #include "avcodec.h"
 #include "get_bits.h"
         s->bitstream_size= buf_size;
         if(buf_size < s->max_framesize){
-            //av_dlog(avctx, "wanna more data ... %d\n", buf_size);
             *data_size = 0;
             return input_buf_size;
         }

libavcodec/v210enc.c+1−1

@@ -22,7 +22,7 @@ · 21 unmodified lines
22	*/	22	*/
23		23
24	#include "avcodec.h"	24	#include "avcodec.h"
25	#include "libavcodec/bytestream.h"	25	#include "bytestream.h"
26		26
27	static av_cold int encode_init(AVCodecContext *avctx)	27	static av_cold int encode_init(AVCodecContext *avctx)
28	{	28	{

libavcodec/vc1dec.c+16−3

     VC1Context *v = avctx->priv_data;
     MpegEncContext *s = &v->s;
     GetBitContext gb;
-    int i;
+    int i, cur_width, cur_height;
     if (!avctx->extradata_size || !avctx->extradata) return -1;
     if (!(avctx->flags & CODEC_FLAG_GRAY))
     if (vc1_init_common(v) < 0) return -1;
     ff_vc1dsp_init(&v->vc1dsp);
-    avctx->coded_width = avctx->width;
+    cur_width = avctx->coded_width = avctx->width;
-    avctx->coded_height = avctx->height;
+    cur_height = avctx->coded_height = avctx->height;
     if (avctx->codec_id == CODEC_ID_WMV3)
     {
         int count = 0;
         }
         v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2'));
     }
+    // Sequence header information may not have been parsed
+    // yet when ff_msmpeg4_decode_init was called the fist time
+    // above.  If sequence information changes, we need to call
+    // it again.
+    if (cur_width != avctx->width ||
+        cur_height != avctx->height) {
+        MPV_common_end(s);
+        if(ff_msmpeg4_decode_init(avctx) < 0)
+            return -1;
+        avctx->coded_width = avctx->width;
+        avctx->coded_height = avctx->height;
+    }
     avctx->profile = v->profile;
     if (v->profile == PROFILE_ADVANCED)
         avctx->level = v->level;

libavcodec/vorbisdec.c+4−0

  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <inttypes.h>
 #include <math.h>
 #define ALT_BITSTREAM_READER_LE
             for (i = 0; i < order; i++)
                 lsp[i] = 2.0f * cos(lsp[i]);
+            av_dlog(NULL, "floor0 synth: map_size = %"PRIu32"; m = %d; wstep = %f\n",
+                    vf->map_size[blockflag], order, wstep);
             i = 0;
             while (i < vf->map_size[blockflag]) {
                 int j, iter_cond = vf->map[blockflag][i];

libavcodec/x86/h264_intrapred_init.c+110−110

@@ -124,132 +124,132 @@ void ff_h264_pred_init_x86(H264PredContext *h, int codec_id, const int bit_depth · 123 unmodified lines
124	{	124	{
125	int mm_flags = av_get_cpu_flags();	125	int mm_flags = av_get_cpu_flags();
126		126
127	if (bit_depth == 8) {
128	#if HAVE_YASM	127	#if HAVE_YASM
129	if (mm_flags & AV_CPU_FLAG_MMX) {	128	if (bit_depth == 8) {
130	h->pred16x16[VERT_PRED8x8] = ff_pred16x16_vertical_mmx;	129	if (mm_flags & AV_CPU_FLAG_MMX) {
131	h->pred16x16[HOR_PRED8x8 ] = ff_pred16x16_horizontal_mmx;	130	h->pred16x16[VERT_PRED8x8 ] = ff_pred16x16_vertical_mmx;
132	h->pred8x8 [VERT_PRED8x8] = ff_pred8x8_vertical_mmx;	131	h->pred16x16[HOR_PRED8x8 ] = ff_pred16x16_horizontal_mmx;
133	h->pred8x8 [HOR_PRED8x8 ] = ff_pred8x8_horizontal_mmx;	132	h->pred8x8 [VERT_PRED8x8 ] = ff_pred8x8_vertical_mmx;
134	if (codec_id == CODEC_ID_VP8) {	133	h->pred8x8 [HOR_PRED8x8 ] = ff_pred8x8_horizontal_mmx;
135	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_tm_vp8_mmx;	134	if (codec_id == CODEC_ID_VP8) {
136	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_tm_vp8_mmx;	135	h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_tm_vp8_mmx;
137	h->pred4x4 [TM_VP8_PRED ] = ff_pred4x4_tm_vp8_mmx;	136	h->pred8x8 [PLANE_PRED8x8 ] = ff_pred8x8_tm_vp8_mmx;
138	} else {	137	h->pred4x4 [TM_VP8_PRED ] = ff_pred4x4_tm_vp8_mmx;
139	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_plane_mmx;
140	if (codec_id == CODEC_ID_SVQ3) {
141	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_svq3_mmx;
142	} else if (codec_id == CODEC_ID_RV40) {
143	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_rv40_mmx;
144	} else {	138	} else {
145	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_h264_mmx;	139	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_plane_mmx;
		140	if (codec_id == CODEC_ID_SVQ3) {
		141	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_svq3_mmx;
		142	} else if (codec_id == CODEC_ID_RV40) {
		143	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_rv40_mmx;
		144	} else {
		145	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_h264_mmx;
		146	}
146	}	147	}
147	}	148	}
148	}
149		149
150	if (mm_flags & AV_CPU_FLAG_MMX2) {	150	if (mm_flags & AV_CPU_FLAG_MMX2) {
151	h->pred16x16[HOR_PRED8x8 ] = ff_pred16x16_horizontal_mmxext;	151	h->pred16x16[HOR_PRED8x8 ] = ff_pred16x16_horizontal_mmxext;
152	h->pred16x16[DC_PRED8x8 ] = ff_pred16x16_dc_mmxext;	152	h->pred16x16[DC_PRED8x8 ] = ff_pred16x16_dc_mmxext;
153	h->pred8x8 [HOR_PRED8x8 ] = ff_pred8x8_horizontal_mmxext;	153	h->pred8x8 [HOR_PRED8x8 ] = ff_pred8x8_horizontal_mmxext;
154	h->pred8x8l [TOP_DC_PRED ] = ff_pred8x8l_top_dc_mmxext;	154	h->pred8x8l [TOP_DC_PRED ] = ff_pred8x8l_top_dc_mmxext;
155	h->pred8x8l [DC_PRED ] = ff_pred8x8l_dc_mmxext;	155	h->pred8x8l [DC_PRED ] = ff_pred8x8l_dc_mmxext;
156	h->pred8x8l [HOR_PRED ] = ff_pred8x8l_horizontal_mmxext;	156	h->pred8x8l [HOR_PRED ] = ff_pred8x8l_horizontal_mmxext;
157	h->pred8x8l [VERT_PRED ] = ff_pred8x8l_vertical_mmxext;	157	h->pred8x8l [VERT_PRED ] = ff_pred8x8l_vertical_mmxext;
158	h->pred8x8l [DIAG_DOWN_RIGHT_PRED] = ff_pred8x8l_down_right_mmxext;	158	h->pred8x8l [DIAG_DOWN_RIGHT_PRED ] = ff_pred8x8l_down_right_mmxext;
159	h->pred8x8l [VERT_RIGHT_PRED ] = ff_pred8x8l_vertical_right_mmxext;	159	h->pred8x8l [VERT_RIGHT_PRED ] = ff_pred8x8l_vertical_right_mmxext;
160	h->pred8x8l [HOR_UP_PRED ] = ff_pred8x8l_horizontal_up_mmxext;	160	h->pred8x8l [HOR_UP_PRED ] = ff_pred8x8l_horizontal_up_mmxext;
161	h->pred8x8l [DIAG_DOWN_LEFT_PRED ] = ff_pred8x8l_down_left_mmxext;	161	h->pred8x8l [DIAG_DOWN_LEFT_PRED ] = ff_pred8x8l_down_left_mmxext;
162	h->pred8x8l [HOR_DOWN_PRED ] = ff_pred8x8l_horizontal_down_mmxext;	162	h->pred8x8l [HOR_DOWN_PRED ] = ff_pred8x8l_horizontal_down_mmxext;
163	h->pred4x4 [DIAG_DOWN_RIGHT_PRED] = ff_pred4x4_down_right_mmxext;	163	h->pred4x4 [DIAG_DOWN_RIGHT_PRED ] = ff_pred4x4_down_right_mmxext;
164	h->pred4x4 [VERT_RIGHT_PRED ] = ff_pred4x4_vertical_right_mmxext;	164	h->pred4x4 [VERT_RIGHT_PRED ] = ff_pred4x4_vertical_right_mmxext;
165	h->pred4x4 [HOR_DOWN_PRED ] = ff_pred4x4_horizontal_down_mmxext;	165	h->pred4x4 [HOR_DOWN_PRED ] = ff_pred4x4_horizontal_down_mmxext;
166	h->pred4x4 [DC_PRED ] = ff_pred4x4_dc_mmxext;	166	h->pred4x4 [DC_PRED ] = ff_pred4x4_dc_mmxext;
167	if (codec_id == CODEC_ID_VP8 \|\| codec_id == CODEC_ID_H264)	167	if (codec_id == CODEC_ID_VP8 \|\| codec_id == CODEC_ID_H264) {
168	h->pred4x4 [DIAG_DOWN_LEFT_PRED ] = ff_pred4x4_down_left_mmxext;	168	h->pred4x4 [DIAG_DOWN_LEFT_PRED] = ff_pred4x4_down_left_mmxext;
169	if (codec_id == CODEC_ID_SVQ3 \|\| codec_id == CODEC_ID_H264)	169	}
170	h->pred4x4 [VERT_LEFT_PRED ] = ff_pred4x4_vertical_left_mmxext;	170	if (codec_id == CODEC_ID_SVQ3 \|\| codec_id == CODEC_ID_H264) {
171	if (codec_id != CODEC_ID_RV40) {	171	h->pred4x4 [VERT_LEFT_PRED ] = ff_pred4x4_vertical_left_mmxext;
172	h->pred4x4 [HOR_UP_PRED ] = ff_pred4x4_horizontal_up_mmxext;	172	}
173	}	173	if (codec_id != CODEC_ID_RV40) {
174	if (codec_id == CODEC_ID_SVQ3 \|\| codec_id == CODEC_ID_H264) {	174	h->pred4x4 [HOR_UP_PRED ] = ff_pred4x4_horizontal_up_mmxext;
175	h->pred8x8 [TOP_DC_PRED8x8 ] = ff_pred8x8_top_dc_mmxext;	175	}
176	h->pred8x8 [DC_PRED8x8 ] = ff_pred8x8_dc_mmxext;	176	if (codec_id == CODEC_ID_SVQ3 \|\| codec_id == CODEC_ID_H264) {
177	}	177	h->pred8x8 [TOP_DC_PRED8x8 ] = ff_pred8x8_top_dc_mmxext;
178	if (codec_id == CODEC_ID_VP8) {	178	h->pred8x8 [DC_PRED8x8 ] = ff_pred8x8_dc_mmxext;
179	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_tm_vp8_mmxext;	179	}
180	h->pred8x8 [DC_PRED8x8 ] = ff_pred8x8_dc_rv40_mmxext;	180	if (codec_id == CODEC_ID_VP8) {
181	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_tm_vp8_mmxext;	181	h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_tm_vp8_mmxext;
182	h->pred4x4 [TM_VP8_PRED ] = ff_pred4x4_tm_vp8_mmxext;	182	h->pred8x8 [DC_PRED8x8 ] = ff_pred8x8_dc_rv40_mmxext;
183	h->pred4x4 [VERT_PRED ] = ff_pred4x4_vertical_vp8_mmxext;	183	h->pred8x8 [PLANE_PRED8x8 ] = ff_pred8x8_tm_vp8_mmxext;
184	} else {	184	h->pred4x4 [TM_VP8_PRED ] = ff_pred4x4_tm_vp8_mmxext;
185	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_plane_mmx2;	185	h->pred4x4 [VERT_PRED ] = ff_pred4x4_vertical_vp8_mmxext;
186	if (codec_id == CODEC_ID_SVQ3) {
187	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_svq3_mmx2;
188	} else if (codec_id == CODEC_ID_RV40) {
189	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_rv40_mmx2;
190	} else {	186	} else {
191	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_h264_mmx2;	187	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_plane_mmx2;
		188	if (codec_id == CODEC_ID_SVQ3) {
		189	h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_plane_svq3_mmx2;
		190	} else if (codec_id == CODEC_ID_RV40) {
		191	h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_plane_rv40_mmx2;
		192	} else {
		193	h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_plane_h264_mmx2;
		194	}
192	}	195	}
193	}	196	}
194	}
195		197
196	if (mm_flags & AV_CPU_FLAG_SSE) {	198	if (mm_flags & AV_CPU_FLAG_SSE) {
197	h->pred16x16[VERT_PRED8x8] = ff_pred16x16_vertical_sse;	199	h->pred16x16[VERT_PRED8x8] = ff_pred16x16_vertical_sse;
198	}	200	}
199		201
200	if (mm_flags & AV_CPU_FLAG_SSE2) {	202	if (mm_flags & AV_CPU_FLAG_SSE2) {
201	h->pred16x16[DC_PRED8x8 ] = ff_pred16x16_dc_sse2;	203	h->pred16x16[DC_PRED8x8 ] = ff_pred16x16_dc_sse2;
202	h->pred8x8l [DIAG_DOWN_LEFT_PRED ] = ff_pred8x8l_down_left_sse2;	204	h->pred8x8l [DIAG_DOWN_LEFT_PRED ] = ff_pred8x8l_down_left_sse2;
203	h->pred8x8l [DIAG_DOWN_RIGHT_PRED] = ff_pred8x8l_down_right_sse2;	205	h->pred8x8l [DIAG_DOWN_RIGHT_PRED ] = ff_pred8x8l_down_right_sse2;
204	h->pred8x8l [VERT_RIGHT_PRED ] = ff_pred8x8l_vertical_right_sse2;	206	h->pred8x8l [VERT_RIGHT_PRED ] = ff_pred8x8l_vertical_right_sse2;
205	h->pred8x8l [VERT_LEFT_PRED ] = ff_pred8x8l_vertical_left_sse2;	207	h->pred8x8l [VERT_LEFT_PRED ] = ff_pred8x8l_vertical_left_sse2;
206	h->pred8x8l [HOR_DOWN_PRED ] = ff_pred8x8l_horizontal_down_sse2;	208	h->pred8x8l [HOR_DOWN_PRED ] = ff_pred8x8l_horizontal_down_sse2;
207	if (codec_id == CODEC_ID_VP8) {	209	if (codec_id == CODEC_ID_VP8) {
208	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_tm_vp8_sse2;	210	h->pred16x16[PLANE_PRED8x8 ] = ff_pred16x16_tm_vp8_sse2;
209	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_tm_vp8_sse2;	211	h->pred8x8 [PLANE_PRED8x8 ] = ff_pred8x8_tm_vp8_sse2;
210	} else {
211	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_plane_sse2;
212	if (codec_id == CODEC_ID_SVQ3) {
213	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_svq3_sse2;
214	} else if (codec_id == CODEC_ID_RV40) {
215	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_rv40_sse2;
216	} else {	212	} else {
217	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_h264_sse2;	213	h->pred8x8 [PLANE_PRED8x8 ] = ff_pred8x8_plane_sse2;
		214	if (codec_id == CODEC_ID_SVQ3) {
		215	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_svq3_sse2;
		216	} else if (codec_id == CODEC_ID_RV40) {
		217	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_rv40_sse2;
		218	} else {
		219	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_h264_sse2;
		220	}
218	}	221	}
219	}	222	}
220	}
221		223
222	if (mm_flags & AV_CPU_FLAG_SSSE3) {	224	if (mm_flags & AV_CPU_FLAG_SSSE3) {
223	h->pred16x16[HOR_PRED8x8 ] = ff_pred16x16_horizontal_ssse3;	225	h->pred16x16[HOR_PRED8x8 ] = ff_pred16x16_horizontal_ssse3;
224	h->pred16x16[DC_PRED8x8 ] = ff_pred16x16_dc_ssse3;	226	h->pred16x16[DC_PRED8x8 ] = ff_pred16x16_dc_ssse3;
225	h->pred8x8 [HOR_PRED8x8 ] = ff_pred8x8_horizontal_ssse3;	227	h->pred8x8 [HOR_PRED8x8 ] = ff_pred8x8_horizontal_ssse3;
226	h->pred8x8l [TOP_DC_PRED ] = ff_pred8x8l_top_dc_ssse3;	228	h->pred8x8l [TOP_DC_PRED ] = ff_pred8x8l_top_dc_ssse3;
227	h->pred8x8l [DC_PRED ] = ff_pred8x8l_dc_ssse3;	229	h->pred8x8l [DC_PRED ] = ff_pred8x8l_dc_ssse3;
228	h->pred8x8l [HOR_PRED ] = ff_pred8x8l_horizontal_ssse3;	230	h->pred8x8l [HOR_PRED ] = ff_pred8x8l_horizontal_ssse3;
229	h->pred8x8l [VERT_PRED ] = ff_pred8x8l_vertical_ssse3;	231	h->pred8x8l [VERT_PRED ] = ff_pred8x8l_vertical_ssse3;
230	h->pred8x8l [DIAG_DOWN_LEFT_PRED ] = ff_pred8x8l_down_left_ssse3;	232	h->pred8x8l [DIAG_DOWN_LEFT_PRED ] = ff_pred8x8l_down_left_ssse3;
231	h->pred8x8l [DIAG_DOWN_RIGHT_PRED] = ff_pred8x8l_down_right_ssse3;	233	h->pred8x8l [DIAG_DOWN_RIGHT_PRED ] = ff_pred8x8l_down_right_ssse3;
232	h->pred8x8l [VERT_RIGHT_PRED ] = ff_pred8x8l_vertical_right_ssse3;	234	h->pred8x8l [VERT_RIGHT_PRED ] = ff_pred8x8l_vertical_right_ssse3;
233	h->pred8x8l [VERT_LEFT_PRED ] = ff_pred8x8l_vertical_left_ssse3;	235	h->pred8x8l [VERT_LEFT_PRED ] = ff_pred8x8l_vertical_left_ssse3;
234	h->pred8x8l [HOR_UP_PRED ] = ff_pred8x8l_horizontal_up_ssse3;	236	h->pred8x8l [HOR_UP_PRED ] = ff_pred8x8l_horizontal_up_ssse3;
235	h->pred8x8l [HOR_DOWN_PRED ] = ff_pred8x8l_horizontal_down_ssse3;	237	h->pred8x8l [HOR_DOWN_PRED ] = ff_pred8x8l_horizontal_down_ssse3;
236	if (codec_id == CODEC_ID_VP8) {	238	if (codec_id == CODEC_ID_VP8) {
237	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_tm_vp8_ssse3;	239	h->pred8x8 [PLANE_PRED8x8 ] = ff_pred8x8_tm_vp8_ssse3;
238	h->pred4x4 [TM_VP8_PRED ] = ff_pred4x4_tm_vp8_ssse3;	240	h->pred4x4 [TM_VP8_PRED ] = ff_pred4x4_tm_vp8_ssse3;
239	} else {
240	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_plane_ssse3;
241	if (codec_id == CODEC_ID_SVQ3) {
242	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_svq3_ssse3;
243	} else if (codec_id == CODEC_ID_RV40) {
244	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_rv40_ssse3;
245	} else {	241	} else {
246	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_h264_ssse3;	242	h->pred8x8 [PLANE_PRED8x8] = ff_pred8x8_plane_ssse3;
		243	if (codec_id == CODEC_ID_SVQ3) {
		244	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_svq3_ssse3;
		245	} else if (codec_id == CODEC_ID_RV40) {
		246	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_rv40_ssse3;
		247	} else {
		248	h->pred16x16[PLANE_PRED8x8] = ff_pred16x16_plane_h264_ssse3;
		249	}
247	}	250	}
248	}	251	}
249	}
250	#endif
251	} else if (bit_depth == 10) {	252	} else if (bit_depth == 10) {
252	#if HAVE_YASM
253	if (mm_flags & AV_CPU_FLAG_MMX2) {	253	if (mm_flags & AV_CPU_FLAG_MMX2) {
254	h->pred4x4[DC_PRED ] = ff_pred4x4_dc_10_mmxext;	254	h->pred4x4[DC_PRED ] = ff_pred4x4_dc_10_mmxext;
255	h->pred4x4[HOR_UP_PRED ] = ff_pred4x4_horizontal_up_10_mmxext;	255	h->pred4x4[HOR_UP_PRED ] = ff_pred4x4_horizontal_up_10_mmxext;
@@ -270,13 +270,13 @@ void ff_h264_pred_init_x86(H264PredContext *h, int codec_id, const int bit_depth · 14 unmodified lines
270	h->pred4x4[HOR_DOWN_PRED ] = ff_pred4x4_horizontal_down_10_ssse3;	270	h->pred4x4[HOR_DOWN_PRED ] = ff_pred4x4_horizontal_down_10_ssse3;
271	}	271	}
272	#if HAVE_AVX	272	#if HAVE_AVX
273	if (mm_flags&AV_CPU_FLAG_AVX) {	273	if (mm_flags & AV_CPU_FLAG_AVX) {
274	h->pred4x4[DIAG_DOWN_LEFT_PRED ] = ff_pred4x4_down_left_10_avx;	274	h->pred4x4[DIAG_DOWN_LEFT_PRED ] = ff_pred4x4_down_left_10_avx;
275	h->pred4x4[DIAG_DOWN_RIGHT_PRED] = ff_pred4x4_down_right_10_avx;	275	h->pred4x4[DIAG_DOWN_RIGHT_PRED] = ff_pred4x4_down_right_10_avx;
276	h->pred4x4[VERT_RIGHT_PRED ] = ff_pred4x4_vertical_right_10_avx;	276	h->pred4x4[VERT_RIGHT_PRED ] = ff_pred4x4_vertical_right_10_avx;
277	h->pred4x4[HOR_DOWN_PRED ] = ff_pred4x4_horizontal_down_10_avx;	277	h->pred4x4[HOR_DOWN_PRED ] = ff_pred4x4_horizontal_down_10_avx;
278	}	278	}
279	#endif /* HAVE_AVX */	279	#endif /* HAVE_AVX */
280	#endif /* HAVE_YASM */
281	}	280	}
		281	#endif /* HAVE_YASM */
282	}	282	}

libavformat/avidec.c+2−2

@@ -1254,7 +1254,7 @@ static int avi_load_index(AVFormatContext *s) · 1253 unmodified lines
1254	if (avio_seek(pb, avi->movi_end, SEEK_SET) < 0)	1254	if (avio_seek(pb, avi->movi_end, SEEK_SET) < 0)
1255	goto the_end; // maybe truncated file	1255	goto the_end; // maybe truncated file
1256	#ifdef DEBUG_SEEK	1256	#ifdef DEBUG_SEEK
1257	printf("movi_end=0x%"PRIx64"\n", avi->movi_end);	1257	av_log(s, AV_LOG_DEBUG, "movi_end=0x%"PRIx64"\n", avi->movi_end);
1258	#endif	1258	#endif
1259	for(;;) {	1259	for(;;) {
1260	if (url_feof(pb))	1260	if (url_feof(pb))
@@ -1262,7 +1262,7 @@ static int avi_load_index(AVFormatContext *s) · 1 unmodified line
1262	tag = avio_rl32(pb);	1262	tag = avio_rl32(pb);
1263	size = avio_rl32(pb);	1263	size = avio_rl32(pb);
1264	#ifdef DEBUG_SEEK	1264	#ifdef DEBUG_SEEK
1265	printf("tag=%c%c%c%c size=0x%x\n",	1265	av_log(s, AV_LOG_DEBUG, "tag=%c%c%c%c size=0x%x\n",
1266	tag & 0xff,	1266	tag & 0xff,
1267	(tag >> 8) & 0xff,	1267	(tag >> 8) & 0xff,
1268	(tag >> 16) & 0xff,	1268	(tag >> 16) & 0xff,

libavformat/mmsh.c+1−1

@@ -28,7 +28,7 @@ · 27 unmodified lines
28	#include <string.h>	28	#include <string.h>
29	#include "libavutil/intreadwrite.h"	29	#include "libavutil/intreadwrite.h"
30	#include "libavutil/avstring.h"	30	#include "libavutil/avstring.h"
31	#include "libavformat/internal.h"	31	#include "internal.h"
32	#include "mms.h"	32	#include "mms.h"
33	#include "asf.h"	33	#include "asf.h"
34	#include "http.h"	34	#include "http.h"

libavformat/mov.c+3−6

 #include <limits.h>
 //#define DEBUG
-//#define DEBUG_METADATA
 //#define MOV_EXPORT_ALL_METADATA
 #include "libavutil/intreadwrite.h"
             av_metadata_set2(&c->fc->metadata, key2, str, 0);
         }
     }
-#ifdef DEBUG_METADATA
+    av_dlog(c->fc, "lang \"%3s\" ", language);
-    av_log(c->fc, AV_LOG_DEBUG, "lang \"%3s\" ", language);
+    av_dlog(c->fc, "tag \"%s\" value \"%s\" atom \"%.4s\" %d %"PRId64"\n",
-    av_log(c->fc, AV_LOG_DEBUG, "tag \"%s\" value \"%s\" atom \"%.4s\" %d %lld\n",
+            key, str, (char*)&atom.type, str_size, atom.size);
-           key, str, (char*)&atom.type, str_size, atom.size);
-#endif
     return 0;
 }

libavformat/mpeg.c+3−5

     int64_t pos, pts, dts;
     pos = *ppos;
-#ifdef DEBUG_SEEK
-    printf("read_dts: pos=0x%"PRIx64" next=%d -> ", pos, find_next);
-#endif
     if (avio_seek(s->pb, pos, SEEK_SET) < 0)
         return AV_NOPTS_VALUE;
         len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
         if (len < 0) {
 #ifdef DEBUG_SEEK
-            printf("none (ret=%d)\n", len);
+            av_log(s, AV_LOG_DEBUG, "none (ret=%d)\n", len);
 #endif
             return AV_NOPTS_VALUE;
         }
         avio_skip(s->pb, len);
     }
 #ifdef DEBUG_SEEK
-    printf("pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n", pos, dts, dts / 90000.0);
+    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
+           pos, dts, dts / 90000.0);
 #endif
     *ppos = pos;
     return dts;

libavformat/rtspdec.c+0−7

 #include "rdt.h"
 #include "url.h"
-//#define DEBUG
-//#define DEBUG_RTP_TCP
 static int rtsp_read_play(AVFormatContext *s)
 {
     RTSPState *rt = s->priv_data;
     int id, len, i, ret;
     RTSPStream *rtsp_st;
-#ifdef DEBUG_RTP_TCP
     av_dlog(s, "tcp_read_packet:\n");
-#endif
 redo:
     for (;;) {
         RTSPMessageHeader reply;
         return -1;
     id  = buf[0];
     len = AV_RB16(buf + 1);
-#ifdef DEBUG_RTP_TCP
     av_dlog(s, "id=%d len=%d\n", id, len);
-#endif
     if (len > buf_size || len < 12)
         goto redo;
     /* get the data */

libavutil/audioconvert.c+2−2

@@ -23,8 +23,8 @@ · 22 unmodified lines
23	* audio conversion routines	23	* audio conversion routines
24	*/	24	*/
25		25
26	#include "libavutil/avutil.h"	26	#include "avstring.h"
27	#include "libavutil/avstring.h"	27	#include "avutil.h"
28	#include "audioconvert.h"	28	#include "audioconvert.h"
29		29
30	static const char * const channel_names[] = {	30	static const char * const channel_names[] = {

libavutil/avutil.h+5−2

 #define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
 #define LIBAVUTIL_VERSION_MAJOR 51
-#define LIBAVUTIL_VERSION_MINOR  6
+#define LIBAVUTIL_VERSION_MINOR  7
-#define LIBAVUTIL_VERSION_MICRO  1
+#define LIBAVUTIL_VERSION_MICRO  0
 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
                                                LIBAVUTIL_VERSION_MINOR, \
 #ifndef FF_API_OLD_EVAL_NAMES
 #define FF_API_OLD_EVAL_NAMES (LIBAVUTIL_VERSION_MAJOR < 52)
 #endif
+#ifndef FF_API_GET_BITS_PER_SAMPLE_FMT
+#define FF_API_GET_BITS_PER_SAMPLE_FMT (LIBAVUTIL_VERSION_MAJOR < 52)
+#endif
 /**
  * Return the LIBAVUTIL_VERSION_INT constant.

libavutil/eval.c+1−1

@@ -26,7 +26,7 @@ · 25 unmodified lines
26	* see http://joe.hotchkiss.com/programming/eval/eval.html	26	* see http://joe.hotchkiss.com/programming/eval/eval.html
27	*/	27	*/
28		28
29	#include "libavutil/avutil.h"	29	#include "avutil.h"
30	#include "eval.h"	30	#include "eval.h"
31		31
32	typedef struct Parser {	32	typedef struct Parser {

libavutil/imgutils.c+1−1

@@ -23,7 +23,7 @@ · 22 unmodified lines
23		23
24	#include "imgutils.h"	24	#include "imgutils.h"
25	#include "internal.h"	25	#include "internal.h"
26	#include "libavutil/pixdesc.h"	26	#include "pixdesc.h"
27		27
28	void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4],	28	void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4],
29	const AVPixFmtDescriptor *pixdesc)	29	const AVPixFmtDescriptor *pixdesc)

libavutil/imgutils.h+1−1

@@ -24,8 +24,8 @@ · 23 unmodified lines
24	* misc image utilities	24	* misc image utilities
25	*/	25	*/
26		26
27	#include "libavutil/pixdesc.h"
28	#include "avutil.h"	27	#include "avutil.h"
		28	#include "pixdesc.h"
29		29
30	/**	30	/**
31	* Compute the max pixel step for each plane of an image with a	31	* Compute the max pixel step for each plane of an image with a

libavutil/inverse.c+1−1

@@ -19,7 +19,7 @@ · 18 unmodified lines
19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20	*/	20	*/
21		21
22	#include "libavutil/intmath.h"	22	#include <stdint.h>
23		23
24	/* a*inverse[b]>>32 == a/b for all 0<=a<=16909558 && 2<=b<=256	24	/* a*inverse[b]>>32 == a/b for all 0<=a<=16909558 && 2<=b<=256
25	* for a>16909558, is an overestimate by less than 1 part in 1<<24 */	25	* for a>16909558, is an overestimate by less than 1 part in 1<<24 */

libavutil/parseutils.c+5−4

 #include <strings.h>
 #include <sys/time.h>
 #include <time.h>
+#include "avstring.h"
+#include "avutil.h"
+#include "eval.h"
+#include "random_seed.h"
 #include "parseutils.h"
-#include "libavutil/avutil.h"
-#include "libavutil/eval.h"
-#include "libavutil/avstring.h"
-#include "libavutil/random_seed.h"
 typedef struct {
     const char *abbr;

libavutil/parseutils.h+1−1

@@ -19,7 +19,7 @@ · 18 unmodified lines
19	#ifndef AVUTIL_PARSEUTILS_H	19	#ifndef AVUTIL_PARSEUTILS_H
20	#define AVUTIL_PARSEUTILS_H	20	#define AVUTIL_PARSEUTILS_H
21		21
22	#include "libavutil/rational.h"	22	#include "rational.h"
23		23
24	/**	24	/**
25	* @file	25	* @file

libavutil/samplefmt.c+8−0

     return buf;
 }
+int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
+{
+     return sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB ?
+        0 : sample_fmt_info[sample_fmt].bits >> 3;
+}
+#if FF_API_GET_BITS_PER_SAMPLE_FMT
 int av_get_bits_per_sample_fmt(enum AVSampleFormat sample_fmt)
 {
     return sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB ?
         0 : sample_fmt_info[sample_fmt].bits;
 }
+#endif
 int av_samples_fill_arrays(uint8_t *pointers[8], int linesizes[8],
                            uint8_t *buf, int nb_channels, int nb_samples,

libavutil/samplefmt.h+11−3

  */
 char *av_get_sample_fmt_string(char *buf, int buf_size, enum AVSampleFormat sample_fmt);
+#if FF_API_GET_BITS_PER_SAMPLE_FMT
 /**
- * Return sample format bits per sample.
+ * @deprecated Use av_get_bytes_per_sample() instead.
+ */
+attribute_deprecated
+int av_get_bits_per_sample_fmt(enum AVSampleFormat sample_fmt);
+#endif
+/**
+ * Return number of bytes per sample.
  *
  * @param sample_fmt the sample format
- * @return number of bits per sample or zero if unknown for the given
+ * @return number of bytes per sample or zero if unknown for the given
  * sample format
  */
-int av_get_bits_per_sample_fmt(enum AVSampleFormat sample_fmt);
+int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt);
 /**
  * Fill channel data pointers and linesizes for samples with sample

libswscale/ppc/swscale_altivec.c+6−2

 void ff_sws_init_swScale_altivec(SwsContext *c)
 {
+    enum PixelFormat dstFormat = c->dstFormat;
     if (!(av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC))
         return;
     c->hScale       = hScale_altivec_real;
-    c->yuv2yuvX     = yuv2yuvX_altivec_real;
+    if (!is16BPS(dstFormat) && !is9_OR_10BPS(dstFormat)) {
+        c->yuv2yuvX     = yuv2yuvX_altivec_real;
+    }
     /* The following list of supported dstFormat values should
      * match what's found in the body of ff_yuv2packedX_altivec() */
-    if (!(c->flags & SWS_BITEXACT) && !c->alpPixBuf &&
+    if (!(c->flags & (SWS_BITEXACT | SWS_FULL_CHR_H_INT)) && !c->alpPixBuf &&
         (c->dstFormat==PIX_FMT_ABGR  || c->dstFormat==PIX_FMT_BGRA  ||
          c->dstFormat==PIX_FMT_BGR24 || c->dstFormat==PIX_FMT_RGB24 ||
          c->dstFormat==PIX_FMT_RGBA  || c->dstFormat==PIX_FMT_ARGB)) {

libswscale/swscale.c+93−134

@@ -353,17 +353,20 @@ yuv2yuvX16_c_template(const int16_t lumFilter, const int16_t *lumSrc, · 352 unmodified lines
353	output_pixel(&aDest[i], val);	353	output_pixel(&aDest[i], val);
354	}	354	}
355	}	355	}
		356	#undef output_pixel
356	}	357	}
357		358
358	#define yuv2NBPS(bits, BE_LE, is_be) \	359	#define yuv2NBPS(bits, BE_LE, is_be) \
359	static void yuv2yuvX ## bits ## BE_LE ## _c(const int16_t *lumFilter, \	360	static void yuv2yuvX ## bits ## BE_LE ## _c(SwsContext c, const int16_t lumFilter, \
360	const int16_t **lumSrc, int lumFilterSize, \	361	const int16_t **lumSrc, int lumFilterSize, \
361	const int16_t chrFilter, const int16_t *chrUSrc, \	362	const int16_t chrFilter, const int16_t *chrUSrc, \
362	const int16_t **chrVSrc, \	363	const int16_t **chrVSrc, \
363	int chrFilterSize, const int16_t **alpSrc, \	364	int chrFilterSize, const int16_t **alpSrc, \
364	uint16_t dest, uint16_t uDest, uint16_t *vDest, \	365	uint8_t _dest, uint8_t _uDest, uint8_t *_vDest, \
365	uint16_t *aDest, int dstW, int chrDstW) \	366	uint8_t *_aDest, int dstW, int chrDstW) \
366	{ \	367	{ \
		368	uint16_t dest = (uint16_t ) _dest, uDest = (uint16_t ) _uDest, \
		369	vDest = (uint16_t ) _vDest, aDest = (uint16_t ) _aDest; \
367	yuv2yuvX16_c_template(lumFilter, lumSrc, lumFilterSize, \	370	yuv2yuvX16_c_template(lumFilter, lumSrc, lumFilterSize, \
368	chrFilter, chrUSrc, chrVSrc, chrFilterSize, \	371	chrFilter, chrUSrc, chrVSrc, chrFilterSize, \
369	alpSrc, \	372	alpSrc, \
@@ -377,7 +380,7 @@ yuv2NBPS(10, LE, 0); · 7 unmodified lines
377	yuv2NBPS(16, BE, 1);	380	yuv2NBPS(16, BE, 1);
378	yuv2NBPS(16, LE, 0);	381	yuv2NBPS(16, LE, 0);
379		382
380	static inline void yuv2yuvX16_c(const int16_t lumFilter, const int16_t *lumSrc, int lumFilterSize,	383	static inline void yuv2yuvX16_c(SwsContext c, const int16_t lumFilter, const int16_t **lumSrc, int lumFilterSize,
381	const int16_t chrFilter, const int16_t chrUSrc, const int16_t *chrVSrc, int chrFilterSize,	384	const int16_t chrFilter, const int16_t chrUSrc, const int16_t *chrVSrc, int chrFilterSize,
382	const int16_t *alpSrc, uint16_t dest, uint16_t uDest, uint16_t vDest, uint16_t *aDest, int dstW, int chrDstW,	385	const int16_t *alpSrc, uint16_t dest, uint16_t uDest, uint16_t vDest, uint16_t *aDest, int dstW, int chrDstW,
383	enum PixelFormat dstFormat)	386	enum PixelFormat dstFormat)
@@ -452,9 +455,13 @@ static void yuv2yuvX_c(SwsContext c, const int16_t lumFilter, const int16_t ** · 68 unmodified lines
452	static inline void yuv2nv12X_c(SwsContext c, const int16_t lumFilter, const int16_t **lumSrc, int lumFilterSize,	455	static inline void yuv2nv12X_c(SwsContext c, const int16_t lumFilter, const int16_t **lumSrc, int lumFilterSize,
453	const int16_t chrFilter, const int16_t *chrUSrc,	456	const int16_t chrFilter, const int16_t *chrUSrc,
454	const int16_t **chrVSrc, int chrFilterSize,	457	const int16_t **chrVSrc, int chrFilterSize,
455	uint8_t dest, uint8_t uDest, int dstW, int chrDstW, int dstFormat,	458	const int16_t *alpSrc, uint8_t dest, uint8_t *uDest,
		459	uint8_t vDest, uint8_t aDest,
		460	int dstW, int chrDstW,
456	const uint8_t lumDither, const uint8_t chrDither)	461	const uint8_t lumDither, const uint8_t chrDither)
457	{	462	{
		463	enum PixelFormat dstFormat = c->dstFormat;
		464
458	//FIXME Optimize (just quickly written not optimized..)	465	//FIXME Optimize (just quickly written not optimized..)
459	int i;	466	int i;
460	for (i=0; i<dstW; i++) {	467	for (i=0; i<dstW; i++) {
@@ -1148,6 +1155,14 @@ static void abgrToA_c(int16_t dst, const uint8_t src, int width, uint32_t *unu · 687 unmodified lines
1148	}	1155	}
1149	}	1156	}
1150		1157
		1158	static void rgbaToA_c(int16_t dst, const uint8_t src, int width, uint32_t *unused)
		1159	{
		1160	int i;
		1161	for (i=0; i<width; i++) {
		1162	dst[i]= src[4*i+3]<<6;
		1163	}
		1164	}
		1165
1151	#define BGR2UV(type, name, shr, shg, shb, shp, maskr, maskg, maskb, RU, GU, BU, RV, GV, BV, S) \	1166	#define BGR2UV(type, name, shr, shg, shb, shp, maskr, maskg, maskb, RU, GU, BU, RV, GV, BV, S) \
1152	static void name ## _c(int16_t dstU, int16_t dstV, const uint8_t src, const uint8_t dummy, int width, uint32_t *unused)\	1167	static void name ## _c(int16_t dstU, int16_t dstV, const uint8_t src, const uint8_t dummy, int width, uint32_t *unused)\
1153	{\	1168	{\
@@ -1616,8 +1631,6 @@ static inline void hyscale(SwsContext c, uint16_t dst, int dstWidth, · 462 unmodified lines
1616	void (toYV12)(uint8_t , const uint8_t , int, uint32_t ) = isAlpha ? c->alpToYV12 : c->lumToYV12;	1631	void (toYV12)(uint8_t , const uint8_t , int, uint32_t ) = isAlpha ? c->alpToYV12 : c->lumToYV12;
1617	void (convertRange)(int16_t , int) = isAlpha ? NULL : c->lumConvertRange;	1632	void (convertRange)(int16_t , int) = isAlpha ? NULL : c->lumConvertRange;
1618		1633
1619	src += isAlpha ? c->alpSrcOffset : c->lumSrcOffset;
1620
1621	if (toYV12) {	1634	if (toYV12) {
1622	toYV12(formatConvBuffer, src, srcW, pal);	1635	toYV12(formatConvBuffer, src, srcW, pal);
1623	src= formatConvBuffer;	1636	src= formatConvBuffer;
@@ -1661,10 +1674,6 @@ static inline void hcscale(SwsContext c, uint16_t dst1, uint16_t *dst2, int ds · 37 unmodified lines
1661	const int16_t *hChrFilterPos, int hChrFilterSize,	1674	const int16_t *hChrFilterPos, int hChrFilterSize,
1662	uint8_t formatConvBuffer, uint32_t pal)	1675	uint8_t formatConvBuffer, uint32_t pal)
1663	{	1676	{
1664
1665	src1 += c->chrSrcOffset;
1666	src2 += c->chrSrcOffset;
1667
1668	if (c->chrToYV12) {	1677	if (c->chrToYV12) {
1669	uint8_t buf2 = formatConvBuffer + FFALIGN(srcW2+78, 16);	1678	uint8_t buf2 = formatConvBuffer + FFALIGN(srcW2+78, 16);
1670	c->chrToYV12(formatConvBuffer, buf2, src1, src2, srcW, pal);	1679	c->chrToYV12(formatConvBuffer, buf2, src1, src2, srcW, pal);
@@ -1687,6 +1696,37 @@ static inline void hcscale(SwsContext c, uint16_t dst1, uint16_t *dst2, int ds · 16 unmodified lines
1687	c->chrConvertRange(dst1, dst2, dstWidth);	1696	c->chrConvertRange(dst1, dst2, dstWidth);
1688	}	1697	}
1689		1698
		1699	static av_always_inline void
		1700	find_c_packed_planar_out_funcs(SwsContext *c,
		1701	yuv2planar1_fn yuv2yuv1, yuv2planarX_fn yuv2yuvX,
		1702	yuv2packed1_fn yuv2packed1, yuv2packed2_fn yuv2packed2,
		1703	yuv2packedX_fn *yuv2packedX)
		1704	{
		1705	enum PixelFormat dstFormat = c->dstFormat;
		1706
		1707	if (dstFormat == PIX_FMT_NV12 \|\| dstFormat == PIX_FMT_NV21) {
		1708	*yuv2yuvX = yuv2nv12X_c;
		1709	} else if (is16BPS(dstFormat)) {
		1710	*yuv2yuvX = isBE(dstFormat) ? yuv2yuvX16BE_c : yuv2yuvX16LE_c;
		1711	} else if (is9_OR_10BPS(dstFormat)) {
		1712	if (dstFormat == PIX_FMT_YUV420P9BE \|\| dstFormat == PIX_FMT_YUV420P9LE) {
		1713	*yuv2yuvX = isBE(dstFormat) ? yuv2yuvX9BE_c : yuv2yuvX9LE_c;
		1714	} else {
		1715	*yuv2yuvX = isBE(dstFormat) ? yuv2yuvX10BE_c : yuv2yuvX10LE_c;
		1716	}
		1717	} else {
		1718	*yuv2yuv1 = yuv2yuv1_c;
		1719	*yuv2yuvX = yuv2yuvX_c;
		1720	}
		1721	if(c->flags & SWS_FULL_CHR_H_INT) {
		1722	*yuv2packedX = yuv2rgbX_c_full;
		1723	} else {
		1724	*yuv2packed1 = yuv2packed1_c;
		1725	*yuv2packed2 = yuv2packed2_c;
		1726	*yuv2packedX = yuv2packedX_c;
		1727	}
		1728	}
		1729
1690	#define DEBUG_SWSCALE_BUFFERS 0	1730	#define DEBUG_SWSCALE_BUFFERS 0
1691	#define DEBUG_BUFFERS(...) if (DEBUG_SWSCALE_BUFFERS) av_log(c, AV_LOG_DEBUG, __VA_ARGS__)	1731	#define DEBUG_BUFFERS(...) if (DEBUG_SWSCALE_BUFFERS) av_log(c, AV_LOG_DEBUG, __VA_ARGS__)
1692		1732
@@ -1731,6 +1771,11 @@ static int swScale(SwsContext c, const uint8_t src[], · 38 unmodified lines
1731	int lastDstY;	1771	int lastDstY;
1732	uint32_t *pal=c->pal_yuv;	1772	uint32_t *pal=c->pal_yuv;
1733	int should_dither= isNBPS(c->srcFormat) \|\| is16BPS(c->srcFormat);	1773	int should_dither= isNBPS(c->srcFormat) \|\| is16BPS(c->srcFormat);
		1774	yuv2planar1_fn yuv2yuv1 = c->yuv2yuv1;
		1775	yuv2planarX_fn yuv2yuvX = c->yuv2yuvX;
		1776	yuv2packed1_fn yuv2packed1 = c->yuv2packed1;
		1777	yuv2packed2_fn yuv2packed2 = c->yuv2packed2;
		1778	yuv2packedX_fn yuv2packedX = c->yuv2packedX;
1734		1779
1735	/* vars which will change and which we need to store back in the context */	1780	/* vars which will change and which we need to store back in the context */
1736	int dstY= c->dstY;	1781	int dstY= c->dstY;
@@ -1869,37 +1914,31 @@ static int swScale(SwsContext c, const uint8_t src[], · 132 unmodified lines
1869	#if HAVE_MMX	1914	#if HAVE_MMX
1870	updateMMXDitherTables(c, dstY, lumBufIndex, chrBufIndex, lastInLumBuf, lastInChrBuf);	1915	updateMMXDitherTables(c, dstY, lumBufIndex, chrBufIndex, lastInLumBuf, lastInChrBuf);
1871	#endif	1916	#endif
1872	if (dstY < dstH-2) {	1917	if (dstY >= dstH-2) {
		1918	// hmm looks like we can't use MMX here without overwriting this array's tail
		1919	find_c_packed_planar_out_funcs(c, &yuv2yuv1, &yuv2yuvX,
		1920	&yuv2packed1, &yuv2packed2,
		1921	&yuv2packedX);
		1922	}
		1923
		1924	{
1873	const int16_t lumSrcPtr= (const int16_t ) lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;	1925	const int16_t lumSrcPtr= (const int16_t ) lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;
1874	const int16_t chrUSrcPtr= (const int16_t ) chrUPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;	1926	const int16_t chrUSrcPtr= (const int16_t ) chrUPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
1875	const int16_t chrVSrcPtr= (const int16_t ) chrVPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;	1927	const int16_t chrVSrcPtr= (const int16_t ) chrVPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
1876	const int16_t alpSrcPtr= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t ) alpPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize : NULL;	1928	const int16_t alpSrcPtr= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t ) alpPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize : NULL;
1877	if (dstFormat == PIX_FMT_NV12 \|\| dstFormat == PIX_FMT_NV21) {	1929
1878	const int chrSkipMask= (1<<c->chrDstVSubSample)-1;	1930	if (isPlanarYUV(dstFormat) \|\| dstFormat==PIX_FMT_GRAY8) { //YV12 like
1879	if (dstY&chrSkipMask) uDest= NULL; //FIXME split functions in lumi / chromi
1880	c->yuv2nv12X(c,
1881	vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize,
1882	vChrFilter+chrDstY*vChrFilterSize, chrUSrcPtr, chrVSrcPtr, vChrFilterSize,
1883	dest, uDest, dstW, chrDstW, dstFormat, lumDither, chrDither);
1884	} else if (isPlanarYUV(dstFormat) \|\| dstFormat==PIX_FMT_GRAY8) { //YV12 like
1885	const int chrSkipMask= (1<<c->chrDstVSubSample)-1;	1931	const int chrSkipMask= (1<<c->chrDstVSubSample)-1;
1886	if ((dstY&chrSkipMask) \|\| isGray(dstFormat)) uDest=vDest= NULL; //FIXME split functions in lumi / chromi	1932	if ((dstY&chrSkipMask) \|\| isGray(dstFormat)) uDest=vDest= NULL; //FIXME split functions in lumi / chromi
1887	if (is16BPS(dstFormat) \|\| isNBPS(dstFormat)) {	1933	if (c->yuv2yuv1 && vLumFilterSize == 1 && vChrFilterSize == 1) { // unscaled YV12
1888	yuv2yuvX16_c(vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize,
1889	vChrFilter+chrDstY*vChrFilterSize, chrUSrcPtr,
1890	chrVSrcPtr, vChrFilterSize,
1891	alpSrcPtr, (uint16_t ) dest, (uint16_t ) uDest,
1892	(uint16_t ) vDest, (uint16_t ) aDest, dstW, chrDstW,
1893	dstFormat);
1894	} else if (vLumFilterSize == 1 && vChrFilterSize == 1) { // unscaled YV12
1895	const int16_t *lumBuf = lumSrcPtr[0];	1934	const int16_t *lumBuf = lumSrcPtr[0];
1896	const int16_t *chrUBuf= chrUSrcPtr[0];	1935	const int16_t *chrUBuf= chrUSrcPtr[0];
1897	const int16_t *chrVBuf= chrVSrcPtr[0];	1936	const int16_t *chrVBuf= chrVSrcPtr[0];
1898	const int16_t *alpBuf= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? alpSrcPtr[0] : NULL;	1937	const int16_t *alpBuf= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? alpSrcPtr[0] : NULL;
1899	c->yuv2yuv1(c, lumBuf, chrUBuf, chrVBuf, alpBuf, dest,	1938	yuv2yuv1(c, lumBuf, chrUBuf, chrVBuf, alpBuf, dest,
1900	uDest, vDest, aDest, dstW, chrDstW, lumDither, chrDither);	1939	uDest, vDest, aDest, dstW, chrDstW, lumDither, chrDither);
1901	} else { //General YV12	1940	} else { //General YV12
1902	c->yuv2yuvX(c,	1941	yuv2yuvX(c,
1903	vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize,	1942	vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize,
1904	vChrFilter+chrDstY*vChrFilterSize, chrUSrcPtr,	1943	vChrFilter+chrDstY*vChrFilterSize, chrUSrcPtr,
1905	chrVSrcPtr, vChrFilterSize,	1944	chrVSrcPtr, vChrFilterSize,
@@ -1908,94 +1947,28 @@ static int swScale(SwsContext c, const uint8_t src[], · 2 unmodified lines
1908	} else {	1947	} else {
1909	assert(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);	1948	assert(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);
1910	assert(chrUSrcPtr + vChrFilterSize - 1 < chrUPixBuf + vChrBufSize*2);	1949	assert(chrUSrcPtr + vChrFilterSize - 1 < chrUPixBuf + vChrBufSize*2);
1911	if (vLumFilterSize == 1 && vChrFilterSize == 2) { //unscaled RGB	1950	if (c->yuv2packed1 && vLumFilterSize == 1 && vChrFilterSize == 2) { //unscaled RGB
1912	int chrAlpha= vChrFilter[2*dstY+1];	1951	int chrAlpha= vChrFilter[2*dstY+1];
1913	if(flags & SWS_FULL_CHR_H_INT) {	1952	yuv2packed1(c, lumSrcPtr, chrUSrcPtr, *(chrUSrcPtr+1),
1914	yuv2rgbX_c_full(c, //FIXME write a packed1_full function	1953	chrVSrcPtr, (chrVSrcPtr+1),
1915	vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,	1954	alpPixBuf ? *alpSrcPtr : NULL,
1916	vChrFilter+dstY*vChrFilterSize, chrUSrcPtr,	1955	dest, dstW, chrAlpha, dstFormat, flags, dstY);
1917	chrVSrcPtr, vChrFilterSize,	1956	} else if (c->yuv2packed2 && vLumFilterSize == 2 && vChrFilterSize == 2) { //bilinear upscale RGB
1918	alpSrcPtr, dest, dstW, dstY);
1919	} else {
1920	c->yuv2packed1(c, lumSrcPtr, chrUSrcPtr, *(chrUSrcPtr+1),
1921	chrVSrcPtr, (chrVSrcPtr+1),
1922	alpPixBuf ? *alpSrcPtr : NULL,
1923	dest, dstW, chrAlpha, dstFormat, flags, dstY);
1924	}
1925	} else if (vLumFilterSize == 2 && vChrFilterSize == 2) { //bilinear upscale RGB
1926	int lumAlpha= vLumFilter[2*dstY+1];	1957	int lumAlpha= vLumFilter[2*dstY+1];
1927	int chrAlpha= vChrFilter[2*dstY+1];	1958	int chrAlpha= vChrFilter[2*dstY+1];
1928	lumMmxFilter[2]=	1959	lumMmxFilter[2]=
1929	lumMmxFilter[3]= vLumFilter[2dstY ]0x10001;	1960	lumMmxFilter[3]= vLumFilter[2dstY ]0x10001;
1930	chrMmxFilter[2]=	1961	chrMmxFilter[2]=
1931	chrMmxFilter[3]= vChrFilter[2chrDstY]0x10001;	1962	chrMmxFilter[3]= vChrFilter[2chrDstY]0x10001;
1932	if(flags & SWS_FULL_CHR_H_INT) {	1963	yuv2packed2(c, lumSrcPtr, (lumSrcPtr+1), chrUSrcPtr, (chrUSrcPtr+1),
1933	yuv2rgbX_c_full(c, //FIXME write a packed2_full function	1964	chrVSrcPtr, (chrVSrcPtr+1),
1934	vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,	1965	alpPixBuf ? alpSrcPtr : NULL, alpPixBuf ? (alpSrcPtr+1) : NULL,
1935	vChrFilter+dstY*vChrFilterSize, chrUSrcPtr, chrVSrcPtr, vChrFilterSize,	1966	dest, dstW, lumAlpha, chrAlpha, dstY);
1936	alpSrcPtr, dest, dstW, dstY);
1937	} else {
1938	c->yuv2packed2(c, lumSrcPtr, (lumSrcPtr+1), chrUSrcPtr, (chrUSrcPtr+1),
1939	chrVSrcPtr, (chrVSrcPtr+1),
1940	alpPixBuf ? alpSrcPtr : NULL, alpPixBuf ? (alpSrcPtr+1) : NULL,
1941	dest, dstW, lumAlpha, chrAlpha, dstY);
1942	}
1943	} else { //general RGB	1967	} else { //general RGB
1944	if(flags & SWS_FULL_CHR_H_INT) {	1968	yuv2packedX(c,
1945	yuv2rgbX_c_full(c,	1969	vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
1946	vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,	1970	vChrFilter+dstY*vChrFilterSize, chrUSrcPtr, chrVSrcPtr, vChrFilterSize,
1947	vChrFilter+dstY*vChrFilterSize, chrUSrcPtr, chrVSrcPtr, vChrFilterSize,	1971	alpSrcPtr, dest, dstW, dstY);
1948	alpSrcPtr, dest, dstW, dstY);
1949	} else {
1950	c->yuv2packedX(c,
1951	vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
1952	vChrFilter+dstY*vChrFilterSize, chrUSrcPtr, chrVSrcPtr, vChrFilterSize,
1953	alpSrcPtr, dest, dstW, dstY);
1954	}
1955	}
1956	}
1957	} else { // hmm looks like we can't use MMX here without overwriting this array's tail
1958	const int16_t lumSrcPtr= (const int16_t )lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;
1959	const int16_t chrUSrcPtr= (const int16_t )chrUPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
1960	const int16_t chrVSrcPtr= (const int16_t )chrVPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
1961	const int16_t alpSrcPtr= (CONFIG_SWSCALE_ALPHA && alpPixBuf) ? (const int16_t )alpPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize : NULL;
1962	if (dstFormat == PIX_FMT_NV12 \|\| dstFormat == PIX_FMT_NV21) {
1963	const int chrSkipMask= (1<<c->chrDstVSubSample)-1;
1964	if (dstY&chrSkipMask) uDest= NULL; //FIXME split functions in lumi / chromi
1965	yuv2nv12X_c(c, vLumFilter+dstY*vLumFilterSize,
1966	lumSrcPtr, vLumFilterSize,
1967	vChrFilter+chrDstY*vChrFilterSize,
1968	chrUSrcPtr, chrVSrcPtr, vChrFilterSize,
1969	dest, uDest, dstW, chrDstW, dstFormat, lumDither, chrDither);
1970	} else if (isPlanarYUV(dstFormat) \|\| dstFormat==PIX_FMT_GRAY8) { //YV12
1971	const int chrSkipMask= (1<<c->chrDstVSubSample)-1;
1972	if ((dstY&chrSkipMask) \|\| isGray(dstFormat)) uDest=vDest= NULL; //FIXME split functions in lumi / chromi
1973	if (is16BPS(dstFormat) \|\| is9_OR_10BPS(dstFormat)) {
1974	yuv2yuvX16_c(vLumFilter+dstY*vLumFilterSize , lumSrcPtr, vLumFilterSize,
1975	vChrFilter+chrDstY*vChrFilterSize, chrUSrcPtr, chrVSrcPtr, vChrFilterSize,
1976	alpSrcPtr, (uint16_t ) dest, (uint16_t ) uDest, (uint16_t ) vDest, (uint16_t ) aDest, dstW, chrDstW,
1977	dstFormat);
1978	} else {
1979	yuv2yuvX_c(c, vLumFilter+dstY*vLumFilterSize,
1980	lumSrcPtr, vLumFilterSize,
1981	vChrFilter+chrDstY*vChrFilterSize,
1982	chrUSrcPtr, chrVSrcPtr, vChrFilterSize,
1983	alpSrcPtr, dest, uDest, vDest, aDest,
1984	dstW, chrDstW, lumDither, chrDither);
1985	}
1986	} else {
1987	assert(lumSrcPtr + vLumFilterSize - 1 < lumPixBuf + vLumBufSize*2);
1988	assert(chrUSrcPtr + vChrFilterSize - 1 < chrUPixBuf + vChrBufSize*2);
1989	if(flags & SWS_FULL_CHR_H_INT) {
1990	yuv2rgbX_c_full(c,
1991	vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
1992	vChrFilter+dstY*vChrFilterSize, chrUSrcPtr, chrVSrcPtr, vChrFilterSize,
1993	alpSrcPtr, dest, dstW, dstY);
1994	} else {
1995	yuv2packedX_c(c,
1996	vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
1997	vChrFilter+dstY*vChrFilterSize, chrUSrcPtr, chrVSrcPtr, vChrFilterSize,
1998	alpSrcPtr, dest, dstW, dstY);
1999	}	1972	}
2000	}	1973	}
2001	}	1974	}
@@ -2024,17 +1997,13 @@ static void sws_init_swScale_c(SwsContext *c) · 22 unmodified lines
2024	{	1997	{
2025	enum PixelFormat srcFormat = c->srcFormat;	1998	enum PixelFormat srcFormat = c->srcFormat;
2026		1999
2027	c->yuv2nv12X = yuv2nv12X_c;	2000	find_c_packed_planar_out_funcs(c, &c->yuv2yuv1, &c->yuv2yuvX,
2028	c->yuv2yuv1 = yuv2yuv1_c;	2001	&c->yuv2packed1, &c->yuv2packed2,
2029	c->yuv2yuvX = yuv2yuvX_c;	2002	&c->yuv2packedX);
2030	c->yuv2packed1 = yuv2packed1_c;
2031	c->yuv2packed2 = yuv2packed2_c;
2032	c->yuv2packedX = yuv2packedX_c;
2033		2003
2034	c->hScale = hScale_c;	2004	c->hScale = hScale_c;
2035		2005
2036	if (c->flags & SWS_FAST_BILINEAR)	2006	if (c->flags & SWS_FAST_BILINEAR) {
2037	{
2038	c->hyscale_fast = hyscale_fast_c;	2007	c->hyscale_fast = hyscale_fast_c;
2039	c->hcscale_fast = hcscale_fast_c;	2008	c->hcscale_fast = hcscale_fast_c;
2040	}	2009	}
@@ -2133,28 +2102,18 @@ static void sws_init_swScale_c(SwsContext *c) · 92 unmodified lines
2133	}	2102	}
2134	if (c->alpPixBuf) {	2103	if (c->alpPixBuf) {
2135	switch (srcFormat) {	2104	switch (srcFormat) {
2136	case PIX_FMT_RGB32 :	2105	case PIX_FMT_BGRA:
2137	case PIX_FMT_RGB32_1:	2106	case PIX_FMT_RGBA: c->alpToYV12 = rgbaToA_c; break;
2138	case PIX_FMT_BGR32 :	2107	case PIX_FMT_ABGR:
2139	case PIX_FMT_BGR32_1: c->alpToYV12 = abgrToA_c; break;	2108	case PIX_FMT_ARGB: c->alpToYV12 = abgrToA_c; break;
2140	case PIX_FMT_GRAY8A : c->alpToYV12 = yuy2ToY_c; break;	2109	case PIX_FMT_Y400A: c->alpToYV12 = uyvyToY_c; break;
2141	case PIX_FMT_PAL8 : c->alpToYV12 = palToA_c; break;	2110	case PIX_FMT_PAL8 : c->alpToYV12 = palToA_c; break;
2142	}	2111	}
2143	}	2112	}
2144		2113
2145	if(isAnyRGB(c->srcFormat) \|\| c->srcFormat == PIX_FMT_PAL8)	2114	if(isAnyRGB(c->srcFormat) \|\| c->srcFormat == PIX_FMT_PAL8)
2146	c->hScale16= hScale16_c;	2115	c->hScale16= hScale16_c;
2147		2116
2148	switch (srcFormat) {
2149	case PIX_FMT_GRAY8A :
2150	c->alpSrcOffset = 1;
2151	break;
2152	case PIX_FMT_RGB32 :
2153	case PIX_FMT_BGR32 :
2154	c->alpSrcOffset = 3;
2155	break;
2156	}
2157
2158	if (c->srcRange != c->dstRange && !isAnyRGB(c->dstFormat)) {	2117	if (c->srcRange != c->dstRange && !isAnyRGB(c->dstFormat)) {
2159	if (c->srcRange) {	2118	if (c->srcRange) {
2160	c->lumConvertRange = lumRangeFromJpeg_c;	2119	c->lumConvertRange = lumRangeFromJpeg_c;

libswscale/swscale_internal.h+40−44

                        int srcStride[], int srcSliceY, int srcSliceH,
                        uint8_t* dst[], int dstStride[]);
+typedef void (*yuv2planar1_fn) (struct SwsContext *c,
+                                const int16_t *lumSrc, const int16_t *chrUSrc,
+                                const int16_t *chrVSrc, const int16_t *alpSrc,
+                                uint8_t *dest,
+                                uint8_t *uDest, uint8_t *vDest, uint8_t *aDest,
+                                int dstW, int chrDstW, const uint8_t *lumDither, const uint8_t *chrDither);
+typedef void (*yuv2planarX_fn) (struct SwsContext *c,
+                                const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize,
+                                const int16_t *chrFilter, const int16_t **chrUSrc,
+                                const int16_t **chrVSrc, int chrFilterSize,
+                                const int16_t **alpSrc,
+                                uint8_t *dest,
+                                uint8_t *uDest, uint8_t *vDest, uint8_t *aDest,
+                                int dstW, int chrDstW, const uint8_t *lumDither, const uint8_t *chrDither);
+typedef void (*yuv2packed1_fn) (struct SwsContext *c,
+                                const uint16_t *buf0,
+                                const uint16_t *ubuf0, const uint16_t *ubuf1,
+                                const uint16_t *vbuf0, const uint16_t *vbuf1,
+                                const uint16_t *abuf0,
+                                uint8_t *dest,
+                                int dstW, int uvalpha, int dstFormat, int flags, int y);
+typedef void (*yuv2packed2_fn) (struct SwsContext *c,
+                                const uint16_t *buf0, const uint16_t *buf1,
+                                const uint16_t *ubuf0, const uint16_t *ubuf1,
+                                const uint16_t *vbuf0, const uint16_t *vbuf1,
+                                const uint16_t *abuf0, const uint16_t *abuf1,
+                                uint8_t *dest,
+                                int dstW, int yalpha, int uvalpha, int y);
+typedef void (*yuv2packedX_fn) (struct SwsContext *c,
+                                const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize,
+                                const int16_t *chrFilter, const int16_t **chrUSrc,
+                                const int16_t **chrVSrc, int chrFilterSize,
+                                const int16_t **alpSrc, uint8_t *dest,
+                                int dstW, int dstY);
 /* This struct should be aligned on at least a 32-byte boundary. */
 typedef struct SwsContext {
     /**
 #endif
     /* function pointers for swScale() */
-    void (*yuv2nv12X  )(struct SwsContext *c,
+    yuv2planar1_fn yuv2yuv1;
-                        const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize,
+    yuv2planarX_fn yuv2yuvX;
-                        const int16_t *chrFilter, const int16_t **chrUSrc,
+    yuv2packed1_fn yuv2packed1;
-                        const int16_t **chrVSrc, int chrFilterSize,
+    yuv2packed2_fn yuv2packed2;
-                        uint8_t *dest, uint8_t *uDest,
+    yuv2packedX_fn yuv2packedX;
-                        int dstW, int chrDstW, int dstFormat, const uint8_t *lumDither, const uint8_t *chrDither);
-    void (*yuv2yuv1   )(struct SwsContext *c,
-                        const int16_t *lumSrc, const int16_t *chrUSrc,
-                        const int16_t *chrVSrc, const int16_t *alpSrc,
-                        uint8_t *dest,
-                        uint8_t *uDest, uint8_t *vDest, uint8_t *aDest,
-                        int dstW, int chrDstW, const uint8_t *lumDither, const uint8_t *chrDither);
-    void (*yuv2yuvX   )(struct SwsContext *c,
-                        const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize,
-                        const int16_t *chrFilter, const int16_t **chrUSrc,
-                        const int16_t **chrVSrc, int chrFilterSize,
-                        const int16_t **alpSrc,
-                        uint8_t *dest,
-                        uint8_t *uDest, uint8_t *vDest, uint8_t *aDest,
-                        int dstW, int chrDstW, const uint8_t *lumDither, const uint8_t *chrDither);
-    void (*yuv2packed1)(struct SwsContext *c,
-                        const uint16_t *buf0,
-                        const uint16_t *ubuf0, const uint16_t *ubuf1,
-                        const uint16_t *vbuf0, const uint16_t *vbuf1,
-                        const uint16_t *abuf0,
-                        uint8_t *dest,
-                        int dstW, int uvalpha, int dstFormat, int flags, int y);
-    void (*yuv2packed2)(struct SwsContext *c,
-                        const uint16_t *buf0, const uint16_t *buf1,
-                        const uint16_t *ubuf0, const uint16_t *ubuf1,
-                        const uint16_t *vbuf0, const uint16_t *vbuf1,
-                        const uint16_t *abuf0, const uint16_t *abuf1,
-                        uint8_t *dest,
-                        int dstW, int yalpha, int uvalpha, int y);
-    void (*yuv2packedX)(struct SwsContext *c,
-                        const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize,
-                        const int16_t *chrFilter, const int16_t **chrUSrc,
-                        const int16_t **chrVSrc, int chrFilterSize,
-                        const int16_t **alpSrc, uint8_t *dest,
-                        int dstW, int dstY);
     void (*lumToYV12)(uint8_t *dst, const uint8_t *src,
                       int width, uint32_t *pal); ///< Unscaled conversion of luma plane to YV12 for horizontal scaler.
     void (*lumConvertRange)(int16_t *dst, int width); ///< Color range conversion function for luma plane if needed.
     void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width); ///< Color range conversion function for chroma planes if needed.
-    int lumSrcOffset; ///< Offset given to luma src pointers passed to horizontal input functions.
-    int chrSrcOffset; ///< Offset given to chroma src pointers passed to horizontal input functions.
-    int alpSrcOffset; ///< Offset given to alpha src pointers passed to horizontal input functions.
     int needs_hcscale; ///< Set if there are chroma planes to be converted.
 } SwsContext;

libswscale/x86/swscale_template.c+40−32

@@ -2351,56 +2351,64 @@ static inline void RENAME(hcscale_fast)(SwsContext c, int16_t dst1, int16_t *d · 2350 unmodified lines
2351		2351
2352	static void RENAME(sws_init_swScale)(SwsContext *c)	2352	static void RENAME(sws_init_swScale)(SwsContext *c)
2353	{	2353	{
2354	enum PixelFormat srcFormat = c->srcFormat;	2354	enum PixelFormat srcFormat = c->srcFormat,
2355		2355	dstFormat = c->dstFormat;
2356	if (!(c->flags & SWS_BITEXACT)) {	2356
2357	if (c->flags & SWS_ACCURATE_RND) {	2357	if (!is16BPS(dstFormat) && !is9_OR_10BPS(dstFormat) && dstFormat != PIX_FMT_NV12
2358	c->yuv2yuv1 = RENAME(yuv2yuv1_ar );	2358	&& dstFormat != PIX_FMT_NV21 && !(c->flags & SWS_BITEXACT)) {
2359	c->yuv2yuvX = RENAME(yuv2yuvX_ar );	2359	if (c->flags & SWS_ACCURATE_RND) {
2360	switch (c->dstFormat) {	2360	c->yuv2yuv1 = RENAME(yuv2yuv1_ar );
2361	case PIX_FMT_RGB32: c->yuv2packedX = RENAME(yuv2rgb32_X_ar); break;	2361	c->yuv2yuvX = RENAME(yuv2yuvX_ar );
2362	case PIX_FMT_BGR24: c->yuv2packedX = RENAME(yuv2bgr24_X_ar); break;	2362	if (!(c->flags & SWS_FULL_CHR_H_INT)) {
2363	case PIX_FMT_RGB555: c->yuv2packedX = RENAME(yuv2rgb555_X_ar); break;	2363	switch (c->dstFormat) {
2364	case PIX_FMT_RGB565: c->yuv2packedX = RENAME(yuv2rgb565_X_ar); break;	2364	case PIX_FMT_RGB32: c->yuv2packedX = RENAME(yuv2rgb32_X_ar); break;
2365	case PIX_FMT_YUYV422: c->yuv2packedX = RENAME(yuv2yuyv422_X_ar); break;	2365	case PIX_FMT_BGR24: c->yuv2packedX = RENAME(yuv2bgr24_X_ar); break;
2366	default: break;	2366	case PIX_FMT_RGB555: c->yuv2packedX = RENAME(yuv2rgb555_X_ar); break;
		2367	case PIX_FMT_RGB565: c->yuv2packedX = RENAME(yuv2rgb565_X_ar); break;
		2368	case PIX_FMT_YUYV422: c->yuv2packedX = RENAME(yuv2yuyv422_X_ar); break;
		2369	default: break;
		2370	}
		2371	}
		2372	} else {
		2373	int should_dither= isNBPS(c->srcFormat) \|\| is16BPS(c->srcFormat);
		2374	c->yuv2yuv1 = should_dither ? RENAME(yuv2yuv1_ar ) : RENAME(yuv2yuv1 );
		2375	c->yuv2yuvX = RENAME(yuv2yuvX );
		2376	if (!(c->flags & SWS_FULL_CHR_H_INT)) {
		2377	switch (c->dstFormat) {
		2378	case PIX_FMT_RGB32: c->yuv2packedX = RENAME(yuv2rgb32_X); break;
		2379	case PIX_FMT_BGR24: c->yuv2packedX = RENAME(yuv2bgr24_X); break;
		2380	case PIX_FMT_RGB555: c->yuv2packedX = RENAME(yuv2rgb555_X); break;
		2381	case PIX_FMT_RGB565: c->yuv2packedX = RENAME(yuv2rgb565_X); break;
		2382	case PIX_FMT_YUYV422: c->yuv2packedX = RENAME(yuv2yuyv422_X); break;
		2383	default: break;
		2384	}
		2385	}
2367	}	2386	}
2368	} else {	2387	if (!(c->flags & SWS_FULL_CHR_H_INT)) {
2369	int should_dither= isNBPS(c->srcFormat) \|\| is16BPS(c->srcFormat);
2370	c->yuv2yuv1 = should_dither ? RENAME(yuv2yuv1_ar ) : RENAME(yuv2yuv1 );
2371	c->yuv2yuvX = RENAME(yuv2yuvX );
2372	switch (c->dstFormat) {	2388	switch (c->dstFormat) {
2373	case PIX_FMT_RGB32: c->yuv2packedX = RENAME(yuv2rgb32_X); break;	2389	case PIX_FMT_RGB32:
2374	case PIX_FMT_BGR24: c->yuv2packedX = RENAME(yuv2bgr24_X); break;
2375	case PIX_FMT_RGB555: c->yuv2packedX = RENAME(yuv2rgb555_X); break;
2376	case PIX_FMT_RGB565: c->yuv2packedX = RENAME(yuv2rgb565_X); break;
2377	case PIX_FMT_YUYV422: c->yuv2packedX = RENAME(yuv2yuyv422_X); break;
2378	default: break;
2379	}
2380	}
2381	switch (c->dstFormat) {
2382	case PIX_FMT_RGB32:
2383	c->yuv2packed1 = RENAME(yuv2rgb32_1);	2390	c->yuv2packed1 = RENAME(yuv2rgb32_1);
2384	c->yuv2packed2 = RENAME(yuv2rgb32_2);	2391	c->yuv2packed2 = RENAME(yuv2rgb32_2);
2385	break;	2392	break;
2386	case PIX_FMT_BGR24:	2393	case PIX_FMT_BGR24:
2387	c->yuv2packed1 = RENAME(yuv2bgr24_1);	2394	c->yuv2packed1 = RENAME(yuv2bgr24_1);
2388	c->yuv2packed2 = RENAME(yuv2bgr24_2);	2395	c->yuv2packed2 = RENAME(yuv2bgr24_2);
2389	break;	2396	break;
2390	case PIX_FMT_RGB555:	2397	case PIX_FMT_RGB555:
2391	c->yuv2packed1 = RENAME(yuv2rgb555_1);	2398	c->yuv2packed1 = RENAME(yuv2rgb555_1);
2392	c->yuv2packed2 = RENAME(yuv2rgb555_2);	2399	c->yuv2packed2 = RENAME(yuv2rgb555_2);
2393	break;	2400	break;
2394	case PIX_FMT_RGB565:	2401	case PIX_FMT_RGB565:
2395	c->yuv2packed1 = RENAME(yuv2rgb565_1);	2402	c->yuv2packed1 = RENAME(yuv2rgb565_1);
2396	c->yuv2packed2 = RENAME(yuv2rgb565_2);	2403	c->yuv2packed2 = RENAME(yuv2rgb565_2);
2397	break;	2404	break;
2398	case PIX_FMT_YUYV422:	2405	case PIX_FMT_YUYV422:
2399	c->yuv2packed1 = RENAME(yuv2yuyv422_1);	2406	c->yuv2packed1 = RENAME(yuv2yuyv422_1);
2400	c->yuv2packed2 = RENAME(yuv2yuyv422_2);	2407	c->yuv2packed2 = RENAME(yuv2yuyv422_2);
2401	break;	2408	break;
2402	default:	2409	default:
2403	break;	2410	break;
		2411	}
2404	}	2412	}
2405	}	2413	}
2406		2414

Merge remote-tracking branch 'qatar/master'

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code