Merge remote-tracking branch 'qatar/master'

* qatar/master:
  rv30: return AVERROR(EINVAL) instead of EINVAL
  build: add -L flags before existing LDFLAGS
  simple_idct: whitespace cosmetics
  simple_idct: make repeated code a macro
  dsputil: remove huge #if 0 block
  simple_idct: change 10-bit add/put stride from pixels to bytes
  dsputil: allow 9/10-bit functions for non-h264 codecs
  dnxhd: rename some data tables
  dnxhdenc: remove inline from function only called through pointer
  dnxhdenc: whitespace cosmetics
  swscale: mark YUV422P10(LE,BE) as supported for output
  configure: add -xc99 to LDFLAGS for Sun CC
  Remove unused and non-compiling vestigial g729 decoder
  Remove unused code under G729_BITEXACT #ifdef.
  mpegvideo: fix invalid picture unreferencing.
  dsputil: Remove extra blank line at end.
  dsputil: Replace a LONG_MAX check with HAVE_FAST_64BIT.
  simple_idct: add 10-bit version

Conflicts:
	Makefile
	libavcodec/g729data.h
	libavcodec/g729dec.c
	libavcodec/rv30.c
	tests/ref/lavfi/pixdesc
	tests/ref/lavfi/pixfmts_copy
	tests/ref/lavfi/pixfmts_null
	tests/ref/lavfi/pixfmts_scale
	tests/ref/lavfi/pixfmts_vflip

Merged-by: Michael Niedermayer <michaelni@gmx.at>
pull/2/head
Michael Niedermayer 14 years ago
commit f93f6963ba
  1. 2
      Makefile
  2. 4
      common.mak
  3. 1
      configure
  4. 11
      libavcodec/acelp_pitch_delay.c
  5. 20
      libavcodec/acelp_vectors.c
  6. 31
      libavcodec/acelp_vectors.h
  7. 2
      libavcodec/alpha/dsputil_alpha.c
  8. 2
      libavcodec/amrnbdec.c
  9. 2
      libavcodec/arm/dsputil_init_arm.c
  10. 5
      libavcodec/arm/dsputil_init_armv5te.c
  11. 5
      libavcodec/arm/dsputil_init_armv6.c
  12. 2
      libavcodec/arm/dsputil_init_neon.c
  13. 22
      libavcodec/bfin/dsputil_bfin.c
  14. 85
      libavcodec/celp_math.c
  15. 2
      libavcodec/dct-test.c
  16. 64
      libavcodec/dnxhdenc.c
  17. 45
      libavcodec/dsputil.c
  18. 145
      libavcodec/dsputil_template.c
  19. 278
      libavcodec/g729data.h
  20. 331
      libavcodec/g729dec.c
  21. 4
      libavcodec/lsp.c
  22. 10
      libavcodec/mpegvideo.c
  23. 2
      libavcodec/ppc/dsputil_ppc.c
  24. 3
      libavcodec/ps2/dsputil_mmi.c
  25. 3
      libavcodec/sh4/dsputil_sh4.c
  26. 338
      libavcodec/simple_idct.c
  27. 11
      libavcodec/simple_idct.h
  28. 316
      libavcodec/simple_idct_template.c
  29. 3
      libavcodec/sparc/dsputil_vis.c
  30. 4
      libavcodec/vc1.c
  31. 2
      libavcodec/x86/dsputil_mmx.c
  32. 2
      libswscale/utils.c

@ -27,8 +27,6 @@ ALLPROGS = $(BASENAMES:%=%$(EXESUF))
ALLPROGS_G = $(BASENAMES:%=%_g$(EXESUF)) ALLPROGS_G = $(BASENAMES:%=%_g$(EXESUF))
ALLMANPAGES = $(BASENAMES:%=%.1) ALLMANPAGES = $(BASENAMES:%=%.1)
ALLFFLIBS = avcodec avdevice avfilter avformat avutil postproc swscale
FFLIBS-$(CONFIG_AVDEVICE) += avdevice FFLIBS-$(CONFIG_AVDEVICE) += avdevice
FFLIBS-$(CONFIG_AVFILTER) += avfilter FFLIBS-$(CONFIG_AVFILTER) += avfilter
FFLIBS-$(CONFIG_AVFORMAT) += avformat FFLIBS-$(CONFIG_AVFORMAT) += avformat

@ -20,6 +20,8 @@ $(foreach VAR,$(SILENT),$(eval override $(VAR) = @$($(VAR))))
$(eval INSTALL = @$(call ECHO,INSTALL,$$(^:$(SRC_DIR)/%=%)); $(INSTALL)) $(eval INSTALL = @$(call ECHO,INSTALL,$$(^:$(SRC_DIR)/%=%)); $(INSTALL))
endif endif
ALLFFLIBS = avcodec avdevice avfilter avformat avutil postproc swscale
# NASM requires -I path terminated with / # NASM requires -I path terminated with /
IFLAGS := -I. -I$(SRC_PATH)/ IFLAGS := -I. -I$(SRC_PATH)/
CPPFLAGS := $(IFLAGS) $(CPPFLAGS) CPPFLAGS := $(IFLAGS) $(CPPFLAGS)
@ -27,7 +29,7 @@ CFLAGS += $(ECFLAGS)
CCFLAGS = $(CFLAGS) CCFLAGS = $(CFLAGS)
YASMFLAGS += $(IFLAGS) -Pconfig.asm YASMFLAGS += $(IFLAGS) -Pconfig.asm
HOSTCFLAGS += $(IFLAGS) HOSTCFLAGS += $(IFLAGS)
LDFLAGS += $(ALLFFLIBS:%=-Llib%) LDFLAGS := $(ALLFFLIBS:%=-Llib%) $(LDFLAGS)
define COMPILE define COMPILE
$($(1)DEP) $($(1)DEP)

1
configure vendored

@ -2049,6 +2049,7 @@ elif $cc -V 2>&1 | grep -q Sun; then
cc_ident=$($cc -V 2>&1 | head -n1 | cut -d' ' -f 2-) cc_ident=$($cc -V 2>&1 | head -n1 | cut -d' ' -f 2-)
DEPEND_CMD='$(DEPCC) $(DEPFLAGS) $< | sed -e "1s,^.*: ,$@: ," -e "\$$!s,\$$, \\\," -e "1!s,^.*: , ," > $(@:.o=.d)' DEPEND_CMD='$(DEPCC) $(DEPFLAGS) $< | sed -e "1s,^.*: ,$@: ," -e "\$$!s,\$$, \\\," -e "1!s,^.*: , ," > $(@:.o=.d)'
DEPFLAGS='$(CPPFLAGS) $(CFLAGS) -xM1' DEPFLAGS='$(CPPFLAGS) $(CFLAGS) -xM1'
add_ldflags -xc99
speed_cflags='-O5' speed_cflags='-O5'
size_cflags='-O5 -xspace' size_cflags='-O5 -xspace'
filter_cflags=suncc_flags filter_cflags=suncc_flags

@ -105,20 +105,9 @@ int16_t ff_acelp_decode_gain_code(
for(i=0; i<ma_pred_order; i++) for(i=0; i<ma_pred_order; i++)
mr_energy += quant_energy[i] * ma_prediction_coeff[i]; mr_energy += quant_energy[i] * ma_prediction_coeff[i];
#ifdef G729_BITEXACT
mr_energy += (((-6165LL * ff_log2(dsp->scalarproduct_int16(fc_v, fc_v, subframe_size, 0))) >> 3) & ~0x3ff);
mr_energy = (5439 * (mr_energy >> 15)) >> 8; // (0.15) = (0.15) * (7.23)
return bidir_sal(
((ff_exp2(mr_energy & 0x7fff) + 16) >> 5) * (gain_corr_factor >> 1),
(mr_energy >> 15) - 25
);
#else
mr_energy = gain_corr_factor * exp(M_LN10 / (20 << 23) * mr_energy) / mr_energy = gain_corr_factor * exp(M_LN10 / (20 << 23) * mr_energy) /
sqrt(dsp->scalarproduct_int16(fc_v, fc_v, subframe_size, 0)); sqrt(dsp->scalarproduct_int16(fc_v, fc_v, subframe_size, 0));
return mr_energy >> 12; return mr_energy >> 12;
#endif
} }
float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy, float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy,

@ -48,26 +48,6 @@ const uint8_t ff_fc_2pulses_9bits_track1_gray[16] =
28, 26, 28, 26,
}; };
const uint8_t ff_fc_2pulses_9bits_track2_gray[32] =
{
0, 2,
5, 4,
12, 10,
7, 9,
25, 24,
20, 22,
14, 15,
19, 17,
36, 31,
21, 26,
1, 6,
16, 11,
27, 29,
32, 30,
39, 37,
34, 35,
};
const uint8_t ff_fc_4pulses_8bits_tracks_13[16] = const uint8_t ff_fc_4pulses_8bits_tracks_13[16] =
{ {
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75,

@ -81,37 +81,6 @@ extern const uint8_t ff_fc_4pulses_8bits_track_4[32];
extern const uint8_t ff_fc_2pulses_9bits_track1[16]; extern const uint8_t ff_fc_2pulses_9bits_track1[16];
extern const uint8_t ff_fc_2pulses_9bits_track1_gray[16]; extern const uint8_t ff_fc_2pulses_9bits_track1_gray[16];
/**
* Track|Pulse| Positions
* -----------------------------------------
* 2 | 1 | 0, 7, 14, 20, 27, 34, 1, 21
* | | 2, 9, 15, 22, 29, 35, 6, 26
* | | 4,10, 17, 24, 30, 37, 11, 31
* | | 5,12, 19, 25, 32, 39, 16, 36
* -----------------------------------------
*
* @remark Track in the table should be read top-to-bottom, left-to-right.
*
* @note (EE.1) This table (from the reference code) does not comply with
* the specification.
* The specification contains the following table:
*
* Track|Pulse| Positions
* -----------------------------------------
* 2 | 1 | 0, 5, 10, 15, 20, 25, 30, 35
* | | 1, 6, 11, 16, 21, 26, 31, 36
* | | 2, 7, 12, 17, 22, 27, 32, 37
* | | 4, 9, 14, 19, 24, 29, 34, 39
*
* -----------------------------------------
*
* @note (EE.2) Reference G.729D code also uses gray decoding for each
* pulse index before looking up the value in the table.
*
* Used in G.729 @@6.4k (with gray coding)
*/
extern const uint8_t ff_fc_2pulses_9bits_track2_gray[32];
/** /**
* b60 hamming windowed sinc function coefficients * b60 hamming windowed sinc function coefficients
*/ */

@ -335,7 +335,7 @@ void dsputil_init_alpha(DSPContext* c, AVCodecContext *avctx)
put_pixels_clamped_axp_p = c->put_pixels_clamped; put_pixels_clamped_axp_p = c->put_pixels_clamped;
add_pixels_clamped_axp_p = c->add_pixels_clamped; add_pixels_clamped_axp_p = c->add_pixels_clamped;
if (!avctx->lowres && if (!avctx->lowres && avctx->bits_per_raw_sample <= 8 &&
(avctx->idct_algo == FF_IDCT_AUTO || (avctx->idct_algo == FF_IDCT_AUTO ||
avctx->idct_algo == FF_IDCT_SIMPLEALPHA)) { avctx->idct_algo == FF_IDCT_SIMPLEALPHA)) {
c->idct_put = ff_simple_idct_put_axp; c->idct_put = ff_simple_idct_put_axp;

@ -83,7 +83,7 @@
/** Maximum sharpening factor /** Maximum sharpening factor
* *
* The specification says 0.8, which should be 13107, but the reference C code * The specification says 0.8, which should be 13107, but the reference C code
* uses 13017 instead. (Amusingly the same applies to SHARP_MAX in g729dec.c.) * uses 13017 instead. (Amusingly the same applies to SHARP_MAX in bitexact G.729.)
*/ */
#define SHARP_MAX 0.79449462890625 #define SHARP_MAX 0.79449462890625

@ -80,7 +80,7 @@ void dsputil_init_arm(DSPContext* c, AVCodecContext *avctx)
ff_put_pixels_clamped = c->put_pixels_clamped; ff_put_pixels_clamped = c->put_pixels_clamped;
ff_add_pixels_clamped = c->add_pixels_clamped; ff_add_pixels_clamped = c->add_pixels_clamped;
if (!avctx->lowres) { if (!avctx->lowres && avctx->bits_per_raw_sample <= 8) {
if(avctx->idct_algo == FF_IDCT_AUTO || if(avctx->idct_algo == FF_IDCT_AUTO ||
avctx->idct_algo == FF_IDCT_ARM){ avctx->idct_algo == FF_IDCT_ARM){
c->idct_put = j_rev_dct_arm_put; c->idct_put = j_rev_dct_arm_put;

@ -29,8 +29,9 @@ void ff_prefetch_arm(void *mem, int stride, int h);
void av_cold ff_dsputil_init_armv5te(DSPContext* c, AVCodecContext *avctx) void av_cold ff_dsputil_init_armv5te(DSPContext* c, AVCodecContext *avctx)
{ {
if (!avctx->lowres && (avctx->idct_algo == FF_IDCT_AUTO || if (!avctx->lowres && avctx->bits_per_raw_sample <= 8 &&
avctx->idct_algo == FF_IDCT_SIMPLEARMV5TE)) { (avctx->idct_algo == FF_IDCT_AUTO ||
avctx->idct_algo == FF_IDCT_SIMPLEARMV5TE)) {
c->idct_put = ff_simple_idct_put_armv5te; c->idct_put = ff_simple_idct_put_armv5te;
c->idct_add = ff_simple_idct_add_armv5te; c->idct_add = ff_simple_idct_add_armv5te;
c->idct = ff_simple_idct_armv5te; c->idct = ff_simple_idct_armv5te;

@ -74,8 +74,9 @@ void av_cold ff_dsputil_init_armv6(DSPContext* c, AVCodecContext *avctx)
{ {
const int high_bit_depth = avctx->codec_id == CODEC_ID_H264 && avctx->bits_per_raw_sample > 8; const int high_bit_depth = avctx->codec_id == CODEC_ID_H264 && avctx->bits_per_raw_sample > 8;
if (!avctx->lowres && (avctx->idct_algo == FF_IDCT_AUTO || if (!avctx->lowres && avctx->bits_per_raw_sample <= 8 &&
avctx->idct_algo == FF_IDCT_SIMPLEARMV6)) { (avctx->idct_algo == FF_IDCT_AUTO ||
avctx->idct_algo == FF_IDCT_SIMPLEARMV6)) {
c->idct_put = ff_simple_idct_put_armv6; c->idct_put = ff_simple_idct_put_armv6;
c->idct_add = ff_simple_idct_add_armv6; c->idct_add = ff_simple_idct_add_armv6;
c->idct = ff_simple_idct_armv6; c->idct = ff_simple_idct_armv6;

@ -177,7 +177,7 @@ void ff_dsputil_init_neon(DSPContext *c, AVCodecContext *avctx)
{ {
const int high_bit_depth = avctx->codec_id == CODEC_ID_H264 && avctx->bits_per_raw_sample > 8; const int high_bit_depth = avctx->codec_id == CODEC_ID_H264 && avctx->bits_per_raw_sample > 8;
if (!avctx->lowres) { if (!avctx->lowres && avctx->bits_per_raw_sample <= 8) {
if (avctx->idct_algo == FF_IDCT_AUTO || if (avctx->idct_algo == FF_IDCT_AUTO ||
avctx->idct_algo == FF_IDCT_SIMPLENEON) { avctx->idct_algo == FF_IDCT_SIMPLENEON) {
c->idct_put = ff_simple_idct_put_neon; c->idct_put = ff_simple_idct_put_neon;

@ -256,16 +256,18 @@ void dsputil_init_bfin( DSPContext* c, AVCodecContext *avctx )
if (avctx->dct_algo == FF_DCT_AUTO) if (avctx->dct_algo == FF_DCT_AUTO)
c->fdct = ff_bfin_fdct; c->fdct = ff_bfin_fdct;
if (avctx->idct_algo==FF_IDCT_VP3) { if (avctx->bits_per_raw_sample <= 8) {
c->idct_permutation_type = FF_NO_IDCT_PERM; if (avctx->idct_algo == FF_IDCT_VP3) {
c->idct = ff_bfin_vp3_idct; c->idct_permutation_type = FF_NO_IDCT_PERM;
c->idct_add = ff_bfin_vp3_idct_add; c->idct = ff_bfin_vp3_idct;
c->idct_put = ff_bfin_vp3_idct_put; c->idct_add = ff_bfin_vp3_idct_add;
} else if (avctx->idct_algo == FF_IDCT_AUTO) { c->idct_put = ff_bfin_vp3_idct_put;
c->idct_permutation_type = FF_NO_IDCT_PERM; } else if (avctx->idct_algo == FF_IDCT_AUTO) {
c->idct = ff_bfin_idct; c->idct_permutation_type = FF_NO_IDCT_PERM;
c->idct_add = bfin_idct_add; c->idct = ff_bfin_idct;
c->idct_put = bfin_idct_put; c->idct_add = bfin_idct_add;
c->idct_put = bfin_idct_put;
}
} }
} }

@ -27,82 +27,6 @@
#include "avcodec.h" #include "avcodec.h"
#include "celp_math.h" #include "celp_math.h"
#ifdef G729_BITEXACT
/**
* Cosine table: base_cos[i] = (1<<15) * cos(i*PI/64)
*/
static const int16_t base_cos[64] =
{
32767, 32729, 32610, 32413, 32138, 31786, 31357, 30853,
30274, 29622, 28899, 28106, 27246, 26320, 25330, 24279,
23170, 22006, 20788, 19520, 18205, 16846, 15447, 14010,
12540, 11039, 9512, 7962, 6393, 4808, 3212, 1608,
0, -1608, -3212, -4808, -6393, -7962, -9512, -11039,
-12540, -14010, -15447, -16846, -18205, -19520, -20788, -22006,
-23170, -24279, -25330, -26320, -27246, -28106, -28899, -29622,
-30274, -30853, -31357, -31786, -32138, -32413, -32610, -32729
};
/**
* Slope used to compute cos(x)
*
* cos(ind*64+offset) = base_cos[ind]+offset*slope_cos[ind]
* values multiplied by 1<<19
*/
static const int16_t slope_cos[64] =
{
-632, -1893, -3150, -4399, -5638, -6863, -8072, -9261,
-10428, -11570, -12684, -13767, -14817, -15832, -16808, -17744,
-18637, -19486, -20287, -21039, -21741, -22390, -22986, -23526,
-24009, -24435, -24801, -25108, -25354, -25540, -25664, -25726,
-25726, -25664, -25540, -25354, -25108, -24801, -24435, -24009,
-23526, -22986, -22390, -21741, -21039, -20287, -19486, -18637,
-17744, -16808, -15832, -14817, -13767, -12684, -11570, -10428,
-9261, -8072, -6863, -5638, -4399, -3150, -1893, -632
};
/**
* Table used to compute exp2(x)
*
* tab_exp2[i] = (1<<14) * exp2(i/32) = 2^(i/32) i=0..32
*/
static const uint16_t tab_exp2[33] =
{
16384, 16743, 17109, 17484, 17867, 18258, 18658, 19066, 19484, 19911,
20347, 20792, 21247, 21713, 22188, 22674, 23170, 23678, 24196, 24726,
25268, 25821, 26386, 26964, 27554, 28158, 28774, 29405, 30048, 30706,
31379, 32066, 32767
};
int16_t ff_cos(uint16_t arg)
{
uint8_t offset= arg;
uint8_t ind = arg >> 8;
assert(arg < 0x4000);
return FFMAX(base_cos[ind] + ((slope_cos[ind] * offset) >> 12), -0x8000);
}
int ff_exp2(uint16_t power)
{
uint16_t frac_x0;
uint16_t frac_dx;
int result;
assert(power <= 0x7fff);
frac_x0 = power >> 10;
frac_dx = (power & 0x03ff) << 5;
result = tab_exp2[frac_x0] << 15;
result += frac_dx * (tab_exp2[frac_x0+1] - tab_exp2[frac_x0]);
return result >> 10;
}
#else // G729_BITEXACT
/** /**
* Cosine table: base_cos[i] = (1<<15) * cos(i*PI/64) * Cosine table: base_cos[i] = (1<<15) * cos(i*PI/64)
*/ */
@ -154,8 +78,6 @@ int ff_exp2(uint16_t power)
return result + ((result*(power&31)*89)>>22); return result + ((result*(power&31)*89)>>22);
} }
#endif // else G729_BITEXACT
/** /**
* Table used to compute log2(x) * Table used to compute log2(x)
* *
@ -163,17 +85,10 @@ int ff_exp2(uint16_t power)
*/ */
static const uint16_t tab_log2[33] = static const uint16_t tab_log2[33] =
{ {
#ifdef G729_BITEXACT
0, 1455, 2866, 4236, 5568, 6863, 8124, 9352,
10549, 11716, 12855, 13967, 15054, 16117, 17156, 18172,
19167, 20142, 21097, 22033, 22951, 23852, 24735, 25603,
26455, 27291, 28113, 28922, 29716, 30497, 31266, 32023, 32767,
#else
4, 1459, 2870, 4240, 5572, 6867, 8127, 9355, 4, 1459, 2870, 4240, 5572, 6867, 8127, 9355,
10552, 11719, 12858, 13971, 15057, 16120, 17158, 18175, 10552, 11719, 12858, 13971, 15057, 16120, 17158, 18175,
19170, 20145, 21100, 22036, 22954, 23854, 24738, 25605, 19170, 20145, 21100, 22036, 22954, 23854, 24738, 25605,
26457, 27294, 28116, 28924, 29719, 30500, 31269, 32025, 32769, 26457, 27294, 28116, 28924, 29719, 30500, 31269, 32025, 32769,
#endif
}; };
int ff_log2(uint32_t value) int ff_log2(uint32_t value)

@ -111,7 +111,7 @@ static const struct algo idct_tab[] = {
{ "FAANI", ff_faanidct, NO_PERM }, { "FAANI", ff_faanidct, NO_PERM },
{ "REF-DBL", ff_ref_idct, NO_PERM }, { "REF-DBL", ff_ref_idct, NO_PERM },
{ "INT", j_rev_dct, MMX_PERM }, { "INT", j_rev_dct, MMX_PERM },
{ "SIMPLE-C", ff_simple_idct, NO_PERM }, { "SIMPLE-C", ff_simple_idct_8, NO_PERM },
#if HAVE_MMX #if HAVE_MMX
#if CONFIG_GPL #if CONFIG_GPL

@ -41,7 +41,7 @@ static const AVClass class = { "dnxhd", av_default_item_name, options, LIBAVUTIL
#define LAMBDA_FRAC_BITS 10 #define LAMBDA_FRAC_BITS 10
static av_always_inline void dnxhd_get_pixels_8x4(DCTELEM *restrict block, const uint8_t *pixels, int line_size) static void dnxhd_get_pixels_8x4(DCTELEM *restrict block, const uint8_t *pixels, int line_size)
{ {
int i; int i;
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
@ -52,10 +52,10 @@ static av_always_inline void dnxhd_get_pixels_8x4(DCTELEM *restrict block, const
pixels += line_size; pixels += line_size;
block += 8; block += 8;
} }
memcpy(block , block- 8, sizeof(*block)*8); memcpy(block, block - 8, sizeof(*block) * 8);
memcpy(block+ 8, block-16, sizeof(*block)*8); memcpy(block + 8, block - 16, sizeof(*block) * 8);
memcpy(block+16, block-24, sizeof(*block)*8); memcpy(block + 16, block - 24, sizeof(*block) * 8);
memcpy(block+24, block-32, sizeof(*block)*8); memcpy(block + 24, block - 32, sizeof(*block) * 8);
} }
static int dnxhd_init_vlc(DNXHDEncContext *ctx) static int dnxhd_init_vlc(DNXHDEncContext *ctx)
@ -64,9 +64,9 @@ static int dnxhd_init_vlc(DNXHDEncContext *ctx)
int max_level = 1<<(ctx->cid_table->bit_depth+2); int max_level = 1<<(ctx->cid_table->bit_depth+2);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_codes, max_level*4*sizeof(*ctx->vlc_codes), fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_codes, max_level*4*sizeof(*ctx->vlc_codes), fail);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_bits , max_level*4*sizeof(*ctx->vlc_bits ), fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_bits, max_level*4*sizeof(*ctx->vlc_bits) , fail);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_codes, 63*2 , fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_codes, 63*2, fail);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_bits , 63 , fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_bits, 63, fail);
ctx->vlc_codes += max_level*2; ctx->vlc_codes += max_level*2;
ctx->vlc_bits += max_level*2; ctx->vlc_bits += max_level*2;
@ -119,8 +119,8 @@ static int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
uint16_t weight_matrix[64] = {1,}; // convert_matrix needs uint16_t* uint16_t weight_matrix[64] = {1,}; // convert_matrix needs uint16_t*
int qscale, i; int qscale, i;
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l, (ctx->m.avctx->qmax+1) * 64 * sizeof(int) , fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l, (ctx->m.avctx->qmax+1) * 64 * sizeof(int), fail);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c, (ctx->m.avctx->qmax+1) * 64 * sizeof(int) , fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c, (ctx->m.avctx->qmax+1) * 64 * sizeof(int), fail);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l16, (ctx->m.avctx->qmax+1) * 64 * 2 * sizeof(uint16_t), fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l16, (ctx->m.avctx->qmax+1) * 64 * 2 * sizeof(uint16_t), fail);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c16, (ctx->m.avctx->qmax+1) * 64 * 2 * sizeof(uint16_t), fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c16, (ctx->m.avctx->qmax+1) * 64 * 2 * sizeof(uint16_t), fail);
@ -218,7 +218,7 @@ static int dnxhd_encode_init(AVCodecContext *avctx)
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_size, ctx->m.mb_height*sizeof(uint32_t), fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_size, ctx->m.mb_height*sizeof(uint32_t), fail);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_offs, ctx->m.mb_height*sizeof(uint32_t), fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_offs, ctx->m.mb_height*sizeof(uint32_t), fail);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_bits, ctx->m.mb_num *sizeof(uint16_t), fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_bits, ctx->m.mb_num *sizeof(uint16_t), fail);
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_qscale, ctx->m.mb_num *sizeof(uint8_t) , fail); FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_qscale, ctx->m.mb_num *sizeof(uint8_t), fail);
ctx->frame.key_frame = 1; ctx->frame.key_frame = 1;
ctx->frame.pict_type = AV_PICTURE_TYPE_I; ctx->frame.pict_type = AV_PICTURE_TYPE_I;
@ -341,7 +341,7 @@ static av_always_inline int dnxhd_ssd_block(DCTELEM *qblock, DCTELEM *block)
int score = 0; int score = 0;
int i; int i;
for (i = 0; i < 64; i++) for (i = 0; i < 64; i++)
score += (block[i]-qblock[i])*(block[i]-qblock[i]); score += (block[i] - qblock[i]) * (block[i] - qblock[i]);
return score; return score;
} }
@ -369,26 +369,28 @@ static av_always_inline void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, in
const uint8_t *ptr_v = ctx->thread[0]->src[2] + ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << 3); const uint8_t *ptr_v = ctx->thread[0]->src[2] + ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << 3);
DSPContext *dsp = &ctx->m.dsp; DSPContext *dsp = &ctx->m.dsp;
dsp->get_pixels(ctx->blocks[0], ptr_y , ctx->m.linesize); dsp->get_pixels(ctx->blocks[0], ptr_y, ctx->m.linesize);
dsp->get_pixels(ctx->blocks[1], ptr_y + 8, ctx->m.linesize); dsp->get_pixels(ctx->blocks[1], ptr_y + 8, ctx->m.linesize);
dsp->get_pixels(ctx->blocks[2], ptr_u , ctx->m.uvlinesize); dsp->get_pixels(ctx->blocks[2], ptr_u, ctx->m.uvlinesize);
dsp->get_pixels(ctx->blocks[3], ptr_v , ctx->m.uvlinesize); dsp->get_pixels(ctx->blocks[3], ptr_v, ctx->m.uvlinesize);
if (mb_y+1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) { if (mb_y+1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) {
if (ctx->interlaced) { if (ctx->interlaced) {
ctx->get_pixels_8x4_sym(ctx->blocks[4], ptr_y + ctx->dct_y_offset , ctx->m.linesize); ctx->get_pixels_8x4_sym(ctx->blocks[4], ptr_y + ctx->dct_y_offset, ctx->m.linesize);
ctx->get_pixels_8x4_sym(ctx->blocks[5], ptr_y + ctx->dct_y_offset + 8, ctx->m.linesize); ctx->get_pixels_8x4_sym(ctx->blocks[5], ptr_y + ctx->dct_y_offset + 8, ctx->m.linesize);
ctx->get_pixels_8x4_sym(ctx->blocks[6], ptr_u + ctx->dct_uv_offset , ctx->m.uvlinesize); ctx->get_pixels_8x4_sym(ctx->blocks[6], ptr_u + ctx->dct_uv_offset, ctx->m.uvlinesize);
ctx->get_pixels_8x4_sym(ctx->blocks[7], ptr_v + ctx->dct_uv_offset , ctx->m.uvlinesize); ctx->get_pixels_8x4_sym(ctx->blocks[7], ptr_v + ctx->dct_uv_offset, ctx->m.uvlinesize);
} else { } else {
dsp->clear_block(ctx->blocks[4]); dsp->clear_block(ctx->blocks[5]); dsp->clear_block(ctx->blocks[4]);
dsp->clear_block(ctx->blocks[6]); dsp->clear_block(ctx->blocks[7]); dsp->clear_block(ctx->blocks[5]);
dsp->clear_block(ctx->blocks[6]);
dsp->clear_block(ctx->blocks[7]);
} }
} else { } else {
dsp->get_pixels(ctx->blocks[4], ptr_y + ctx->dct_y_offset , ctx->m.linesize); dsp->get_pixels(ctx->blocks[4], ptr_y + ctx->dct_y_offset, ctx->m.linesize);
dsp->get_pixels(ctx->blocks[5], ptr_y + ctx->dct_y_offset + 8, ctx->m.linesize); dsp->get_pixels(ctx->blocks[5], ptr_y + ctx->dct_y_offset + 8, ctx->m.linesize);
dsp->get_pixels(ctx->blocks[6], ptr_u + ctx->dct_uv_offset , ctx->m.uvlinesize); dsp->get_pixels(ctx->blocks[6], ptr_u + ctx->dct_uv_offset, ctx->m.uvlinesize);
dsp->get_pixels(ctx->blocks[7], ptr_v + ctx->dct_uv_offset , ctx->m.uvlinesize); dsp->get_pixels(ctx->blocks[7], ptr_v + ctx->dct_uv_offset, ctx->m.uvlinesize);
} }
} }
@ -496,14 +498,14 @@ static void dnxhd_setup_threads_slices(DNXHDEncContext *ctx)
for (mb_y = 0; mb_y < ctx->m.mb_height; mb_y++) { for (mb_y = 0; mb_y < ctx->m.mb_height; mb_y++) {
int thread_size; int thread_size;
ctx->slice_offs[mb_y] = offset; ctx->slice_offs[mb_y] = offset;
ctx->slice_size[mb_y] = 0; ctx->slice_size[mb_y] = 0;
for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) { for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
unsigned mb = mb_y * ctx->m.mb_width + mb_x; unsigned mb = mb_y * ctx->m.mb_width + mb_x;
ctx->slice_size[mb_y] += ctx->mb_bits[mb]; ctx->slice_size[mb_y] += ctx->mb_bits[mb];
} }
ctx->slice_size[mb_y] = (ctx->slice_size[mb_y]+31)&~31; ctx->slice_size[mb_y] = (ctx->slice_size[mb_y]+31)&~31;
ctx->slice_size[mb_y] >>= 3; ctx->slice_size[mb_y] >>= 3;
thread_size = ctx->slice_size[mb_y]; thread_size = ctx->slice_size[mb_y];
offset += thread_size; offset += thread_size;
} }
} }

@ -184,7 +184,7 @@ static int pix_norm1_c(uint8_t * pix, int line_size)
s += sq[pix[6]]; s += sq[pix[6]];
s += sq[pix[7]]; s += sq[pix[7]];
#else #else
#if LONG_MAX > 2147483647 #if HAVE_FAST_64BIT
register uint64_t x=*(uint64_t*)pix; register uint64_t x=*(uint64_t*)pix;
s += sq[x&0xff]; s += sq[x&0xff];
s += sq[(x>>8)&0xff]; s += sq[(x>>8)&0xff];
@ -2225,7 +2225,7 @@ static int quant_psnr8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *s
s->block_last_index[0/*FIXME*/]= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i); s->block_last_index[0/*FIXME*/]= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
s->dct_unquantize_inter(s, temp, 0, s->qscale); s->dct_unquantize_inter(s, temp, 0, s->qscale);
ff_simple_idct(temp); //FIXME ff_simple_idct_8(temp); //FIXME
for(i=0; i<64; i++) for(i=0; i<64; i++)
sum+= (temp[i]-bak[i])*(temp[i]-bak[i]); sum+= (temp[i]-bak[i])*(temp[i]-bak[i]);
@ -2866,6 +2866,12 @@ av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx)
c->idct = j_rev_dct1; c->idct = j_rev_dct1;
c->idct_permutation_type= FF_NO_IDCT_PERM; c->idct_permutation_type= FF_NO_IDCT_PERM;
}else{ }else{
if (avctx->bits_per_raw_sample == 10) {
c->idct_put = ff_simple_idct_put_10;
c->idct_add = ff_simple_idct_add_10;
c->idct = ff_simple_idct_10;
c->idct_permutation_type = FF_NO_IDCT_PERM;
} else {
if(avctx->idct_algo==FF_IDCT_INT){ if(avctx->idct_algo==FF_IDCT_INT){
c->idct_put= ff_jref_idct_put; c->idct_put= ff_jref_idct_put;
c->idct_add= ff_jref_idct_add; c->idct_add= ff_jref_idct_add;
@ -2896,11 +2902,12 @@ av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx)
c->idct_put = ff_bink_idct_put_c; c->idct_put = ff_bink_idct_put_c;
c->idct_permutation_type = FF_NO_IDCT_PERM; c->idct_permutation_type = FF_NO_IDCT_PERM;
}else{ //accurate/default }else{ //accurate/default
c->idct_put= ff_simple_idct_put; c->idct_put = ff_simple_idct_put_8;
c->idct_add= ff_simple_idct_add; c->idct_add = ff_simple_idct_add_8;
c->idct = ff_simple_idct; c->idct = ff_simple_idct_8;
c->idct_permutation_type= FF_NO_IDCT_PERM; c->idct_permutation_type= FF_NO_IDCT_PERM;
} }
}
} }
c->get_pixels = get_pixels_c; c->get_pixels = get_pixels_c;
@ -3169,21 +3176,18 @@ av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx)
dspfunc2(avg_h264_qpel, 1, 8, depth);\ dspfunc2(avg_h264_qpel, 1, 8, depth);\
dspfunc2(avg_h264_qpel, 2, 4, depth); dspfunc2(avg_h264_qpel, 2, 4, depth);
if (avctx->codec_id != CODEC_ID_H264 || avctx->bits_per_raw_sample == 8) { switch (avctx->bits_per_raw_sample) {
BIT_DEPTH_FUNCS(8) case 9:
} else { BIT_DEPTH_FUNCS(9);
switch (avctx->bits_per_raw_sample) { break;
case 9: case 10:
BIT_DEPTH_FUNCS(9) BIT_DEPTH_FUNCS(10);
break; break;
case 10: default:
BIT_DEPTH_FUNCS(10) av_log(avctx, AV_LOG_DEBUG, "Unsupported bit depth: %d\n", avctx->bits_per_raw_sample);
break; case 8:
default: BIT_DEPTH_FUNCS(8);
av_log(avctx, AV_LOG_DEBUG, "Unsupported bit depth: %d\n", avctx->bits_per_raw_sample); break;
BIT_DEPTH_FUNCS(8)
break;
}
} }
@ -3243,4 +3247,3 @@ av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx)
av_log(avctx, AV_LOG_ERROR, "Internal error, IDCT permutation not set\n"); av_log(avctx, AV_LOG_ERROR, "Internal error, IDCT permutation not set\n");
} }
} }

@ -230,150 +230,6 @@ static void FUNCC(add_pixels4)(uint8_t *restrict p_pixels, DCTELEM *p_block, int
} }
} }
#if 0
#define PIXOP2(OPNAME, OP) \
static void OPNAME ## _pixels(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
{\
int i;\
for(i=0; i<h; i++){\
OP(*((uint64_t*)block), AV_RN64(pixels));\
pixels+=line_size;\
block +=line_size;\
}\
}\
\
static void OPNAME ## _no_rnd_pixels_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
{\
int i;\
for(i=0; i<h; i++){\
const uint64_t a= AV_RN64(pixels );\
const uint64_t b= AV_RN64(pixels+1);\
OP(*((uint64_t*)block), (a&b) + (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
pixels+=line_size;\
block +=line_size;\
}\
}\
\
static void OPNAME ## _pixels_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
{\
int i;\
for(i=0; i<h; i++){\
const uint64_t a= AV_RN64(pixels );\
const uint64_t b= AV_RN64(pixels+1);\
OP(*((uint64_t*)block), (a|b) - (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
pixels+=line_size;\
block +=line_size;\
}\
}\
\
static void OPNAME ## _no_rnd_pixels_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
{\
int i;\
for(i=0; i<h; i++){\
const uint64_t a= AV_RN64(pixels );\
const uint64_t b= AV_RN64(pixels+line_size);\
OP(*((uint64_t*)block), (a&b) + (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
pixels+=line_size;\
block +=line_size;\
}\
}\
\
static void OPNAME ## _pixels_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
{\
int i;\
for(i=0; i<h; i++){\
const uint64_t a= AV_RN64(pixels );\
const uint64_t b= AV_RN64(pixels+line_size);\
OP(*((uint64_t*)block), (a|b) - (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
pixels+=line_size;\
block +=line_size;\
}\
}\
\
static void OPNAME ## _pixels_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
{\
int i;\
const uint64_t a= AV_RN64(pixels );\
const uint64_t b= AV_RN64(pixels+1);\
uint64_t l0= (a&0x0303030303030303ULL)\
+ (b&0x0303030303030303ULL)\
+ 0x0202020202020202ULL;\
uint64_t h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
+ ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
uint64_t l1,h1;\
\
pixels+=line_size;\
for(i=0; i<h; i+=2){\
uint64_t a= AV_RN64(pixels );\
uint64_t b= AV_RN64(pixels+1);\
l1= (a&0x0303030303030303ULL)\
+ (b&0x0303030303030303ULL);\
h1= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
+ ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
pixels+=line_size;\
block +=line_size;\
a= AV_RN64(pixels );\
b= AV_RN64(pixels+1);\
l0= (a&0x0303030303030303ULL)\
+ (b&0x0303030303030303ULL)\
+ 0x0202020202020202ULL;\
h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
+ ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
pixels+=line_size;\
block +=line_size;\
}\
}\
\
static void OPNAME ## _no_rnd_pixels_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
{\
int i;\
const uint64_t a= AV_RN64(pixels );\
const uint64_t b= AV_RN64(pixels+1);\
uint64_t l0= (a&0x0303030303030303ULL)\
+ (b&0x0303030303030303ULL)\
+ 0x0101010101010101ULL;\
uint64_t h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
+ ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
uint64_t l1,h1;\
\
pixels+=line_size;\
for(i=0; i<h; i+=2){\
uint64_t a= AV_RN64(pixels );\
uint64_t b= AV_RN64(pixels+1);\
l1= (a&0x0303030303030303ULL)\
+ (b&0x0303030303030303ULL);\
h1= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
+ ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
pixels+=line_size;\
block +=line_size;\
a= AV_RN64(pixels );\
b= AV_RN64(pixels+1);\
l0= (a&0x0303030303030303ULL)\
+ (b&0x0303030303030303ULL)\
+ 0x0101010101010101ULL;\
h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
+ ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
pixels+=line_size;\
block +=line_size;\
}\
}\
\
CALL_2X_PIXELS(OPNAME ## _pixels16_c , OPNAME ## _pixels_c , 8*sizeof(pixel))\
CALL_2X_PIXELS(OPNAME ## _pixels16_x2_c , OPNAME ## _pixels_x2_c , 8*sizeof(pixel))\
CALL_2X_PIXELS(OPNAME ## _pixels16_y2_c , OPNAME ## _pixels_y2_c , 8*sizeof(pixel))\
CALL_2X_PIXELS(OPNAME ## _pixels16_xy2_c, OPNAME ## _pixels_xy2_c, 8*sizeof(pixel))\
CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_x2_c , OPNAME ## _no_rnd_pixels_x2_c , 8*sizeof(pixel))\
CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_y2_c , OPNAME ## _no_rnd_pixels_y2_c , 8*sizeof(pixel))\
CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_xy2_c, OPNAME ## _no_rnd_pixels_xy2_c, 8*sizeof(pixel))
#define op_avg(a, b) a = ( ((a)|(b)) - ((((a)^(b))&0xFEFEFEFEFEFEFEFEULL)>>1) )
#else // 64 bit variant
#define PIXOP2(OPNAME, OP) \ #define PIXOP2(OPNAME, OP) \
static void FUNCC(OPNAME ## _pixels2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\ static void FUNCC(OPNAME ## _pixels2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
int i;\ int i;\
@ -749,7 +605,6 @@ CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_y2) , FUNCC(OPNAME ## _no_rnd_pi
CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_xy2), FUNCC(OPNAME ## _no_rnd_pixels8_xy2), 8*sizeof(pixel))\ CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_xy2), FUNCC(OPNAME ## _no_rnd_pixels8_xy2), 8*sizeof(pixel))\
#define op_avg(a, b) a = rnd_avg_pixel4(a, b) #define op_avg(a, b) a = rnd_avg_pixel4(a, b)
#endif
#define op_put(a, b) a = b #define op_put(a, b) a = b
PIXOP2(avg, op_avg) PIXOP2(avg, op_avg)

@ -1,278 +0,0 @@
/*
* data for G.729 decoder
* Copyright (c) 2007 Vladimir Voroshilov
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVCODEC_G729DATA_H
#define AVCODEC_G729DATA_H
#include <stdint.h>
#define MA_NP 4 ///< Moving Average (MA) prediction order
#define VQ_1ST_BITS 7 ///< first stage vector of quantizer (size in bits)
#define VQ_2ND_BITS 5 ///< second stage vector of quantizer (size in bits)
#define GC_1ST_IDX_BITS_8K 3 ///< gain codebook (first stage) index, 8k mode (size in bits)
#define GC_2ND_IDX_BITS_8K 4 ///< gain codebook (second stage) index, 8k mode (size in bits)
#define GC_1ST_IDX_BITS_6K4 3 ///< gain codebook (first stage) index, 6.4k mode (size in bits)
#define GC_2ND_IDX_BITS_6K4 3 ///< gain codebook (second stage) index, 6.4k mode (size in bits)
/**
* first stage LSP codebook
* (10-dimensional, with 128 entries (3.24 of G.729)
*/
static const int16_t cb_lsp_1st[1<<VQ_1ST_BITS][10] = { /* (2.13) */
{ 1486, 2168, 3751, 9074, 12134, 13944, 17983, 19173, 21190, 21820},
{ 1730, 2640, 3450, 4870, 6126, 7876, 15644, 17817, 20294, 21902},
{ 1568, 2256, 3088, 4874, 11063, 13393, 18307, 19293, 21109, 21741},
{ 1733, 2512, 3357, 4708, 6977, 10296, 17024, 17956, 19145, 20350},
{ 1744, 2436, 3308, 8731, 10432, 12007, 15614, 16639, 21359, 21913},
{ 1786, 2369, 3372, 4521, 6795, 12963, 17674, 18988, 20855, 21640},
{ 1631, 2433, 3361, 6328, 10709, 12013, 13277, 13904, 19441, 21088},
{ 1489, 2364, 3291, 6250, 9227, 10403, 13843, 15278, 17721, 21451},
{ 1869, 2533, 3475, 4365, 9152, 14513, 15908, 17022, 20611, 21411},
{ 2070, 3025, 4333, 5854, 7805, 9231, 10597, 16047, 20109, 21834},
{ 1910, 2673, 3419, 4261, 11168, 15111, 16577, 17591, 19310, 20265},
{ 1141, 1815, 2624, 4623, 6495, 9588, 13968, 16428, 19351, 21286},
{ 2192, 3171, 4707, 5808, 10904, 12500, 14162, 15664, 21124, 21789},
{ 1286, 1907, 2548, 3453, 9574, 11964, 15978, 17344, 19691, 22495},
{ 1921, 2720, 4604, 6684, 11503, 12992, 14350, 15262, 16997, 20791},
{ 2052, 2759, 3897, 5246, 6638, 10267, 15834, 16814, 18149, 21675},
{ 1798, 2497, 5617, 11449, 13189, 14711, 17050, 18195, 20307, 21182},
{ 1009, 1647, 2889, 5709, 9541, 12354, 15231, 18494, 20966, 22033},
{ 3016, 3794, 5406, 7469, 12488, 13984, 15328, 16334, 19952, 20791},
{ 2203, 3040, 3796, 5442, 11987, 13512, 14931, 16370, 17856, 18803},
{ 2912, 4292, 7988, 9572, 11562, 13244, 14556, 16529, 20004, 21073},
{ 2861, 3607, 5923, 7034, 9234, 12054, 13729, 18056, 20262, 20974},
{ 3069, 4311, 5967, 7367, 11482, 12699, 14309, 16233, 18333, 19172},
{ 2434, 3661, 4866, 5798, 10383, 11722, 13049, 15668, 18862, 19831},
{ 2020, 2605, 3860, 9241, 13275, 14644, 16010, 17099, 19268, 20251},
{ 1877, 2809, 3590, 4707, 11056, 12441, 15622, 17168, 18761, 19907},
{ 2107, 2873, 3673, 5799, 13579, 14687, 15938, 17077, 18890, 19831},
{ 1612, 2284, 2944, 3572, 8219, 13959, 15924, 17239, 18592, 20117},
{ 2420, 3156, 6542, 10215, 12061, 13534, 15305, 16452, 18717, 19880},
{ 1667, 2612, 3534, 5237, 10513, 11696, 12940, 16798, 18058, 19378},
{ 2388, 3017, 4839, 9333, 11413, 12730, 15024, 16248, 17449, 18677},
{ 1875, 2786, 4231, 6320, 8694, 10149, 11785, 17013, 18608, 19960},
{ 679, 1411, 4654, 8006, 11446, 13249, 15763, 18127, 20361, 21567},
{ 1838, 2596, 3578, 4608, 5650, 11274, 14355, 15886, 20579, 21754},
{ 1303, 1955, 2395, 3322, 12023, 13764, 15883, 18077, 20180, 21232},
{ 1438, 2102, 2663, 3462, 8328, 10362, 13763, 17248, 19732, 22344},
{ 860, 1904, 6098, 7775, 9815, 12007, 14821, 16709, 19787, 21132},
{ 1673, 2723, 3704, 6125, 7668, 9447, 13683, 14443, 20538, 21731},
{ 1246, 1849, 2902, 4508, 7221, 12710, 14835, 16314, 19335, 22720},
{ 1525, 2260, 3862, 5659, 7342, 11748, 13370, 14442, 18044, 21334},
{ 1196, 1846, 3104, 7063, 10972, 12905, 14814, 17037, 19922, 22636},
{ 2147, 3106, 4475, 6511, 8227, 9765, 10984, 12161, 18971, 21300},
{ 1585, 2405, 2994, 4036, 11481, 13177, 14519, 15431, 19967, 21275},
{ 1778, 2688, 3614, 4680, 9465, 11064, 12473, 16320, 19742, 20800},
{ 1862, 2586, 3492, 6719, 11708, 13012, 14364, 16128, 19610, 20425},
{ 1395, 2156, 2669, 3386, 10607, 12125, 13614, 16705, 18976, 21367},
{ 1444, 2117, 3286, 6233, 9423, 12981, 14998, 15853, 17188, 21857},
{ 2004, 2895, 3783, 4897, 6168, 7297, 12609, 16445, 19297, 21465},
{ 1495, 2863, 6360, 8100, 11399, 14271, 15902, 17711, 20479, 22061},
{ 2484, 3114, 5718, 7097, 8400, 12616, 14073, 14847, 20535, 21396},
{ 2424, 3277, 5296, 6284, 11290, 12903, 16022, 17508, 19333, 20283},
{ 2565, 3778, 5360, 6989, 8782, 10428, 14390, 15742, 17770, 21734},
{ 2727, 3384, 6613, 9254, 10542, 12236, 14651, 15687, 20074, 21102},
{ 1916, 2953, 6274, 8088, 9710, 10925, 12392, 16434, 20010, 21183},
{ 3384, 4366, 5349, 7667, 11180, 12605, 13921, 15324, 19901, 20754},
{ 3075, 4283, 5951, 7619, 9604, 11010, 12384, 14006, 20658, 21497},
{ 1751, 2455, 5147, 9966, 11621, 13176, 14739, 16470, 20788, 21756},
{ 1442, 2188, 3330, 6813, 8929, 12135, 14476, 15306, 19635, 20544},
{ 2294, 2895, 4070, 8035, 12233, 13416, 14762, 17367, 18952, 19688},
{ 1937, 2659, 4602, 6697, 9071, 12863, 14197, 15230, 16047, 18877},
{ 2071, 2663, 4216, 9445, 10887, 12292, 13949, 14909, 19236, 20341},
{ 1740, 2491, 3488, 8138, 9656, 11153, 13206, 14688, 20896, 21907},
{ 2199, 2881, 4675, 8527, 10051, 11408, 14435, 15463, 17190, 20597},
{ 1943, 2988, 4177, 6039, 7478, 8536, 14181, 15551, 17622, 21579},
{ 1825, 3175, 7062, 9818, 12824, 15450, 18330, 19856, 21830, 22412},
{ 2464, 3046, 4822, 5977, 7696, 15398, 16730, 17646, 20588, 21320},
{ 2550, 3393, 5305, 6920, 10235, 14083, 18143, 19195, 20681, 21336},
{ 3003, 3799, 5321, 6437, 7919, 11643, 15810, 16846, 18119, 18980},
{ 3455, 4157, 6838, 8199, 9877, 12314, 15905, 16826, 19949, 20892},
{ 3052, 3769, 4891, 5810, 6977, 10126, 14788, 15990, 19773, 20904},
{ 3671, 4356, 5827, 6997, 8460, 12084, 14154, 14939, 19247, 20423},
{ 2716, 3684, 5246, 6686, 8463, 10001, 12394, 14131, 16150, 19776},
{ 1945, 2638, 4130, 7995, 14338, 15576, 17057, 18206, 20225, 20997},
{ 2304, 2928, 4122, 4824, 5640, 13139, 15825, 16938, 20108, 21054},
{ 1800, 2516, 3350, 5219, 13406, 15948, 17618, 18540, 20531, 21252},
{ 1436, 2224, 2753, 4546, 9657, 11245, 15177, 16317, 17489, 19135},
{ 2319, 2899, 4980, 6936, 8404, 13489, 15554, 16281, 20270, 20911},
{ 2187, 2919, 4610, 5875, 7390, 12556, 14033, 16794, 20998, 21769},
{ 2235, 2923, 5121, 6259, 8099, 13589, 15340, 16340, 17927, 20159},
{ 1765, 2638, 3751, 5730, 7883, 10108, 13633, 15419, 16808, 18574},
{ 3460, 5741, 9596, 11742, 14413, 16080, 18173, 19090, 20845, 21601},
{ 3735, 4426, 6199, 7363, 9250, 14489, 16035, 17026, 19873, 20876},
{ 3521, 4778, 6887, 8680, 12717, 14322, 15950, 18050, 20166, 21145},
{ 2141, 2968, 6865, 8051, 10010, 13159, 14813, 15861, 17528, 18655},
{ 4148, 6128, 9028, 10871, 12686, 14005, 15976, 17208, 19587, 20595},
{ 4403, 5367, 6634, 8371, 10163, 11599, 14963, 16331, 17982, 18768},
{ 4091, 5386, 6852, 8770, 11563, 13290, 15728, 16930, 19056, 20102},
{ 2746, 3625, 5299, 7504, 10262, 11432, 13172, 15490, 16875, 17514},
{ 2248, 3556, 8539, 10590, 12665, 14696, 16515, 17824, 20268, 21247},
{ 1279, 1960, 3920, 7793, 10153, 14753, 16646, 18139, 20679, 21466},
{ 2440, 3475, 6737, 8654, 12190, 14588, 17119, 17925, 19110, 19979},
{ 1879, 2514, 4497, 7572, 10017, 14948, 16141, 16897, 18397, 19376},
{ 2804, 3688, 7490, 10086, 11218, 12711, 16307, 17470, 20077, 21126},
{ 2023, 2682, 3873, 8268, 10255, 11645, 15187, 17102, 18965, 19788},
{ 2823, 3605, 5815, 8595, 10085, 11469, 16568, 17462, 18754, 19876},
{ 2851, 3681, 5280, 7648, 9173, 10338, 14961, 16148, 17559, 18474},
{ 1348, 2645, 5826, 8785, 10620, 12831, 16255, 18319, 21133, 22586},
{ 2141, 3036, 4293, 6082, 7593, 10629, 17158, 18033, 21466, 22084},
{ 1608, 2375, 3384, 6878, 9970, 11227, 16928, 17650, 20185, 21120},
{ 2774, 3616, 5014, 6557, 7788, 8959, 17068, 18302, 19537, 20542},
{ 1934, 4813, 6204, 7212, 8979, 11665, 15989, 17811, 20426, 21703},
{ 2288, 3507, 5037, 6841, 8278, 9638, 15066, 16481, 21653, 22214},
{ 2951, 3771, 4878, 7578, 9016, 10298, 14490, 15242, 20223, 20990},
{ 3256, 4791, 6601, 7521, 8644, 9707, 13398, 16078, 19102, 20249},
{ 1827, 2614, 3486, 6039, 12149, 13823, 16191, 17282, 21423, 22041},
{ 1000, 1704, 3002, 6335, 8471, 10500, 14878, 16979, 20026, 22427},
{ 1646, 2286, 3109, 7245, 11493, 12791, 16824, 17667, 18981, 20222},
{ 1708, 2501, 3315, 6737, 8729, 9924, 16089, 17097, 18374, 19917},
{ 2623, 3510, 4478, 5645, 9862, 11115, 15219, 18067, 19583, 20382},
{ 2518, 3434, 4728, 6388, 8082, 9285, 13162, 18383, 19819, 20552},
{ 1726, 2383, 4090, 6303, 7805, 12845, 14612, 17608, 19269, 20181},
{ 2860, 3735, 4838, 6044, 7254, 8402, 14031, 16381, 18037, 19410},
{ 4247, 5993, 7952, 9792, 12342, 14653, 17527, 18774, 20831, 21699},
{ 3502, 4051, 5680, 6805, 8146, 11945, 16649, 17444, 20390, 21564},
{ 3151, 4893, 5899, 7198, 11418, 13073, 15124, 17673, 20520, 21861},
{ 3960, 4848, 5926, 7259, 8811, 10529, 15661, 16560, 18196, 20183},
{ 4499, 6604, 8036, 9251, 10804, 12627, 15880, 17512, 20020, 21046},
{ 4251, 5541, 6654, 8318, 9900, 11686, 15100, 17093, 20572, 21687},
{ 3769, 5327, 7865, 9360, 10684, 11818, 13660, 15366, 18733, 19882},
{ 3083, 3969, 6248, 8121, 9798, 10994, 12393, 13686, 17888, 19105},
{ 2731, 4670, 7063, 9201, 11346, 13735, 16875, 18797, 20787, 22360},
{ 1187, 2227, 4737, 7214, 9622, 12633, 15404, 17968, 20262, 23533},
{ 1911, 2477, 3915, 10098, 11616, 12955, 16223, 17138, 19270, 20729},
{ 1764, 2519, 3887, 6944, 9150, 12590, 16258, 16984, 17924, 18435},
{ 1400, 3674, 7131, 8718, 10688, 12508, 15708, 17711, 19720, 21068},
{ 2322, 3073, 4287, 8108, 9407, 10628, 15862, 16693, 19714, 21474},
{ 2630, 3339, 4758, 8360, 10274, 11333, 12880, 17374, 19221, 19936},
{ 1721, 2577, 5553, 7195, 8651, 10686, 15069, 16953, 18703, 19929}
};
/**
* second stage LSP codebook, high and low parts
(both 5-dimensional, with 32 entries (3.2.4 of G.729)
*/
static const int16_t cb_lsp_2nd[1<<VQ_2ND_BITS][10] = { /* (2.13) */
{ -435, -815, -742, 1033, -518, 582, -1201, 829, 86, 385},
{ -833, -891, 463, -8, -1251, 1450, 72, -231, 864, 661},
{-1021, 231, -306, 321, -220, -163, -526, -754, -1633, 267},
{ 57, -198, -339, -33, -1468, 573, 796, -169, -631, 816},
{ 171, -350, 294, 1660, 453, 519, 291, 159, -640, -1296},
{ -701, -842, -58, 950, 892, 1549, 715, 527, -714, -193},
{ 584, 31, -289, 356, -333, -457, 612, -283, -1381, -741},
{ -109, -808, 231, 77, -87, -344, 1341, 1087, -654, -569},
{ -859, 1236, 550, 854, 714, -543, -1752, -195, -98, -276},
{ -877, -954, -1248, -299, 212, -235, -728, 949, 1517, 895},
{ -77, 344, -620, 763, 413, 502, -362, -960, -483, 1386},
{ -314, -307, -256, -1260, -429, 450, -466, -108, 1010, 2223},
{ 711, 693, 521, 650, 1305, -28, -378, 744, -1005, 240},
{ -112, -271, -500, 946, 1733, 271, -15, 909, -259, 1688},
{ 575, -10, -468, -199, 1101, -1011, 581, -53, -747, 878},
{ 145, -285, -1280, -398, 36, -498, -1377, 18, -444, 1483},
{-1133, -835, 1350, 1284, -95, 1015, -222, 443, 372, -354},
{-1459, -1237, 416, -213, 466, 669, 659, 1640, 932, 534},
{ -15, 66, 468, 1019, -748, 1385, -182, -907, -721, -262},
{ -338, 148, 1445, 75, -760, 569, 1247, 337, 416, -121},
{ 389, 239, 1568, 981, 113, 369, -1003, -507, -587, -904},
{ -312, -98, 949, 31, 1104, 72, -141, 1465, 63, -785},
{ 1127, 584, 835, 277, -1159, 208, 301, -882, 117, -404},
{ 539, -114, 856, -493, 223, -912, 623, -76, 276, -440},
{ 2197, 2337, 1268, 670, 304, -267, -525, 140, 882, -139},
{-1596, 550, 801, -456, -56, -697, 865, 1060, 413, 446},
{ 1154, 593, -77, 1237, -31, 581, -1037, -895, 669, 297},
{ 397, 558, 203, -797, -919, 3, 692, -292, 1050, 782},
{ 334, 1475, 632, -80, 48, -1061, -484, 362, -597, -852},
{ -545, -330, -429, -680, 1133, -1182, -744, 1340, 262, 63},
{ 1320, 827, -398, -576, 341, -774, -483, -1247, -70, 98},
{ -163, 674, -11, -886, 531, -1125, -265, -242, 724, 934}
};
/**
* gain codebook (first stage), 8k mode (3.9.2 of G.729)
*/
static const int16_t cb_gain_1st_8k[1<<GC_1ST_IDX_BITS_8K][2] = { /*(0.14) (2.13) */
{ 3242 , 9949 },
{ 1551 , 2425 },
{ 2678 , 27162 },
{ 1921 , 9291 },
{ 1831 , 5022 },
{ 1 , 1516 },
{ 356 , 14756 },
{ 57 , 5404 },
};
/**
* gain codebook (second stage), 8k mode (3.9.2 of G.729)
*/
static const int16_t cb_gain_2nd_8k[1<<GC_2ND_IDX_BITS_8K][2] = { /*(1.14) (1.13) */
{ 5142 , 592 },
{ 17299 , 1861 },
{ 6160 , 2395 },
{ 16112 , 3392 },
{ 826 , 2005 },
{ 18973 , 5935 },
{ 1994 , 0 },
{ 15434 , 237 },
{ 10573 , 2966 },
{ 15132 , 4914 },
{ 11569 , 1196 },
{ 14194 , 1630 },
{ 8091 , 4861 },
{ 15161 , 14276 },
{ 9120 , 525 },
{ 13260 , 3256 },
};
/**
* 4th order Moving Average (MA) Predictor codebook (3.2.4 of G.729)
*/
static const int16_t cb_ma_predictor[2][MA_NP][10] = { /* (0.15) */
{
{ 8421, 9109, 9175, 8965, 9034, 9057, 8765, 8775, 9106, 8673},
{ 7018, 7189, 7638, 7307, 7444, 7379, 7038, 6956, 6930, 6868},
{ 5472, 4990, 5134, 5177, 5246, 5141, 5206, 5095, 4830, 5147},
{ 4056, 3031, 2614, 3024, 2916, 2713, 3309, 3237, 2857, 3473}
},
{
{ 7733, 7880, 8188, 8175, 8247, 8490, 8637, 8601, 8359, 7569},
{ 4210, 3031, 2552, 3473, 3876, 3853, 4184, 4154, 3909, 3968},
{ 3214, 1930, 1313, 2143, 2493, 2385, 2755, 2706, 2542, 2919},
{ 3024, 1592, 940, 1631, 1723, 1579, 2034, 2084, 1913, 2601}
}
};
static const int16_t cb_ma_predictor_sum[2][10] = { /* (0.15) */
{ 7798, 8447, 8205, 8293, 8126, 8477, 8447, 8703, 9043, 8604},
{14585, 18333, 19772, 17344, 16426, 16459, 15155, 15220, 16043, 15708}
};
/**
* initial LSP coefficients belongs to virtual frame preceding the
* first frame of the stream
*/
static const int16_t lsp_init[10]= { /* (0.15) */
30000, 26000, 21000, 15000, 8000, 0, -8000,-15000,-21000,-26000
};
#endif /* AVCODEC_G729DATA_H */

@ -1,331 +0,0 @@
/*
* G.729 decoder
* Copyright (c) 2008 Vladimir Voroshilov
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <inttypes.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <assert.h>
#include "avcodec.h"
#include "libavutil/avutil.h"
#include "get_bits.h"
#include "lsp.h"
#include "celp_math.h"
#include "acelp_filters.h"
#include "acelp_pitch_delay.h"
#include "acelp_vectors.h"
#include "g729data.h"
/**
* minimum quantized LSF value (3.2.4)
* 0.005 in Q13
*/
#define LSFQ_MIN 40
/**
* maximum quantized LSF value (3.2.4)
* 3.135 in Q13
*/
#define LSFQ_MAX 25681
/**
* minimum LSF distance (3.2.4)
* 0.0391 in Q13
*/
#define LSFQ_DIFF_MIN 321
/**
* minimum gain pitch value (3.8, Equation 47)
* 0.2 in (1.14)
*/
#define SHARP_MIN 3277
/**
* maximum gain pitch value (3.8, Equation 47)
* (EE) This does not comply with the specification.
* Specification says about 0.8, which should be
* 13107 in (1.14), but reference C code uses
* 13017 (equals to 0.7945) instead of it.
*/
#define SHARP_MAX 13017
/**
* subframe size
*/
#define SUBFRAME_SIZE 40
typedef struct {
uint8_t ac_index_bits[2]; ///< adaptive codebook index for second subframe (size in bits)
uint8_t parity_bit; ///< parity bit for pitch delay
uint8_t gc_1st_index_bits; ///< gain codebook (first stage) index (size in bits)
uint8_t gc_2nd_index_bits; ///< gain codebook (second stage) index (size in bits)
uint8_t fc_signs_bits; ///< number of pulses in fixed-codebook vector
uint8_t fc_indexes_bits; ///< size (in bits) of fixed-codebook index entry
} G729FormatDescription;
typedef struct {
int pitch_delay_int_prev; ///< integer part of previous subframe's pitch delay (4.1.3)
/// (2.13) LSP quantizer outputs
int16_t past_quantizer_output_buf[MA_NP + 1][10];
int16_t* past_quantizer_outputs[MA_NP + 1];
int16_t lsfq[10]; ///< (2.13) quantized LSF coefficients from previous frame
int16_t lsp_buf[2][10]; ///< (0.15) LSP coefficients (previous and current frames) (3.2.5)
int16_t *lsp[2]; ///< pointers to lsp_buf
} G729Context;
static const G729FormatDescription format_g729_8k = {
.ac_index_bits = {8,5},
.parity_bit = 1,
.gc_1st_index_bits = GC_1ST_IDX_BITS_8K,
.gc_2nd_index_bits = GC_2ND_IDX_BITS_8K,
.fc_signs_bits = 4,
.fc_indexes_bits = 13,
};
static const G729FormatDescription format_g729d_6k4 = {
.ac_index_bits = {8,4},
.parity_bit = 0,
.gc_1st_index_bits = GC_1ST_IDX_BITS_6K4,
.gc_2nd_index_bits = GC_2ND_IDX_BITS_6K4,
.fc_signs_bits = 2,
.fc_indexes_bits = 9,
};
/**
* @brief pseudo random number generator
*/
static inline uint16_t g729_prng(uint16_t value)
{
return 31821 * value + 13849;
}
/**
* Get parity bit of bit 2..7
*/
static inline int get_parity(uint8_t value)
{
return (0x6996966996696996ULL >> (value >> 2)) & 1;
}
static void lsf_decode(int16_t* lsfq, int16_t* past_quantizer_outputs[MA_NP + 1],
int16_t ma_predictor,
int16_t vq_1st, int16_t vq_2nd_low, int16_t vq_2nd_high)
{
int i,j;
static const uint8_t min_distance[2]={10, 5}; //(2.13)
int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
for (i = 0; i < 5; i++) {
quantizer_output[i] = cb_lsp_1st[vq_1st][i ] + cb_lsp_2nd[vq_2nd_low ][i ];
quantizer_output[i + 5] = cb_lsp_1st[vq_1st][i + 5] + cb_lsp_2nd[vq_2nd_high][i + 5];
}
for (j = 0; j < 2; j++) {
for (i = 1; i < 10; i++) {
int diff = (quantizer_output[i - 1] - quantizer_output[i] + min_distance[j]) >> 1;
if (diff > 0) {
quantizer_output[i - 1] -= diff;
quantizer_output[i ] += diff;
}
}
}
for (i = 0; i < 10; i++) {
int sum = quantizer_output[i] * cb_ma_predictor_sum[ma_predictor][i];
for (j = 0; j < MA_NP; j++)
sum += past_quantizer_outputs[j][i] * cb_ma_predictor[ma_predictor][j][i];
lsfq[i] = sum >> 15;
}
/* Rotate past_quantizer_outputs. */
memmove(past_quantizer_outputs + 1, past_quantizer_outputs, MA_NP * sizeof(int16_t*));
past_quantizer_outputs[0] = quantizer_output;
ff_acelp_reorder_lsf(lsfq, LSFQ_DIFF_MIN, LSFQ_MIN, LSFQ_MAX, 10);
}
static av_cold int decoder_init(AVCodecContext * avctx)
{
G729Context* ctx = avctx->priv_data;
int i,k;
if (avctx->channels != 1) {
av_log(avctx, AV_LOG_ERROR, "Only mono sound is supported (requested channels: %d).\n", avctx->channels);
return AVERROR(EINVAL);
}
/* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
avctx->frame_size = SUBFRAME_SIZE << 1;
for (k = 0; k < MA_NP + 1; k++) {
ctx->past_quantizer_outputs[k] = ctx->past_quantizer_output_buf[k];
for (i = 1; i < 11; i++)
ctx->past_quantizer_outputs[k][i - 1] = (18717 * i) >> 3;
}
ctx->lsp[0] = ctx->lsp_buf[0];
ctx->lsp[1] = ctx->lsp_buf[1];
memcpy(ctx->lsp[0], lsp_init, 10 * sizeof(int16_t));
return 0;
}
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
int16_t *out_frame = data;
GetBitContext gb;
G729FormatDescription format;
int frame_erasure = 0; ///< frame erasure detected during decoding
int bad_pitch = 0; ///< parity check failed
int i;
G729Context *ctx = avctx->priv_data;
int16_t lp[2][11]; // (3.12)
uint8_t ma_predictor; ///< switched MA predictor of LSP quantizer
uint8_t quantizer_1st; ///< first stage vector of quantizer
uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits)
uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits)
int pitch_delay_int; // pitch delay, integer part
int pitch_delay_3x; // pitch delay, multiplied by 3
if (*data_size < SUBFRAME_SIZE << 2) {
av_log(avctx, AV_LOG_ERROR, "Error processing packet: output buffer too small\n");
return AVERROR(EIO);
}
if (buf_size == 10) {
format = format_g729_8k;
av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s");
} else if (buf_size == 8) {
format = format_g729d_6k4;
av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s");
} else {
av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size);
return AVERROR_INVALIDDATA;
}
for (i=0; i < buf_size; i++)
frame_erasure |= buf[i];
frame_erasure = !frame_erasure;
init_get_bits(&gb, buf, buf_size);
ma_predictor = get_bits(&gb, 1);
quantizer_1st = get_bits(&gb, VQ_1ST_BITS);
quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS);
quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS);
lsf_decode(ctx->lsfq, ctx->past_quantizer_outputs,
ma_predictor,
quantizer_1st, quantizer_2nd_lo, quantizer_2nd_hi);
ff_acelp_lsf2lsp(ctx->lsp[1], ctx->lsfq, 10);
ff_acelp_lp_decode(&lp[0][0], &lp[1][0], ctx->lsp[1], ctx->lsp[0], 10);
FFSWAP(int16_t*, ctx->lsp[1], ctx->lsp[0]);
for (i = 0; i < 2; i++) {
uint8_t ac_index; ///< adaptive codebook index
uint8_t pulses_signs; ///< fixed-codebook vector pulse signs
int fc_indexes; ///< fixed-codebook indexes
uint8_t gc_1st_index; ///< gain codebook (first stage) index
uint8_t gc_2nd_index; ///< gain codebook (second stage) index
ac_index = get_bits(&gb, format.ac_index_bits[i]);
if(!i && format.parity_bit)
bad_pitch = get_parity(ac_index) == get_bits1(&gb);
fc_indexes = get_bits(&gb, format.fc_indexes_bits);
pulses_signs = get_bits(&gb, format.fc_signs_bits);
gc_1st_index = get_bits(&gb, format.gc_1st_index_bits);
gc_2nd_index = get_bits(&gb, format.gc_2nd_index_bits);
if(!i) {
if (bad_pitch)
pitch_delay_3x = 3 * ctx->pitch_delay_int_prev;
else
pitch_delay_3x = ff_acelp_decode_8bit_to_1st_delay3(ac_index);
} else {
int pitch_delay_min = av_clip(ctx->pitch_delay_int_prev - 5,
PITCH_DELAY_MIN, PITCH_DELAY_MAX - 9);
if(packet_type == FORMAT_G729D_6K4)
pitch_delay_3x = ff_acelp_decode_4bit_to_2nd_delay3(ac_index, pitch_delay_min);
else
pitch_delay_3x = ff_acelp_decode_5_6_bit_to_2nd_delay3(ac_index, pitch_delay_min);
}
/* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */
pitch_delay_int = (pitch_delay_3x + 1) / 3;
ff_acelp_weighted_vector_sum(fc + pitch_delay_int,
fc + pitch_delay_int,
fc, 1 << 14,
av_clip(ctx->gain_pitch, SHARP_MIN, SHARP_MAX),
0, 14,
SUBFRAME_SIZE - pitch_delay_int);
if (frame_erasure) {
ctx->gain_pitch = (29491 * ctx->gain_pitch) >> 15; // 0.90 (0.15)
ctx->gain_code = ( 2007 * ctx->gain_code ) >> 11; // 0.98 (0.11)
gain_corr_factor = 0;
} else {
ctx->gain_pitch = cb_gain_1st_8k[gc_1st_index][0] +
cb_gain_2nd_8k[gc_2nd_index][0];
gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] +
cb_gain_2nd_8k[gc_2nd_index][1];
ff_acelp_weighted_vector_sum(ctx->exc + i * SUBFRAME_SIZE,
ctx->exc + i * SUBFRAME_SIZE, fc,
(!voicing && frame_erasure) ? 0 : ctx->gain_pitch,
( voicing && frame_erasure) ? 0 : ctx->gain_code,
1 << 13, 14, SUBFRAME_SIZE);
ctx->pitch_delay_int_prev = pitch_delay_int;
}
*data_size = SUBFRAME_SIZE << 2;
return buf_size;
}
AVCodec ff_g729_decoder =
{
"g729",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_G729,
sizeof(G729Context),
decoder_init,
NULL,
NULL,
decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("G.729"),
};

@ -150,11 +150,7 @@ void ff_acelp_lp_decode(int16_t* lp_1st, int16_t* lp_2nd, const int16_t* lsp_2nd
/* LSP values for first subframe (3.2.5 of G.729, Equation 24)*/ /* LSP values for first subframe (3.2.5 of G.729, Equation 24)*/
for(i=0; i<lp_order; i++) for(i=0; i<lp_order; i++)
#ifdef G729_BITEXACT
lsp_1st[i] = (lsp_2nd[i] >> 1) + (lsp_prev[i] >> 1);
#else
lsp_1st[i] = (lsp_2nd[i] + lsp_prev[i]) >> 1; lsp_1st[i] = (lsp_2nd[i] + lsp_prev[i]) >> 1;
#endif
ff_acelp_lsp2lpc(lp_1st, lsp_1st, lp_order >> 1); ff_acelp_lsp2lpc(lp_1st, lsp_1st, lp_order >> 1);

@ -318,7 +318,7 @@ int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared){
s->prev_pict_types[0]= s->dropable ? AV_PICTURE_TYPE_B : s->pict_type; s->prev_pict_types[0]= s->dropable ? AV_PICTURE_TYPE_B : s->pict_type;
if (pic->f.age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->f.age] == AV_PICTURE_TYPE_B) if (pic->f.age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->f.age] == AV_PICTURE_TYPE_B)
pic->f.age = INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway. pic->f.age = INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
pic->owner2 = NULL; pic->owner2 = s;
return 0; return 0;
fail: //for the FF_ALLOCZ_OR_GOTO macro fail: //for the FF_ALLOCZ_OR_GOTO macro
@ -1036,14 +1036,16 @@ int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
/* mark&release old frames */ /* mark&release old frames */
if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->f.data[0]) { if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->f.data[0]) {
if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){ if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
free_frame_buffer(s, s->last_picture_ptr); if (s->last_picture_ptr->owner2 == s)
free_frame_buffer(s, s->last_picture_ptr);
/* release forgotten pictures */ /* release forgotten pictures */
/* if(mpeg124/h263) */ /* if(mpeg124/h263) */
if(!s->encoding){ if(!s->encoding){
for(i=0; i<s->picture_count; i++){ for(i=0; i<s->picture_count; i++){
if (s->picture[i].f.data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].f.reference) { if (s->picture[i].owner2 == s && s->picture[i].f.data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].f.reference) {
av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n"); if (!(avctx->active_thread_type & FF_THREAD_FRAME))
av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
free_frame_buffer(s, &s->picture[i]); free_frame_buffer(s, &s->picture[i]);
} }
} }

@ -178,7 +178,7 @@ void dsputil_init_ppc(DSPContext* c, AVCodecContext *avctx)
} }
#endif //CONFIG_ENCODERS #endif //CONFIG_ENCODERS
if (avctx->lowres==0) { if (avctx->lowres == 0 && avctx->bits_per_raw_sample <= 8) {
if ((avctx->idct_algo == FF_IDCT_AUTO) || if ((avctx->idct_algo == FF_IDCT_AUTO) ||
(avctx->idct_algo == FF_IDCT_ALTIVEC)) { (avctx->idct_algo == FF_IDCT_ALTIVEC)) {
c->idct_put = idct_put_altivec; c->idct_put = idct_put_altivec;

@ -156,7 +156,8 @@ void dsputil_init_mmi(DSPContext* c, AVCodecContext *avctx)
c->get_pixels = get_pixels_mmi; c->get_pixels = get_pixels_mmi;
if(idct_algo==FF_IDCT_AUTO || idct_algo==FF_IDCT_PS2){ if (avctx->bits_per_raw_sample <= 8 &&
(idct_algo==FF_IDCT_AUTO || idct_algo==FF_IDCT_PS2)) {
c->idct_put= ff_mmi_idct_put; c->idct_put= ff_mmi_idct_put;
c->idct_add= ff_mmi_idct_add; c->idct_add= ff_mmi_idct_add;
c->idct = ff_mmi_idct; c->idct = ff_mmi_idct;

@ -97,7 +97,8 @@ void dsputil_init_sh4(DSPContext* c, AVCodecContext *avctx)
if (!high_bit_depth) if (!high_bit_depth)
c->clear_blocks = clear_blocks_sh4; c->clear_blocks = clear_blocks_sh4;
if(idct_algo==FF_IDCT_AUTO || idct_algo==FF_IDCT_SH4){ if (avctx->bits_per_raw_sample <= 8 &&
(idct_algo==FF_IDCT_AUTO || idct_algo==FF_IDCT_SH4)) {
c->idct_put = idct_put; c->idct_put = idct_put;
c->idct_add = idct_add; c->idct_add = idct_add;
c->idct = idct_sh4; c->idct = idct_sh4;

@ -25,339 +25,19 @@
* simpleidct in C. * simpleidct in C.
*/ */
/*
based upon some outcommented c code from mpeg2dec (idct_mmx.c
written by Aaron Holtzman <aholtzma@ess.engr.uvic.ca>)
*/
#include "libavutil/intreadwrite.h" #include "libavutil/intreadwrite.h"
#include "avcodec.h" #include "avcodec.h"
#include "dsputil.h" #include "dsputil.h"
#include "mathops.h" #include "mathops.h"
#include "simple_idct.h" #include "simple_idct.h"
#define W1 22725 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5 #define BIT_DEPTH 8
#define W2 21407 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5 #include "simple_idct_template.c"
#define W3 19266 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5 #undef BIT_DEPTH
#define W4 16383 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define W5 12873 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define W6 8867 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define W7 4520 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define ROW_SHIFT 11
#define COL_SHIFT 20 // 6
static inline void idctRowCondDC (DCTELEM * row)
{
int a0, a1, a2, a3, b0, b1, b2, b3;
#if HAVE_FAST_64BIT
#define ROW0_MASK (0xffffLL << 48 * HAVE_BIGENDIAN)
if (((((uint64_t *)row)[0] & ~ROW0_MASK) | ((uint64_t *)row)[1]) == 0) {
uint64_t temp = (row[0] << 3) & 0xffff;
temp += temp << 16;
temp += temp << 32;
((uint64_t *)row)[0] = temp;
((uint64_t *)row)[1] = temp;
return;
}
#else
if (!(((uint32_t*)row)[1] |
((uint32_t*)row)[2] |
((uint32_t*)row)[3] |
row[1])) {
uint32_t temp = (row[0] << 3) & 0xffff;
temp += temp << 16;
((uint32_t*)row)[0]=((uint32_t*)row)[1] =
((uint32_t*)row)[2]=((uint32_t*)row)[3] = temp;
return;
}
#endif
a0 = (W4 * row[0]) + (1 << (ROW_SHIFT - 1));
a1 = a0;
a2 = a0;
a3 = a0;
/* no need to optimize : gcc does it */
a0 += W2 * row[2];
a1 += W6 * row[2];
a2 -= W6 * row[2];
a3 -= W2 * row[2];
b0 = MUL16(W1, row[1]);
MAC16(b0, W3, row[3]);
b1 = MUL16(W3, row[1]);
MAC16(b1, -W7, row[3]);
b2 = MUL16(W5, row[1]);
MAC16(b2, -W1, row[3]);
b3 = MUL16(W7, row[1]);
MAC16(b3, -W5, row[3]);
if (AV_RN64A(row + 4)) {
a0 += W4*row[4] + W6*row[6];
a1 += - W4*row[4] - W2*row[6];
a2 += - W4*row[4] + W2*row[6];
a3 += W4*row[4] - W6*row[6];
MAC16(b0, W5, row[5]);
MAC16(b0, W7, row[7]);
MAC16(b1, -W1, row[5]);
MAC16(b1, -W5, row[7]);
MAC16(b2, W7, row[5]);
MAC16(b2, W3, row[7]);
MAC16(b3, W3, row[5]);
MAC16(b3, -W1, row[7]);
}
row[0] = (a0 + b0) >> ROW_SHIFT;
row[7] = (a0 - b0) >> ROW_SHIFT;
row[1] = (a1 + b1) >> ROW_SHIFT;
row[6] = (a1 - b1) >> ROW_SHIFT;
row[2] = (a2 + b2) >> ROW_SHIFT;
row[5] = (a2 - b2) >> ROW_SHIFT;
row[3] = (a3 + b3) >> ROW_SHIFT;
row[4] = (a3 - b3) >> ROW_SHIFT;
}
static inline void idctSparseColPut (uint8_t *dest, int line_size,
DCTELEM * col)
{
int a0, a1, a2, a3, b0, b1, b2, b3;
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
/* XXX: I did that only to give same values as previous code */
a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
a1 = a0;
a2 = a0;
a3 = a0;
a0 += + W2*col[8*2];
a1 += + W6*col[8*2];
a2 += - W6*col[8*2];
a3 += - W2*col[8*2];
b0 = MUL16(W1, col[8*1]);
b1 = MUL16(W3, col[8*1]);
b2 = MUL16(W5, col[8*1]);
b3 = MUL16(W7, col[8*1]);
MAC16(b0, + W3, col[8*3]);
MAC16(b1, - W7, col[8*3]);
MAC16(b2, - W1, col[8*3]);
MAC16(b3, - W5, col[8*3]);
if(col[8*4]){
a0 += + W4*col[8*4];
a1 += - W4*col[8*4];
a2 += - W4*col[8*4];
a3 += + W4*col[8*4];
}
if (col[8*5]) {
MAC16(b0, + W5, col[8*5]);
MAC16(b1, - W1, col[8*5]);
MAC16(b2, + W7, col[8*5]);
MAC16(b3, + W3, col[8*5]);
}
if(col[8*6]){
a0 += + W6*col[8*6];
a1 += - W2*col[8*6];
a2 += + W2*col[8*6];
a3 += - W6*col[8*6];
}
if (col[8*7]) {
MAC16(b0, + W7, col[8*7]);
MAC16(b1, - W5, col[8*7]);
MAC16(b2, + W3, col[8*7]);
MAC16(b3, - W1, col[8*7]);
}
dest[0] = cm[(a0 + b0) >> COL_SHIFT];
dest += line_size;
dest[0] = cm[(a1 + b1) >> COL_SHIFT];
dest += line_size;
dest[0] = cm[(a2 + b2) >> COL_SHIFT];
dest += line_size;
dest[0] = cm[(a3 + b3) >> COL_SHIFT];
dest += line_size;
dest[0] = cm[(a3 - b3) >> COL_SHIFT];
dest += line_size;
dest[0] = cm[(a2 - b2) >> COL_SHIFT];
dest += line_size;
dest[0] = cm[(a1 - b1) >> COL_SHIFT];
dest += line_size;
dest[0] = cm[(a0 - b0) >> COL_SHIFT];
}
static inline void idctSparseColAdd (uint8_t *dest, int line_size,
DCTELEM * col)
{
int a0, a1, a2, a3, b0, b1, b2, b3;
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
/* XXX: I did that only to give same values as previous code */
a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
a1 = a0;
a2 = a0;
a3 = a0;
a0 += + W2*col[8*2];
a1 += + W6*col[8*2];
a2 += - W6*col[8*2];
a3 += - W2*col[8*2];
b0 = MUL16(W1, col[8*1]);
b1 = MUL16(W3, col[8*1]);
b2 = MUL16(W5, col[8*1]);
b3 = MUL16(W7, col[8*1]);
MAC16(b0, + W3, col[8*3]); #define BIT_DEPTH 10
MAC16(b1, - W7, col[8*3]); #include "simple_idct_template.c"
MAC16(b2, - W1, col[8*3]); #undef BIT_DEPTH
MAC16(b3, - W5, col[8*3]);
if(col[8*4]){
a0 += + W4*col[8*4];
a1 += - W4*col[8*4];
a2 += - W4*col[8*4];
a3 += + W4*col[8*4];
}
if (col[8*5]) {
MAC16(b0, + W5, col[8*5]);
MAC16(b1, - W1, col[8*5]);
MAC16(b2, + W7, col[8*5]);
MAC16(b3, + W3, col[8*5]);
}
if(col[8*6]){
a0 += + W6*col[8*6];
a1 += - W2*col[8*6];
a2 += + W2*col[8*6];
a3 += - W6*col[8*6];
}
if (col[8*7]) {
MAC16(b0, + W7, col[8*7]);
MAC16(b1, - W5, col[8*7]);
MAC16(b2, + W3, col[8*7]);
MAC16(b3, - W1, col[8*7]);
}
dest[0] = cm[dest[0] + ((a0 + b0) >> COL_SHIFT)];
dest += line_size;
dest[0] = cm[dest[0] + ((a1 + b1) >> COL_SHIFT)];
dest += line_size;
dest[0] = cm[dest[0] + ((a2 + b2) >> COL_SHIFT)];
dest += line_size;
dest[0] = cm[dest[0] + ((a3 + b3) >> COL_SHIFT)];
dest += line_size;
dest[0] = cm[dest[0] + ((a3 - b3) >> COL_SHIFT)];
dest += line_size;
dest[0] = cm[dest[0] + ((a2 - b2) >> COL_SHIFT)];
dest += line_size;
dest[0] = cm[dest[0] + ((a1 - b1) >> COL_SHIFT)];
dest += line_size;
dest[0] = cm[dest[0] + ((a0 - b0) >> COL_SHIFT)];
}
static inline void idctSparseCol (DCTELEM * col)
{
int a0, a1, a2, a3, b0, b1, b2, b3;
/* XXX: I did that only to give same values as previous code */
a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4));
a1 = a0;
a2 = a0;
a3 = a0;
a0 += + W2*col[8*2];
a1 += + W6*col[8*2];
a2 += - W6*col[8*2];
a3 += - W2*col[8*2];
b0 = MUL16(W1, col[8*1]);
b1 = MUL16(W3, col[8*1]);
b2 = MUL16(W5, col[8*1]);
b3 = MUL16(W7, col[8*1]);
MAC16(b0, + W3, col[8*3]);
MAC16(b1, - W7, col[8*3]);
MAC16(b2, - W1, col[8*3]);
MAC16(b3, - W5, col[8*3]);
if(col[8*4]){
a0 += + W4*col[8*4];
a1 += - W4*col[8*4];
a2 += - W4*col[8*4];
a3 += + W4*col[8*4];
}
if (col[8*5]) {
MAC16(b0, + W5, col[8*5]);
MAC16(b1, - W1, col[8*5]);
MAC16(b2, + W7, col[8*5]);
MAC16(b3, + W3, col[8*5]);
}
if(col[8*6]){
a0 += + W6*col[8*6];
a1 += - W2*col[8*6];
a2 += + W2*col[8*6];
a3 += - W6*col[8*6];
}
if (col[8*7]) {
MAC16(b0, + W7, col[8*7]);
MAC16(b1, - W5, col[8*7]);
MAC16(b2, + W3, col[8*7]);
MAC16(b3, - W1, col[8*7]);
}
col[0 ] = ((a0 + b0) >> COL_SHIFT);
col[8 ] = ((a1 + b1) >> COL_SHIFT);
col[16] = ((a2 + b2) >> COL_SHIFT);
col[24] = ((a3 + b3) >> COL_SHIFT);
col[32] = ((a3 - b3) >> COL_SHIFT);
col[40] = ((a2 - b2) >> COL_SHIFT);
col[48] = ((a1 - b1) >> COL_SHIFT);
col[56] = ((a0 - b0) >> COL_SHIFT);
}
void ff_simple_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
{
int i;
for(i=0; i<8; i++)
idctRowCondDC(block + i*8);
for(i=0; i<8; i++)
idctSparseColPut(dest + i, line_size, block + i);
}
void ff_simple_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
{
int i;
for(i=0; i<8; i++)
idctRowCondDC(block + i*8);
for(i=0; i<8; i++)
idctSparseColAdd(dest + i, line_size, block + i);
}
void ff_simple_idct(DCTELEM *block)
{
int i;
for(i=0; i<8; i++)
idctRowCondDC(block + i*8);
for(i=0; i<8; i++)
idctSparseCol(block + i);
}
/* 2x4x8 idct */ /* 2x4x8 idct */
@ -428,7 +108,7 @@ void ff_simple_idct248_put(uint8_t *dest, int line_size, DCTELEM *block)
/* IDCT8 on each line */ /* IDCT8 on each line */
for(i=0; i<8; i++) { for(i=0; i<8; i++) {
idctRowCondDC(block + i*8); idctRowCondDC_8(block + i*8);
} }
/* IDCT4 and store */ /* IDCT4 and store */
@ -503,7 +183,7 @@ void ff_simple_idct84_add(uint8_t *dest, int line_size, DCTELEM *block)
/* IDCT8 on each line */ /* IDCT8 on each line */
for(i=0; i<4; i++) { for(i=0; i<4; i++) {
idctRowCondDC(block + i*8); idctRowCondDC_8(block + i*8);
} }
/* IDCT4 and store */ /* IDCT4 and store */
@ -523,7 +203,7 @@ void ff_simple_idct48_add(uint8_t *dest, int line_size, DCTELEM *block)
/* IDCT8 and store */ /* IDCT8 and store */
for(i=0; i<4; i++){ for(i=0; i<4; i++){
idctSparseColAdd(dest + i, line_size, block + i); idctSparseColAdd_8(dest + i, line_size, block + i);
} }
} }

@ -31,12 +31,17 @@
#include <stdint.h> #include <stdint.h>
#include "dsputil.h" #include "dsputil.h"
void ff_simple_idct_put(uint8_t *dest, int line_size, DCTELEM *block); void ff_simple_idct_put_8(uint8_t *dest, int line_size, DCTELEM *block);
void ff_simple_idct_add(uint8_t *dest, int line_size, DCTELEM *block); void ff_simple_idct_add_8(uint8_t *dest, int line_size, DCTELEM *block);
void ff_simple_idct_8(DCTELEM *block);
void ff_simple_idct_put_10(uint8_t *dest, int line_size, DCTELEM *block);
void ff_simple_idct_add_10(uint8_t *dest, int line_size, DCTELEM *block);
void ff_simple_idct_10(DCTELEM *block);
void ff_simple_idct_mmx(int16_t *block); void ff_simple_idct_mmx(int16_t *block);
void ff_simple_idct_add_mmx(uint8_t *dest, int line_size, int16_t *block); void ff_simple_idct_add_mmx(uint8_t *dest, int line_size, int16_t *block);
void ff_simple_idct_put_mmx(uint8_t *dest, int line_size, int16_t *block); void ff_simple_idct_put_mmx(uint8_t *dest, int line_size, int16_t *block);
void ff_simple_idct(DCTELEM *block);
void ff_simple_idct248_put(uint8_t *dest, int line_size, DCTELEM *block); void ff_simple_idct248_put(uint8_t *dest, int line_size, DCTELEM *block);

@ -0,0 +1,316 @@
/*
* Simple IDCT
*
* Copyright (c) 2001 Michael Niedermayer <michaelni@gmx.at>
*
* This file is part of Libav.
*
* Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file
* simpleidct in C.
*/
/*
based upon some outcommented c code from mpeg2dec (idct_mmx.c
written by Aaron Holtzman <aholtzma@ess.engr.uvic.ca>)
*/
#include "bit_depth_template.c"
#undef W1
#undef W2
#undef W3
#undef W4
#undef W5
#undef W6
#undef W7
#undef ROW_SHIFT
#undef COL_SHIFT
#undef DC_SHIFT
#undef MUL
#undef MAC
#if BIT_DEPTH == 8
#define W1 22725 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define W2 21407 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define W3 19266 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define W4 16383 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define W5 12873 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define W6 8867 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define W7 4520 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define ROW_SHIFT 11
#define COL_SHIFT 20
#define DC_SHIFT 3
#define MUL(a, b) MUL16(a, b)
#define MAC(a, b, c) MAC16(a, b, c)
#elif BIT_DEPTH == 10
#define W1 90901
#define W2 85627
#define W3 77062
#define W4 65535
#define W5 51491
#define W6 35468
#define W7 18081
#define ROW_SHIFT 15
#define COL_SHIFT 20
#define DC_SHIFT 1
#define MUL(a, b) ((a) * (b))
#define MAC(a, b, c) ((a) += (b) * (c))
#else
#error "Unsupported bitdepth"
#endif
static inline void FUNC(idctRowCondDC)(DCTELEM *row)
{
int a0, a1, a2, a3, b0, b1, b2, b3;
#if HAVE_FAST_64BIT
#define ROW0_MASK (0xffffLL << 48 * HAVE_BIGENDIAN)
if (((((uint64_t *)row)[0] & ~ROW0_MASK) | ((uint64_t *)row)[1]) == 0) {
uint64_t temp = (row[0] << DC_SHIFT) & 0xffff;
temp += temp << 16;
temp += temp << 32;
((uint64_t *)row)[0] = temp;
((uint64_t *)row)[1] = temp;
return;
}
#else
if (!(((uint32_t*)row)[1] |
((uint32_t*)row)[2] |
((uint32_t*)row)[3] |
row[1])) {
uint32_t temp = (row[0] << DC_SHIFT) & 0xffff;
temp += temp << 16;
((uint32_t*)row)[0]=((uint32_t*)row)[1] =
((uint32_t*)row)[2]=((uint32_t*)row)[3] = temp;
return;
}
#endif
a0 = (W4 * row[0]) + (1 << (ROW_SHIFT - 1));
a1 = a0;
a2 = a0;
a3 = a0;
a0 += W2 * row[2];
a1 += W6 * row[2];
a2 -= W6 * row[2];
a3 -= W2 * row[2];
b0 = MUL(W1, row[1]);
MAC(b0, W3, row[3]);
b1 = MUL(W3, row[1]);
MAC(b1, -W7, row[3]);
b2 = MUL(W5, row[1]);
MAC(b2, -W1, row[3]);
b3 = MUL(W7, row[1]);
MAC(b3, -W5, row[3]);
if (AV_RN64A(row + 4)) {
a0 += W4*row[4] + W6*row[6];
a1 += - W4*row[4] - W2*row[6];
a2 += - W4*row[4] + W2*row[6];
a3 += W4*row[4] - W6*row[6];
MAC(b0, W5, row[5]);
MAC(b0, W7, row[7]);
MAC(b1, -W1, row[5]);
MAC(b1, -W5, row[7]);
MAC(b2, W7, row[5]);
MAC(b2, W3, row[7]);
MAC(b3, W3, row[5]);
MAC(b3, -W1, row[7]);
}
row[0] = (a0 + b0) >> ROW_SHIFT;
row[7] = (a0 - b0) >> ROW_SHIFT;
row[1] = (a1 + b1) >> ROW_SHIFT;
row[6] = (a1 - b1) >> ROW_SHIFT;
row[2] = (a2 + b2) >> ROW_SHIFT;
row[5] = (a2 - b2) >> ROW_SHIFT;
row[3] = (a3 + b3) >> ROW_SHIFT;
row[4] = (a3 - b3) >> ROW_SHIFT;
}
#define IDCT_COLS do { \
a0 = W4 * (col[8*0] + ((1<<(COL_SHIFT-1))/W4)); \
a1 = a0; \
a2 = a0; \
a3 = a0; \
\
a0 += W2*col[8*2]; \
a1 += W6*col[8*2]; \
a2 += -W6*col[8*2]; \
a3 += -W2*col[8*2]; \
\
b0 = MUL(W1, col[8*1]); \
b1 = MUL(W3, col[8*1]); \
b2 = MUL(W5, col[8*1]); \
b3 = MUL(W7, col[8*1]); \
\
MAC(b0, W3, col[8*3]); \
MAC(b1, -W7, col[8*3]); \
MAC(b2, -W1, col[8*3]); \
MAC(b3, -W5, col[8*3]); \
\
if (col[8*4]) { \
a0 += W4*col[8*4]; \
a1 += -W4*col[8*4]; \
a2 += -W4*col[8*4]; \
a3 += W4*col[8*4]; \
} \
\
if (col[8*5]) { \
MAC(b0, W5, col[8*5]); \
MAC(b1, -W1, col[8*5]); \
MAC(b2, W7, col[8*5]); \
MAC(b3, W3, col[8*5]); \
} \
\
if (col[8*6]) { \
a0 += W6*col[8*6]; \
a1 += -W2*col[8*6]; \
a2 += W2*col[8*6]; \
a3 += -W6*col[8*6]; \
} \
\
if (col[8*7]) { \
MAC(b0, W7, col[8*7]); \
MAC(b1, -W5, col[8*7]); \
MAC(b2, W3, col[8*7]); \
MAC(b3, -W1, col[8*7]); \
} \
} while (0)
static inline void FUNC(idctSparseColPut)(pixel *dest, int line_size,
DCTELEM *col)
{
int a0, a1, a2, a3, b0, b1, b2, b3;
INIT_CLIP;
IDCT_COLS;
dest[0] = CLIP((a0 + b0) >> COL_SHIFT);
dest += line_size;
dest[0] = CLIP((a1 + b1) >> COL_SHIFT);
dest += line_size;
dest[0] = CLIP((a2 + b2) >> COL_SHIFT);
dest += line_size;
dest[0] = CLIP((a3 + b3) >> COL_SHIFT);
dest += line_size;
dest[0] = CLIP((a3 - b3) >> COL_SHIFT);
dest += line_size;
dest[0] = CLIP((a2 - b2) >> COL_SHIFT);
dest += line_size;
dest[0] = CLIP((a1 - b1) >> COL_SHIFT);
dest += line_size;
dest[0] = CLIP((a0 - b0) >> COL_SHIFT);
}
static inline void FUNC(idctSparseColAdd)(pixel *dest, int line_size,
DCTELEM *col)
{
int a0, a1, a2, a3, b0, b1, b2, b3;
INIT_CLIP;
IDCT_COLS;
dest[0] = CLIP(dest[0] + ((a0 + b0) >> COL_SHIFT));
dest += line_size;
dest[0] = CLIP(dest[0] + ((a1 + b1) >> COL_SHIFT));
dest += line_size;
dest[0] = CLIP(dest[0] + ((a2 + b2) >> COL_SHIFT));
dest += line_size;
dest[0] = CLIP(dest[0] + ((a3 + b3) >> COL_SHIFT));
dest += line_size;
dest[0] = CLIP(dest[0] + ((a3 - b3) >> COL_SHIFT));
dest += line_size;
dest[0] = CLIP(dest[0] + ((a2 - b2) >> COL_SHIFT));
dest += line_size;
dest[0] = CLIP(dest[0] + ((a1 - b1) >> COL_SHIFT));
dest += line_size;
dest[0] = CLIP(dest[0] + ((a0 - b0) >> COL_SHIFT));
}
static inline void FUNC(idctSparseCol)(DCTELEM *col)
{
int a0, a1, a2, a3, b0, b1, b2, b3;
IDCT_COLS;
col[0 ] = ((a0 + b0) >> COL_SHIFT);
col[8 ] = ((a1 + b1) >> COL_SHIFT);
col[16] = ((a2 + b2) >> COL_SHIFT);
col[24] = ((a3 + b3) >> COL_SHIFT);
col[32] = ((a3 - b3) >> COL_SHIFT);
col[40] = ((a2 - b2) >> COL_SHIFT);
col[48] = ((a1 - b1) >> COL_SHIFT);
col[56] = ((a0 - b0) >> COL_SHIFT);
}
void FUNC(ff_simple_idct_put)(uint8_t *dest_, int line_size, DCTELEM *block)
{
pixel *dest = (pixel *)dest_;
int i;
line_size /= sizeof(pixel);
for (i = 0; i < 8; i++)
FUNC(idctRowCondDC)(block + i*8);
for (i = 0; i < 8; i++)
FUNC(idctSparseColPut)(dest + i, line_size, block + i);
}
void FUNC(ff_simple_idct_add)(uint8_t *dest_, int line_size, DCTELEM *block)
{
pixel *dest = (pixel *)dest_;
int i;
line_size /= sizeof(pixel);
for (i = 0; i < 8; i++)
FUNC(idctRowCondDC)(block + i*8);
for (i = 0; i < 8; i++)
FUNC(idctSparseColAdd)(dest + i, line_size, block + i);
}
void FUNC(ff_simple_idct)(DCTELEM *block)
{
int i;
for (i = 0; i < 8; i++)
FUNC(idctRowCondDC)(block + i*8);
for (i = 0; i < 8; i++)
FUNC(idctSparseCol)(block + i);
}

@ -3956,7 +3956,8 @@ void dsputil_init_vis(DSPContext* c, AVCodecContext *avctx)
const int high_bit_depth = avctx->codec_id == CODEC_ID_H264 && avctx->bits_per_raw_sample > 8; const int high_bit_depth = avctx->codec_id == CODEC_ID_H264 && avctx->bits_per_raw_sample > 8;
if (accel & ACCEL_SPARC_VIS) { if (accel & ACCEL_SPARC_VIS) {
if(avctx->idct_algo==FF_IDCT_SIMPLEVIS){ if (avctx->bits_per_raw_sample <= 8 &&
avctx->idct_algo == FF_IDCT_SIMPLEVIS) {
c->idct_put = ff_simple_idct_put_vis; c->idct_put = ff_simple_idct_put_vis;
c->idct_add = ff_simple_idct_add_vis; c->idct_add = ff_simple_idct_add_vis;
c->idct = ff_simple_idct_vis; c->idct = ff_simple_idct_vis;

@ -337,11 +337,11 @@ int vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitConte
v->res_fasttx = get_bits1(gb); v->res_fasttx = get_bits1(gb);
if (!v->res_fasttx) if (!v->res_fasttx)
{ {
v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct; v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_8;
v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add; v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add; v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add; v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add; v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8;
v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add; v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;
v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add; v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;
v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add; v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;

@ -2369,7 +2369,7 @@ void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx)
if (mm_flags & AV_CPU_FLAG_MMX) { if (mm_flags & AV_CPU_FLAG_MMX) {
const int idct_algo= avctx->idct_algo; const int idct_algo= avctx->idct_algo;
if(avctx->lowres==0){ if (avctx->lowres == 0 && avctx->bits_per_raw_sample <= 8) {
if(idct_algo==FF_IDCT_AUTO || idct_algo==FF_IDCT_SIMPLEMMX){ if(idct_algo==FF_IDCT_AUTO || idct_algo==FF_IDCT_SIMPLEMMX){
c->idct_put= ff_simple_idct_put_mmx; c->idct_put= ff_simple_idct_put_mmx;
c->idct_add= ff_simple_idct_add_mmx; c->idct_add= ff_simple_idct_add_mmx;

@ -182,11 +182,13 @@ int sws_isSupportedInput(enum PixelFormat pix_fmt)
|| (x)==PIX_FMT_YUV420P9LE \ || (x)==PIX_FMT_YUV420P9LE \
|| (x)==PIX_FMT_YUV420P10LE \ || (x)==PIX_FMT_YUV420P10LE \
|| (x)==PIX_FMT_YUV420P16LE \ || (x)==PIX_FMT_YUV420P16LE \
|| (x)==PIX_FMT_YUV422P10LE \
|| (x)==PIX_FMT_YUV422P16LE \ || (x)==PIX_FMT_YUV422P16LE \
|| (x)==PIX_FMT_YUV444P16LE \ || (x)==PIX_FMT_YUV444P16LE \
|| (x)==PIX_FMT_YUV422P10BE \ || (x)==PIX_FMT_YUV422P10BE \
|| (x)==PIX_FMT_YUV420P9BE \ || (x)==PIX_FMT_YUV420P9BE \
|| (x)==PIX_FMT_YUV420P10BE \ || (x)==PIX_FMT_YUV420P10BE \
|| (x)==PIX_FMT_YUV422P10BE \
|| (x)==PIX_FMT_YUV420P16BE \ || (x)==PIX_FMT_YUV420P16BE \
|| (x)==PIX_FMT_YUV422P16BE \ || (x)==PIX_FMT_YUV422P16BE \
|| (x)==PIX_FMT_YUV444P16BE \ || (x)==PIX_FMT_YUV444P16BE \

Loading…
Cancel
Save