Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

vp8: K&R formatting cosmetics

Browse Source 
Signed-off-by: Diego Biurrun <diego@biurrun.de>
pull/64/head
Vittorio Giovara 11 years ago committed by Diego Biurrun
parent 6adf3bc42e
commit 53c20f17c7
6 changed files with 934 additions and 807 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 949
      libavcodec/vp8.c
  2. 19
      libavcodec/vp8.h
  3. 15
      libavcodec/vp8_parser.c
  4. 188
      libavcodec/vp8data.h
  5. 566
      libavcodec/vp8dsp.c
  6. 4
      libavcodec/vp8dsp.h

949
libavcodec/vp8.c
View File

File diff suppressed because it is too large Load Diff

19
libavcodec/vp8.h
Unescape View File

@ -28,14 +28,15 @@
#include "libavutil/buffer.h" #include "libavutil/buffer.h"
#include "vp56.h"
#include "vp8dsp.h"
#include "h264pred.h" #include "h264pred.h"
#include "thread.h" #include "thread.h"
#include "vp56.h"
#include "vp8dsp.h"
#if HAVE_PTHREADS #if HAVE_PTHREADS
#include <pthread.h> # include <pthread.h>
#elif HAVE_W32THREADS #elif HAVE_W32THREADS
#include "compat/w32pthreads.h" # include "compat/w32pthreads.h"
#endif #endif
#define VP8_MAX_QUANT 127 #define VP8_MAX_QUANT 127
@ -82,7 +83,7 @@ typedef struct VP8FilterStrength {
typedef struct VP8Macroblock { typedef struct VP8Macroblock {
uint8_t skip; uint8_t skip;
// todo: make it possible to check for at least (i4x4 or split_mv) // TODO: make it possible to check for at least (i4x4 or split_mv)
// in one op. are others needed? // in one op. are others needed?
uint8_t mode; uint8_t mode;
uint8_t ref_frame; uint8_t ref_frame;
@ -116,7 +117,7 @@ typedef struct VP8ThreadData {
int thread_nr; int thread_nr;
#if HAVE_THREADS #if HAVE_THREADS
pthread_mutex_t lock; pthread_mutex_t lock;
pthread_cond_t cond; pthread_cond_t cond;
#endif #endif
int thread_mb_pos; // (mb_y << 16) | (mb_x & 0xFFFF) int thread_mb_pos; // (mb_y << 16) | (mb_x & 0xFFFF)
int wait_mb_pos; // What the current thread is waiting on. int wait_mb_pos; // What the current thread is waiting on.
@ -203,7 +204,7 @@ typedef struct VP8Context {
* [7] - split mv * [7] - split mv
* i16x16 modes never have any adjustment * i16x16 modes never have any adjustment
*/ */
int8_t mode[VP8_MVMODE_SPLIT+1]; int8_t mode[VP8_MVMODE_SPLIT + 1];
/** /**
* filter strength adjustment for macroblocks that reference: * filter strength adjustment for macroblocks that reference:
@ -215,7 +216,7 @@ typedef struct VP8Context {
int8_t ref[4]; int8_t ref[4];
} lf_delta; } lf_delta;
uint8_t (*top_border)[16+8+8]; uint8_t (*top_border)[16 + 8 + 8];
uint8_t (*top_nnz)[9]; uint8_t (*top_nnz)[9];
VP56RangeCoder c; ///< header context, includes mb modes and motion vectors VP56RangeCoder c; ///< header context, includes mb modes and motion vectors
@ -234,7 +235,7 @@ typedef struct VP8Context {
uint8_t golden; uint8_t golden;
uint8_t pred16x16[4]; uint8_t pred16x16[4];
uint8_t pred8x8c[3]; uint8_t pred8x8c[3];
uint8_t token[4][16][3][NUM_DCT_TOKENS-1]; uint8_t token[4][16][3][NUM_DCT_TOKENS - 1];
uint8_t mvc[2][19]; uint8_t mvc[2][19];
} prob[2]; } prob[2];

15
libavcodec/vp8_parser.c
Unescape View File

@ -21,18 +21,19 @@
#include "parser.h" #include "parser.h"
static int parse(AVCodecParserContext *s, static int parse(AVCodecParserContext *s,
AVCodecContext *avctx, AVCodecContext *avctx,
const uint8_t **poutbuf, int *poutbuf_size, const uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size) const uint8_t *buf, int buf_size)
{ {
s->pict_type= (buf[0]&0x01) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I; s->pict_type = (buf[0] & 0x01) ? AV_PICTURE_TYPE_P
: AV_PICTURE_TYPE_I;
*poutbuf = buf; *poutbuf = buf;
*poutbuf_size = buf_size; *poutbuf_size = buf_size;
return buf_size; return buf_size;
} }
AVCodecParser ff_vp8_parser = { AVCodecParser ff_vp8_parser = {
.codec_ids = { AV_CODEC_ID_VP8 }, .codec_ids = { AV_CODEC_ID_VP8 },
.parser_parse = parse, .parser_parse = parse,
}; };

188
libavcodec/vp8data.h
Unescape View File

@ -30,28 +30,25 @@
#include "vp8.h" #include "vp8.h"
#include "h264pred.h" #include "h264pred.h"
static const uint8_t vp8_pred4x4_mode[] = static const uint8_t vp8_pred4x4_mode[] = {
{
[DC_PRED8x8] = DC_PRED, [DC_PRED8x8] = DC_PRED,
[VERT_PRED8x8] = VERT_PRED, [VERT_PRED8x8] = VERT_PRED,
[HOR_PRED8x8] = HOR_PRED, [HOR_PRED8x8] = HOR_PRED,
[PLANE_PRED8x8] = TM_VP8_PRED, [PLANE_PRED8x8] = TM_VP8_PRED,
}; };
static const int8_t vp8_pred16x16_tree_intra[4][2] = static const int8_t vp8_pred16x16_tree_intra[4][2] = {
{ { -MODE_I4x4, 1 }, // '0'
{ -MODE_I4x4, 1 }, // '0' { 2, 3 },
{ 2, 3 }, { -DC_PRED8x8, -VERT_PRED8x8 }, // '100', '101'
{ -DC_PRED8x8, -VERT_PRED8x8 }, // '100', '101' { -HOR_PRED8x8, -PLANE_PRED8x8 }, // '110', '111'
{ -HOR_PRED8x8, -PLANE_PRED8x8 }, // '110', '111'
}; };
static const int8_t vp8_pred16x16_tree_inter[4][2] = static const int8_t vp8_pred16x16_tree_inter[4][2] = {
{ { -DC_PRED8x8, 1 }, // '0'
{ -DC_PRED8x8, 1 }, // '0' { 2, 3 },
{ 2, 3 }, { -VERT_PRED8x8, -HOR_PRED8x8 }, // '100', '101'
{ -VERT_PRED8x8, -HOR_PRED8x8 }, // '100', '101' { -PLANE_PRED8x8, -MODE_I4x4 }, // '110', '111'
{ -PLANE_PRED8x8, -MODE_I4x4 }, // '110', '111'
}; };
static const int vp8_mode_contexts[6][4] = { static const int vp8_mode_contexts[6][4] = {
@ -64,26 +61,26 @@ static const int vp8_mode_contexts[6][4] = {
}; };
static const uint8_t vp8_mbsplits[5][16] = { static const uint8_t vp8_mbsplits[5][16] = {
{ 0, 0, 0, 0, 0, 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1 },
1, 1, 1, 1, 1, 1, 1, 1 }, { 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1 },
{ 0, 0, 1, 1, 0, 0, 1, 1, { 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3 },
0, 0, 1, 1, 0, 0, 1, 1 }, { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
{ 0, 0, 1, 1, 0, 0, 1, 1, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
2, 2, 3, 3, 2, 2, 3, 3 },
{ 0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15 },
{ 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0 }
}; };
static const uint8_t vp8_mbfirstidx[4][16] = { static const uint8_t vp8_mbfirstidx[4][16] = {
{ 0, 8 }, { 0, 2 }, { 0, 2, 8, 10 }, { 0, 8 },
{ 0, 1, 2, 3, 4, 5, 6, 7, { 0, 2 },
8, 9, 10, 11, 12, 13, 14, 15 } { 0, 2, 8, 10 },
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }
}; };
static const uint8_t vp8_mbsplit_count[4] = { 2, 2, 4, 16 }; static const uint8_t vp8_mbsplit_count[4] = {
static const uint8_t vp8_mbsplit_prob[3] = { 110, 111, 150 }; 2, 2, 4, 16
};
static const uint8_t vp8_mbsplit_prob[3] = {
110, 111, 150
};
static const uint8_t vp8_submv_prob[5][3] = { static const uint8_t vp8_submv_prob[5][3] = {
{ 147, 136, 18 }, { 147, 136, 18 },
@ -93,39 +90,42 @@ static const uint8_t vp8_submv_prob[5][3] = {
{ 208, 1, 1 } { 208, 1, 1 }
}; };
static const uint8_t vp8_pred16x16_prob_intra[4] = { 145, 156, 163, 128 }; static const uint8_t vp8_pred16x16_prob_intra[4] = {
static const uint8_t vp8_pred16x16_prob_inter[4] = { 112, 86, 140, 37 }; 145, 156, 163, 128
};
static const int8_t vp8_pred4x4_tree[9][2] = static const uint8_t vp8_pred16x16_prob_inter[4] = {
{ 112, 86, 140, 37
{ -DC_PRED, 1 }, // '0'
{ -TM_VP8_PRED, 2 }, // '10'
{ -VERT_PRED, 3 }, // '110'
{ 4, 6 },
{ -HOR_PRED, 5 }, // '11100'
{ -DIAG_DOWN_RIGHT_PRED, -VERT_RIGHT_PRED }, // '111010', '111011'
{ -DIAG_DOWN_LEFT_PRED, 7 }, // '11110'
{ -VERT_LEFT_PRED, 8 }, // '111110'
{ -HOR_DOWN_PRED, -HOR_UP_PRED }, // '1111110', '1111111'
}; };
static const int8_t vp8_pred8x8c_tree[3][2] = static const int8_t vp8_pred4x4_tree[9][2] = {
{ { -DC_PRED, 1 }, // '0'
{ -DC_PRED8x8, 1 }, // '0' { -TM_VP8_PRED, 2 }, // '10'
{ -VERT_PRED8x8, 2 }, // '10 { -VERT_PRED, 3 }, // '110'
{ -HOR_PRED8x8, -PLANE_PRED8x8 }, // '110', '111' { 4, 6 },
{ -HOR_PRED, 5 }, // '11100'
{ -DIAG_DOWN_RIGHT_PRED, -VERT_RIGHT_PRED }, // '111010', '111011'
{ -DIAG_DOWN_LEFT_PRED, 7 }, // '11110'
{ -VERT_LEFT_PRED, 8 }, // '111110'
{ -HOR_DOWN_PRED, -HOR_UP_PRED }, // '1111110', '1111111'
}; };
static const uint8_t vp8_pred8x8c_prob_intra[3] = { 142, 114, 183 }; static const int8_t vp8_pred8x8c_tree[3][2] = {
static const uint8_t vp8_pred8x8c_prob_inter[3] = { 162, 101, 204 }; { -DC_PRED8x8, 1 }, // '0'
{ -VERT_PRED8x8, 2 }, // '10
{ -HOR_PRED8x8, -PLANE_PRED8x8 }, // '110', '111'
};
static const uint8_t vp8_pred4x4_prob_inter[9] = static const uint8_t vp8_pred8x8c_prob_intra[3] = {
{ 142, 114, 183
};
static const uint8_t vp8_pred8x8c_prob_inter[3] = {
162, 101, 204
};
static const uint8_t vp8_pred4x4_prob_inter[9] = {
120, 90, 79, 133, 87, 85, 80, 111, 151 120, 90, 79, 133, 87, 85, 80, 111, 151
}; };
static const uint8_t vp8_pred4x4_prob_intra[10][10][9] = static const uint8_t vp8_pred4x4_prob_intra[10][10][9] = {
{
{ {
{ 39, 53, 200, 87, 26, 21, 43, 232, 171 }, { 39, 53, 200, 87, 26, 21, 43, 232, 171 },
{ 56, 34, 51, 104, 114, 102, 29, 93, 77 }, { 56, 34, 51, 104, 114, 102, 29, 93, 77 },
@ -248,50 +248,57 @@ static const uint8_t vp8_pred4x4_prob_intra[10][10][9] =
}, },
}; };
static const int8_t vp8_segmentid_tree[][2] = static const int8_t vp8_segmentid_tree[][2] = {
{ { 1, 2 },
{ 1, 2 }, { -0, -1 }, // '00', '01'
{ -0, -1 }, // '00', '01' { -2, -3 }, // '10', '11'
{ -2, -3 }, // '10', '11'
}; };
static const uint8_t vp8_coeff_band[16] = static const uint8_t vp8_coeff_band[16] = {
{
0, 1, 2, 3, 6, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7 0, 1, 2, 3, 6, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7
}; };
/* Inverse of vp8_coeff_band: mappings of bands to coefficient indexes. /* Inverse of vp8_coeff_band: mappings of bands to coefficient indexes.
* Each list is -1-terminated. */ * Each list is -1-terminated. */
static const int8_t vp8_coeff_band_indexes[8][10] = static const int8_t vp8_coeff_band_indexes[8][10] = {
{ { 0, -1 },
{0, -1}, { 1, -1 },
{1, -1}, { 2, -1 },
{2, -1}, { 3, -1 },
{3, -1}, { 5, -1 },
{5, -1}, { 6, -1 },
{6, -1}, { 4, 7, 8, 9, 10, 11, 12, 13, 14, -1 },
{4, 7, 8, 9, 10, 11, 12, 13, 14, -1}, { 15, -1 }
{15, -1}
}; };
static const uint8_t vp8_dct_cat1_prob[] = { 159, 0 }; static const uint8_t vp8_dct_cat1_prob[] = {
static const uint8_t vp8_dct_cat2_prob[] = { 165, 145, 0 }; 159, 0
static const uint8_t vp8_dct_cat3_prob[] = { 173, 148, 140, 0 }; };
static const uint8_t vp8_dct_cat4_prob[] = { 176, 155, 140, 135, 0 }; static const uint8_t vp8_dct_cat2_prob[] = {
static const uint8_t vp8_dct_cat5_prob[] = { 180, 157, 141, 134, 130, 0 }; 165, 145, 0
static const uint8_t vp8_dct_cat6_prob[] = { 254, 254, 243, 230, 196, 177, 153, 140, 133, 130, 129, 0 }; };
static const uint8_t vp8_dct_cat3_prob[] = {
173, 148, 140, 0
};
static const uint8_t vp8_dct_cat4_prob[] = {
176, 155, 140, 135, 0
};
static const uint8_t vp8_dct_cat5_prob[] = {
180, 157, 141, 134, 130, 0
};
static const uint8_t vp8_dct_cat6_prob[] = {
254, 254, 243, 230, 196, 177, 153, 140, 133, 130, 129, 0
};
// only used for cat3 and above; cat 1 and 2 are referenced directly // only used for cat3 and above; cat 1 and 2 are referenced directly
const uint8_t * const ff_vp8_dct_cat_prob[] = const uint8_t *const ff_vp8_dct_cat_prob[] = {
{
vp8_dct_cat3_prob, vp8_dct_cat3_prob,
vp8_dct_cat4_prob, vp8_dct_cat4_prob,
vp8_dct_cat5_prob, vp8_dct_cat5_prob,
vp8_dct_cat6_prob, vp8_dct_cat6_prob,
}; };
static const uint8_t vp8_token_default_probs[4][8][3][NUM_DCT_TOKENS-1] = static const uint8_t vp8_token_default_probs[4][8][3][NUM_DCT_TOKENS - 1] = {
{
{ {
{ {
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 }, { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 },
@ -462,8 +469,7 @@ static const uint8_t vp8_token_default_probs[4][8][3][NUM_DCT_TOKENS-1] =
}, },
}; };
static const uint8_t vp8_token_update_probs[4][8][3][NUM_DCT_TOKENS-1] = static const uint8_t vp8_token_update_probs[4][8][3][NUM_DCT_TOKENS - 1] = {
{
{ {
{ {
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 }, { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 },
@ -635,15 +641,14 @@ static const uint8_t vp8_token_update_probs[4][8][3][NUM_DCT_TOKENS-1] =
}; };
// fixme: copied from h264data.h // fixme: copied from h264data.h
static const uint8_t zigzag_scan[16]={ static const uint8_t zigzag_scan[16] = {
0+0*4, 1+0*4, 0+1*4, 0+2*4, 0 + 0 * 4, 1 + 0 * 4, 0 + 1 * 4, 0 + 2 * 4,
1+1*4, 2+0*4, 3+0*4, 2+1*4, 1 + 1 * 4, 2 + 0 * 4, 3 + 0 * 4, 2 + 1 * 4,
1+2*4, 0+3*4, 1+3*4, 2+2*4, 1 + 2 * 4, 0 + 3 * 4, 1 + 3 * 4, 2 + 2 * 4,
3+1*4, 3+2*4, 2+3*4, 3+3*4, 3 + 1 * 4, 3 + 2 * 4, 2 + 3 * 4, 3 + 3 * 4,
}; };
static const uint8_t vp8_dc_qlookup[VP8_MAX_QUANT+1] = static const uint8_t vp8_dc_qlookup[VP8_MAX_QUANT + 1] = {
{
4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 17, 4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 17,
18, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 25, 25, 26, 27, 28, 18, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 25, 25, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43,
@ -654,8 +659,7 @@ static const uint8_t vp8_dc_qlookup[VP8_MAX_QUANT+1] =
122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 143, 145, 148, 151, 154, 157, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 143, 145, 148, 151, 154, 157,
}; };
static const uint16_t vp8_ac_qlookup[VP8_MAX_QUANT+1] = static const uint16_t vp8_ac_qlookup[VP8_MAX_QUANT + 1] = {
{
4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,

566
libavcodec/vp8dsp.c
Unescape View File

@ -24,9 +24,10 @@
* VP8 compatible video decoder * VP8 compatible video decoder
*/ */
#include "libavutil/common.h"
#include "mathops.h" #include "mathops.h"
#include "vp8dsp.h" #include "vp8dsp.h"
#include "libavutil/common.h"
// TODO: Maybe add dequant // TODO: Maybe add dequant
static void vp8_luma_dc_wht_c(int16_t block[4][4][16], int16_t dc[16]) static void vp8_luma_dc_wht_c(int16_t block[4][4][16], int16_t dc[16])
@ -34,26 +35,26 @@ static void vp8_luma_dc_wht_c(int16_t block[4][4][16], int16_t dc[16])
int i, t0, t1, t2, t3; int i, t0, t1, t2, t3;
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
t0 = dc[0*4+i] + dc[3*4+i]; t0 = dc[0 * 4 + i] + dc[3 * 4 + i];
t1 = dc[1*4+i] + dc[2*4+i]; t1 = dc[1 * 4 + i] + dc[2 * 4 + i];
t2 = dc[1*4+i] - dc[2*4+i]; t2 = dc[1 * 4 + i] - dc[2 * 4 + i];
t3 = dc[0*4+i] - dc[3*4+i]; t3 = dc[0 * 4 + i] - dc[3 * 4 + i];
dc[0*4+i] = t0 + t1; dc[0 * 4 + i] = t0 + t1;
dc[1*4+i] = t3 + t2; dc[1 * 4 + i] = t3 + t2;
dc[2*4+i] = t0 - t1; dc[2 * 4 + i] = t0 - t1;
dc[3*4+i] = t3 - t2; dc[3 * 4 + i] = t3 - t2;
} }
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
t0 = dc[i*4+0] + dc[i*4+3] + 3; // rounding t0 = dc[i * 4 + 0] + dc[i * 4 + 3] + 3; // rounding
t1 = dc[i*4+1] + dc[i*4+2]; t1 = dc[i * 4 + 1] + dc[i * 4 + 2];
t2 = dc[i*4+1] - dc[i*4+2]; t2 = dc[i * 4 + 1] - dc[i * 4 + 2];
t3 = dc[i*4+0] - dc[i*4+3] + 3; // rounding t3 = dc[i * 4 + 0] - dc[i * 4 + 3] + 3; // rounding
dc[i*4+0] = 0; dc[i * 4 + 0] = 0;
dc[i*4+1] = 0; dc[i * 4 + 1] = 0;
dc[i*4+2] = 0; dc[i * 4 + 2] = 0;
dc[i*4+3] = 0; dc[i * 4 + 3] = 0;
block[i][0][0] = (t0 + t1) >> 3; block[i][0][0] = (t0 + t1) >> 3;
block[i][1][0] = (t3 + t2) >> 3; block[i][1][0] = (t3 + t2) >> 3;
@ -75,8 +76,8 @@ static void vp8_luma_dc_wht_dc_c(int16_t block[4][4][16], int16_t dc[16])
} }
} }
#define MUL_20091(a) ((((a)*20091) >> 16) + (a)) #define MUL_20091(a) ((((a) * 20091) >> 16) + (a))
#define MUL_35468(a) (((a)*35468) >> 16) #define MUL_35468(a) (((a) * 35468) >> 16)
static void vp8_idct_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride) static void vp8_idct_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
{ {
@ -84,32 +85,32 @@ static void vp8_idct_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
int16_t tmp[16]; int16_t tmp[16];
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
t0 = block[0*4+i] + block[2*4+i]; t0 = block[0 * 4 + i] + block[2 * 4 + i];
t1 = block[0*4+i] - block[2*4+i]; t1 = block[0 * 4 + i] - block[2 * 4 + i];
t2 = MUL_35468(block[1*4+i]) - MUL_20091(block[3*4+i]); t2 = MUL_35468(block[1 * 4 + i]) - MUL_20091(block[3 * 4 + i]);
t3 = MUL_20091(block[1*4+i]) + MUL_35468(block[3*4+i]); t3 = MUL_20091(block[1 * 4 + i]) + MUL_35468(block[3 * 4 + i]);
block[0*4+i] = 0; block[0 * 4 + i] = 0;
block[1*4+i] = 0; block[1 * 4 + i] = 0;
block[2*4+i] = 0; block[2 * 4 + i] = 0;
block[3*4+i] = 0; block[3 * 4 + i] = 0;
tmp[i*4+0] = t0 + t3; tmp[i * 4 + 0] = t0 + t3;
tmp[i*4+1] = t1 + t2; tmp[i * 4 + 1] = t1 + t2;
tmp[i*4+2] = t1 - t2; tmp[i * 4 + 2] = t1 - t2;
tmp[i*4+3] = t0 - t3; tmp[i * 4 + 3] = t0 - t3;
} }
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
t0 = tmp[0*4+i] + tmp[2*4+i]; t0 = tmp[0 * 4 + i] + tmp[2 * 4 + i];
t1 = tmp[0*4+i] - tmp[2*4+i]; t1 = tmp[0 * 4 + i] - tmp[2 * 4 + i];
t2 = MUL_35468(tmp[1*4+i]) - MUL_20091(tmp[3*4+i]); t2 = MUL_35468(tmp[1 * 4 + i]) - MUL_20091(tmp[3 * 4 + i]);
t3 = MUL_20091(tmp[1*4+i]) + MUL_35468(tmp[3*4+i]); t3 = MUL_20091(tmp[1 * 4 + i]) + MUL_35468(tmp[3 * 4 + i]);
dst[0] = av_clip_uint8(dst[0] + ((t0 + t3 + 4) >> 3)); dst[0] = av_clip_uint8(dst[0] + ((t0 + t3 + 4) >> 3));
dst[1] = av_clip_uint8(dst[1] + ((t1 + t2 + 4) >> 3)); dst[1] = av_clip_uint8(dst[1] + ((t1 + t2 + 4) >> 3));
dst[2] = av_clip_uint8(dst[2] + ((t1 - t2 + 4) >> 3)); dst[2] = av_clip_uint8(dst[2] + ((t1 - t2 + 4) >> 3));
dst[3] = av_clip_uint8(dst[3] + ((t0 - t3 + 4) >> 3)); dst[3] = av_clip_uint8(dst[3] + ((t0 - t3 + 4) >> 3));
dst += stride; dst += stride;
} }
} }
@ -123,46 +124,49 @@ static void vp8_idct_dc_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
dst[1] = av_clip_uint8(dst[1] + dc); dst[1] = av_clip_uint8(dst[1] + dc);
dst[2] = av_clip_uint8(dst[2] + dc); dst[2] = av_clip_uint8(dst[2] + dc);
dst[3] = av_clip_uint8(dst[3] + dc); dst[3] = av_clip_uint8(dst[3] + dc);
dst += stride; dst += stride;
} }
} }
static void vp8_idct_dc_add4uv_c(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride) static void vp8_idct_dc_add4uv_c(uint8_t *dst, int16_t block[4][16],
ptrdiff_t stride)
{ {
vp8_idct_dc_add_c(dst+stride*0+0, block[0], stride); vp8_idct_dc_add_c(dst + stride * 0 + 0, block[0], stride);
vp8_idct_dc_add_c(dst+stride*0+4, block[1], stride); vp8_idct_dc_add_c(dst + stride * 0 + 4, block[1], stride);
vp8_idct_dc_add_c(dst+stride*4+0, block[2], stride); vp8_idct_dc_add_c(dst + stride * 4 + 0, block[2], stride);
vp8_idct_dc_add_c(dst+stride*4+4, block[3], stride); vp8_idct_dc_add_c(dst + stride * 4 + 4, block[3], stride);
} }
static void vp8_idct_dc_add4y_c(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride) static void vp8_idct_dc_add4y_c(uint8_t *dst, int16_t block[4][16],
ptrdiff_t stride)
{ {
vp8_idct_dc_add_c(dst+ 0, block[0], stride); vp8_idct_dc_add_c(dst + 0, block[0], stride);
vp8_idct_dc_add_c(dst+ 4, block[1], stride); vp8_idct_dc_add_c(dst + 4, block[1], stride);
vp8_idct_dc_add_c(dst+ 8, block[2], stride); vp8_idct_dc_add_c(dst + 8, block[2], stride);
vp8_idct_dc_add_c(dst+12, block[3], stride); vp8_idct_dc_add_c(dst + 12, block[3], stride);
} }
// because I like only having two parameters to pass functions... // because I like only having two parameters to pass functions...
#define LOAD_PIXELS\ #define LOAD_PIXELS \
int av_unused p3 = p[-4*stride];\ int av_unused p3 = p[-4 * stride]; \
int av_unused p2 = p[-3*stride];\ int av_unused p2 = p[-3 * stride]; \
int av_unused p1 = p[-2*stride];\ int av_unused p1 = p[-2 * stride]; \
int av_unused p0 = p[-1*stride];\ int av_unused p0 = p[-1 * stride]; \
int av_unused q0 = p[ 0*stride];\ int av_unused q0 = p[ 0 * stride]; \
int av_unused q1 = p[ 1*stride];\ int av_unused q1 = p[ 1 * stride]; \
int av_unused q2 = p[ 2*stride];\ int av_unused q2 = p[ 2 * stride]; \
int av_unused q3 = p[ 3*stride]; int av_unused q3 = p[ 3 * stride];
#define clip_int8(n) (cm[n+0x80]-0x80) #define clip_int8(n) (cm[n + 0x80] - 0x80)
static av_always_inline void filter_common(uint8_t *p, ptrdiff_t stride, int is4tap) static av_always_inline void filter_common(uint8_t *p, ptrdiff_t stride,
int is4tap)
{ {
LOAD_PIXELS LOAD_PIXELS
int a, f1, f2; int a, f1, f2;
const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP; const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;
a = 3*(q0 - p0); a = 3 * (q0 - p0);
if (is4tap) if (is4tap)
a += clip_int8(p1 - q1); a += clip_int8(p1 - q1);
@ -171,45 +175,50 @@ static av_always_inline void filter_common(uint8_t *p, ptrdiff_t stride, int is4
// We deviate from the spec here with c(a+3) >> 3 // We deviate from the spec here with c(a+3) >> 3
// since that's what libvpx does. // since that's what libvpx does.
f1 = FFMIN(a+4, 127) >> 3; f1 = FFMIN(a + 4, 127) >> 3;
f2 = FFMIN(a+3, 127) >> 3; f2 = FFMIN(a + 3, 127) >> 3;
// Despite what the spec says, we do need to clamp here to // Despite what the spec says, we do need to clamp here to
// be bitexact with libvpx. // be bitexact with libvpx.
p[-1*stride] = cm[p0 + f2]; p[-1 * stride] = cm[p0 + f2];
p[ 0*stride] = cm[q0 - f1]; p[ 0 * stride] = cm[q0 - f1];
// only used for _inner on blocks without high edge variance // only used for _inner on blocks without high edge variance
if (!is4tap) { if (!is4tap) {
a = (f1+1)>>1; a = (f1 + 1) >> 1;
p[-2*stride] = cm[p1 + a]; p[-2 * stride] = cm[p1 + a];
p[ 1*stride] = cm[q1 - a]; p[ 1 * stride] = cm[q1 - a];
} }
} }
static av_always_inline int simple_limit(uint8_t *p, ptrdiff_t stride, int flim) static av_always_inline int simple_limit(uint8_t *p, ptrdiff_t stride, int flim)
{ {
LOAD_PIXELS LOAD_PIXELS
return 2*FFABS(p0-q0) + (FFABS(p1-q1) >> 1) <= flim; return 2 * FFABS(p0 - q0) + (FFABS(p1 - q1) >> 1) <= flim;
} }
/** /**
* E - limit at the macroblock edge * E - limit at the macroblock edge
* I - limit for interior difference * I - limit for interior difference
*/ */
static av_always_inline int normal_limit(uint8_t *p, ptrdiff_t stride, int E, int I) static av_always_inline int normal_limit(uint8_t *p, ptrdiff_t stride,
int E, int I)
{ {
LOAD_PIXELS LOAD_PIXELS
return simple_limit(p, stride, E) return simple_limit(p, stride, E) &&
&& FFABS(p3-p2) <= I && FFABS(p2-p1) <= I && FFABS(p1-p0) <= I FFABS(p3 - p2) <= I &&
&& FFABS(q3-q2) <= I && FFABS(q2-q1) <= I && FFABS(q1-q0) <= I; FFABS(p2 - p1) <= I &&
FFABS(p1 - p0) <= I &&
FFABS(q3 - q2) <= I &&
FFABS(q2 - q1) <= I &&
FFABS(q1 - q0) <= I;
} }
// high edge variance // high edge variance
static av_always_inline int hev(uint8_t *p, ptrdiff_t stride, int thresh) static av_always_inline int hev(uint8_t *p, ptrdiff_t stride, int thresh)
{ {
LOAD_PIXELS LOAD_PIXELS
return FFABS(p1-p0) > thresh || FFABS(q1-q0) > thresh; return FFABS(p1 - p0) > thresh || FFABS(q1 - q0) > thresh;
} }
static av_always_inline void filter_mbedge(uint8_t *p, ptrdiff_t stride) static av_always_inline void filter_mbedge(uint8_t *p, ptrdiff_t stride)
@ -219,67 +228,75 @@ static av_always_inline void filter_mbedge(uint8_t *p, ptrdiff_t stride)
LOAD_PIXELS LOAD_PIXELS
w = clip_int8(p1-q1); w = clip_int8(p1 - q1);
w = clip_int8(w + 3*(q0-p0)); w = clip_int8(w + 3 * (q0 - p0));
a0 = (27*w + 63) >> 7; a0 = (27 * w + 63) >> 7;
a1 = (18*w + 63) >> 7; a1 = (18 * w + 63) >> 7;
a2 = ( 9*w + 63) >> 7; a2 = (9 * w + 63) >> 7;
p[-3*stride] = cm[p2 + a2]; p[-3 * stride] = cm[p2 + a2];
p[-2*stride] = cm[p1 + a1]; p[-2 * stride] = cm[p1 + a1];
p[-1*stride] = cm[p0 + a0]; p[-1 * stride] = cm[p0 + a0];
p[ 0*stride] = cm[q0 - a0]; p[ 0 * stride] = cm[q0 - a0];
p[ 1*stride] = cm[q1 - a1]; p[ 1 * stride] = cm[q1 - a1];
p[ 2*stride] = cm[q2 - a2]; p[ 2 * stride] = cm[q2 - a2];
} }
#define LOOP_FILTER(dir, size, stridea, strideb, maybe_inline) \ #define LOOP_FILTER(dir, size, stridea, strideb, maybe_inline) \
static maybe_inline void vp8_ ## dir ## _loop_filter ## size ## _c(uint8_t *dst, ptrdiff_t stride,\ static maybe_inline \
int flim_E, int flim_I, int hev_thresh)\ void vp8_ ## dir ## _loop_filter ## size ## _c(uint8_t *dst, \
{\ ptrdiff_t stride, \
int i;\ int flim_E, int flim_I, \
\ int hev_thresh) \
for (i = 0; i < size; i++)\ { \
if (normal_limit(dst+i*stridea, strideb, flim_E, flim_I)) {\ int i; \
if (hev(dst+i*stridea, strideb, hev_thresh))\ for (i = 0; i < size; i++) \
filter_common(dst+i*stridea, strideb, 1);\ if (normal_limit(dst + i * stridea, strideb, flim_E, flim_I)) { \
else\ if (hev(dst + i * stridea, strideb, hev_thresh)) \
filter_mbedge(dst+i*stridea, strideb);\ filter_common(dst + i * stridea, strideb, 1); \
}\ else \
}\ filter_mbedge(dst + i * stridea, strideb); \
\ } \
static maybe_inline void vp8_ ## dir ## _loop_filter ## size ## _inner_c(uint8_t *dst, ptrdiff_t stride,\ } \
int flim_E, int flim_I, int hev_thresh)\ \
{\ static maybe_inline \
int i;\ void vp8_ ## dir ## _loop_filter ## size ## _inner_c(uint8_t *dst, \
\ ptrdiff_t stride, \
for (i = 0; i < size; i++)\ int flim_E, int flim_I, \
if (normal_limit(dst+i*stridea, strideb, flim_E, flim_I)) {\ int hev_thresh) \
int hv = hev(dst+i*stridea, strideb, hev_thresh);\ { \
if (hv) \ int i; \
filter_common(dst+i*stridea, strideb, 1);\ for (i = 0; i < size; i++) \
else \ if (normal_limit(dst + i * stridea, strideb, flim_E, flim_I)) { \
filter_common(dst+i*stridea, strideb, 0);\ int hv = hev(dst + i * stridea, strideb, hev_thresh); \
}\ if (hv) \
filter_common(dst + i * stridea, strideb, 1); \
else \
filter_common(dst + i * stridea, strideb, 0); \
} \
} }
LOOP_FILTER(v, 16, 1, stride,) LOOP_FILTER(v, 16, 1, stride, )
LOOP_FILTER(h, 16, stride, 1,) LOOP_FILTER(h, 16, stride, 1, )
#define UV_LOOP_FILTER(dir, stridea, strideb) \ #define UV_LOOP_FILTER(dir, stridea, strideb) \
LOOP_FILTER(dir, 8, stridea, strideb, av_always_inline) \ LOOP_FILTER(dir, 8, stridea, strideb, av_always_inline) \
static void vp8_ ## dir ## _loop_filter8uv_c(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride,\ static void vp8_ ## dir ## _loop_filter8uv_c(uint8_t *dstU, uint8_t *dstV, \
int fE, int fI, int hev_thresh)\ ptrdiff_t stride, int fE, \
{\ int fI, int hev_thresh) \
vp8_ ## dir ## _loop_filter8_c(dstU, stride, fE, fI, hev_thresh);\ { \
vp8_ ## dir ## _loop_filter8_c(dstV, stride, fE, fI, hev_thresh);\ vp8_ ## dir ## _loop_filter8_c(dstU, stride, fE, fI, hev_thresh); \
}\ vp8_ ## dir ## _loop_filter8_c(dstV, stride, fE, fI, hev_thresh); \
static void vp8_ ## dir ## _loop_filter8uv_inner_c(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride,\ } \
int fE, int fI, int hev_thresh)\ \
{\ static void vp8_ ## dir ## _loop_filter8uv_inner_c(uint8_t *dstU, \
vp8_ ## dir ## _loop_filter8_inner_c(dstU, stride, fE, fI, hev_thresh);\ uint8_t *dstV, \
vp8_ ## dir ## _loop_filter8_inner_c(dstV, stride, fE, fI, hev_thresh);\ ptrdiff_t stride, int fE, \
int fI, int hev_thresh) \
{ \
vp8_ ## dir ## _loop_filter8_inner_c(dstU, stride, fE, fI, hev_thresh); \
vp8_ ## dir ## _loop_filter8_inner_c(dstV, stride, fE, fI, hev_thresh); \
} }
UV_LOOP_FILTER(v, 1, stride) UV_LOOP_FILTER(v, 1, stride)
@ -290,8 +307,8 @@ static void vp8_v_loop_filter_simple_c(uint8_t *dst, ptrdiff_t stride, int flim)
int i; int i;
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
if (simple_limit(dst+i, stride, flim)) if (simple_limit(dst + i, stride, flim))
filter_common(dst+i, stride, 1); filter_common(dst + i, stride, 1);
} }
static void vp8_h_loop_filter_simple_c(uint8_t *dst, ptrdiff_t stride, int flim) static void vp8_h_loop_filter_simple_c(uint8_t *dst, ptrdiff_t stride, int flim)
@ -299,94 +316,110 @@ static void vp8_h_loop_filter_simple_c(uint8_t *dst, ptrdiff_t stride, int flim)
int i; int i;
for (i = 0; i < 16; i++) for (i = 0; i < 16; i++)
if (simple_limit(dst+i*stride, 1, flim)) if (simple_limit(dst + i * stride, 1, flim))
filter_common(dst+i*stride, 1, 1); filter_common(dst + i * stride, 1, 1);
} }
static const uint8_t subpel_filters[7][6] = { static const uint8_t subpel_filters[7][6] = {
{ 0, 6, 123, 12, 1, 0 }, { 0, 6, 123, 12, 1, 0 },
{ 2, 11, 108, 36, 8, 1 }, { 2, 11, 108, 36, 8, 1 },
{ 0, 9, 93, 50, 6, 0 }, { 0, 9, 93, 50, 6, 0 },
{ 3, 16, 77, 77, 16, 3 }, { 3, 16, 77, 77, 16, 3 },
{ 0, 6, 50, 93, 9, 0 }, { 0, 6, 50, 93, 9, 0 },
{ 1, 8, 36, 108, 11, 2 }, { 1, 8, 36, 108, 11, 2 },
{ 0, 1, 12, 123, 6, 0 }, { 0, 1, 12, 123, 6, 0 },
}; };
#define PUT_PIXELS(WIDTH) \ #define PUT_PIXELS(WIDTH) \
static void put_vp8_pixels ## WIDTH ##_c(uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride, int h, int x, int y) { \ static void put_vp8_pixels ## WIDTH ## _c(uint8_t *dst, ptrdiff_t dststride, \
int i; \ uint8_t *src, ptrdiff_t srcstride, \
for (i = 0; i < h; i++, dst+= dststride, src+= srcstride) { \ int h, int x, int y) \
memcpy(dst, src, WIDTH); \ { \
} \ int i; \
for (i = 0; i < h; i++, dst += dststride, src += srcstride) \
memcpy(dst, src, WIDTH); \
} }
PUT_PIXELS(16) PUT_PIXELS(16)
PUT_PIXELS(8) PUT_PIXELS(8)
PUT_PIXELS(4) PUT_PIXELS(4)
#define FILTER_6TAP(src, F, stride) \ #define FILTER_6TAP(src, F, stride) \
cm[(F[2]*src[x+0*stride] - F[1]*src[x-1*stride] + F[0]*src[x-2*stride] + \ cm[(F[2] * src[x + 0 * stride] - F[1] * src[x - 1 * stride] + \
F[3]*src[x+1*stride] - F[4]*src[x+2*stride] + F[5]*src[x+3*stride] + 64) >> 7] F[0] * src[x - 2 * stride] + F[3] * src[x + 1 * stride] - \
F[4] * src[x + 2 * stride] + F[5] * src[x + 3 * stride] + 64) >> 7]
#define FILTER_4TAP(src, F, stride) \
cm[(F[2]*src[x+0*stride] - F[1]*src[x-1*stride] + \ #define FILTER_4TAP(src, F, stride) \
F[3]*src[x+1*stride] - F[4]*src[x+2*stride] + 64) >> 7] cm[(F[2] * src[x + 0 * stride] - F[1] * src[x - 1 * stride] + \
F[3] * src[x + 1 * stride] - F[4] * src[x + 2 * stride] + 64) >> 7]
#define VP8_EPEL_H(SIZE, TAPS) \
static void put_vp8_epel ## SIZE ## _h ## TAPS ## _c(uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my) \ #define VP8_EPEL_H(SIZE, TAPS) \
{ \ static void put_vp8_epel ## SIZE ## _h ## TAPS ## _c(uint8_t *dst, \
const uint8_t *filter = subpel_filters[mx-1]; \ ptrdiff_t dststride, \
const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP; \ uint8_t *src, \
int x, y; \ ptrdiff_t srcstride, \
\ int h, int mx, int my) \
for (y = 0; y < h; y++) { \ { \
for (x = 0; x < SIZE; x++) \ const uint8_t *filter = subpel_filters[mx - 1]; \
dst[x] = FILTER_ ## TAPS ## TAP(src, filter, 1); \ const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP; \
dst += dststride; \ int x, y; \
src += srcstride; \ for (y = 0; y < h; y++) { \
} \ for (x = 0; x < SIZE; x++) \
dst[x] = FILTER_ ## TAPS ## TAP(src, filter, 1); \
dst += dststride; \
src += srcstride; \
} \
} }
#define VP8_EPEL_V(SIZE, TAPS) \
static void put_vp8_epel ## SIZE ## _v ## TAPS ## _c(uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my) \ #define VP8_EPEL_V(SIZE, TAPS) \
{ \ static void put_vp8_epel ## SIZE ## _v ## TAPS ## _c(uint8_t *dst, \
const uint8_t *filter = subpel_filters[my-1]; \ ptrdiff_t dststride, \
const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP; \ uint8_t *src, \
int x, y; \ ptrdiff_t srcstride, \
\ int h, int mx, int my) \
for (y = 0; y < h; y++) { \ { \
for (x = 0; x < SIZE; x++) \ const uint8_t *filter = subpel_filters[my - 1]; \
dst[x] = FILTER_ ## TAPS ## TAP(src, filter, srcstride); \ const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP; \
dst += dststride; \ int x, y; \
src += srcstride; \ for (y = 0; y < h; y++) { \
} \ for (x = 0; x < SIZE; x++) \
dst[x] = FILTER_ ## TAPS ## TAP(src, filter, srcstride); \
dst += dststride; \
src += srcstride; \
} \
} }
#define VP8_EPEL_HV(SIZE, HTAPS, VTAPS) \
static void put_vp8_epel ## SIZE ## _h ## HTAPS ## v ## VTAPS ## _c(uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my) \ #define VP8_EPEL_HV(SIZE, HTAPS, VTAPS) \
{ \ static void \
const uint8_t *filter = subpel_filters[mx-1]; \ put_vp8_epel ## SIZE ## _h ## HTAPS ## v ## VTAPS ## _c(uint8_t *dst, \
const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP; \ ptrdiff_t dststride, \
int x, y; \ uint8_t *src, \
uint8_t tmp_array[(2*SIZE+VTAPS-1)*SIZE]; \ ptrdiff_t srcstride, \
uint8_t *tmp = tmp_array; \ int h, int mx, \
src -= (2-(VTAPS==4))*srcstride; \ int my) \
\ { \
for (y = 0; y < h+VTAPS-1; y++) { \ const uint8_t *filter = subpel_filters[mx - 1]; \
for (x = 0; x < SIZE; x++) \ const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP; \
tmp[x] = FILTER_ ## HTAPS ## TAP(src, filter, 1); \ int x, y; \
tmp += SIZE; \ uint8_t tmp_array[(2 * SIZE + VTAPS - 1) * SIZE]; \
src += srcstride; \ uint8_t *tmp = tmp_array; \
} \ src -= (2 - (VTAPS == 4)) * srcstride; \
\ \
tmp = tmp_array + (2-(VTAPS==4))*SIZE; \ for (y = 0; y < h + VTAPS - 1; y++) { \
filter = subpel_filters[my-1]; \ for (x = 0; x < SIZE; x++) \
\ tmp[x] = FILTER_ ## HTAPS ## TAP(src, filter, 1); \
for (y = 0; y < h; y++) { \ tmp += SIZE; \
for (x = 0; x < SIZE; x++) \ src += srcstride; \
dst[x] = FILTER_ ## VTAPS ## TAP(tmp, filter, SIZE); \ } \
dst += dststride; \ tmp = tmp_array + (2 - (VTAPS == 4)) * SIZE; \
tmp += SIZE; \ filter = subpel_filters[my - 1]; \
} \ \
for (y = 0; y < h; y++) { \
for (x = 0; x < SIZE; x++) \
dst[x] = FILTER_ ## VTAPS ## TAP(tmp, filter, SIZE); \
dst += dststride; \
tmp += SIZE; \
} \
} }
VP8_EPEL_H(16, 4) VP8_EPEL_H(16, 4)
@ -401,6 +434,7 @@ VP8_EPEL_V(4, 4)
VP8_EPEL_V(16, 6) VP8_EPEL_V(16, 6)
VP8_EPEL_V(8, 6) VP8_EPEL_V(8, 6)
VP8_EPEL_V(4, 6) VP8_EPEL_V(4, 6)
VP8_EPEL_HV(16, 4, 4) VP8_EPEL_HV(16, 4, 4)
VP8_EPEL_HV(8, 4, 4) VP8_EPEL_HV(8, 4, 4)
VP8_EPEL_HV(4, 4, 4) VP8_EPEL_HV(4, 4, 4)
@ -414,73 +448,77 @@ VP8_EPEL_HV(16, 6, 6)
VP8_EPEL_HV(8, 6, 6) VP8_EPEL_HV(8, 6, 6)
VP8_EPEL_HV(4, 6, 6) VP8_EPEL_HV(4, 6, 6)
#define VP8_BILINEAR(SIZE) \ #define VP8_BILINEAR(SIZE) \
static void put_vp8_bilinear ## SIZE ## _h_c(uint8_t *dst, ptrdiff_t dstride, uint8_t *src, ptrdiff_t sstride, int h, int mx, int my) \ static void put_vp8_bilinear ## SIZE ## _h_c(uint8_t *dst, ptrdiff_t dstride, \
{ \ uint8_t *src, ptrdiff_t sstride, \
int a = 8-mx, b = mx; \ int h, int mx, int my) \
int x, y; \ { \
\ int a = 8 - mx, b = mx; \
for (y = 0; y < h; y++) { \ int x, y; \
for (x = 0; x < SIZE; x++) \ for (y = 0; y < h; y++) { \
dst[x] = (a*src[x] + b*src[x+1] + 4) >> 3; \ for (x = 0; x < SIZE; x++) \
dst += dstride; \ dst[x] = (a * src[x] + b * src[x + 1] + 4) >> 3; \
src += sstride; \ dst += dstride; \
} \ src += sstride; \
} \ } \
static void put_vp8_bilinear ## SIZE ## _v_c(uint8_t *dst, ptrdiff_t dstride, uint8_t *src, ptrdiff_t sstride, int h, int mx, int my) \ } \
{ \ \
int c = 8-my, d = my; \ static void put_vp8_bilinear ## SIZE ## _v_c(uint8_t *dst, ptrdiff_t dstride, \
int x, y; \ uint8_t *src, ptrdiff_t sstride, \
\ int h, int mx, int my) \
for (y = 0; y < h; y++) { \ { \
for (x = 0; x < SIZE; x++) \ int c = 8 - my, d = my; \
dst[x] = (c*src[x] + d*src[x+sstride] + 4) >> 3; \ int x, y; \
dst += dstride; \ for (y = 0; y < h; y++) { \
src += sstride; \ for (x = 0; x < SIZE; x++) \
} \ dst[x] = (c * src[x] + d * src[x + sstride] + 4) >> 3; \
} \ dst += dstride; \
\ src += sstride; \
static void put_vp8_bilinear ## SIZE ## _hv_c(uint8_t *dst, ptrdiff_t dstride, uint8_t *src, ptrdiff_t sstride, int h, int mx, int my) \ } \
{ \ } \
int a = 8-mx, b = mx; \ \
int c = 8-my, d = my; \ static void put_vp8_bilinear ## SIZE ## _hv_c(uint8_t *dst, \
int x, y; \ ptrdiff_t dstride, \
uint8_t tmp_array[(2*SIZE+1)*SIZE]; \ uint8_t *src, \
uint8_t *tmp = tmp_array; \ ptrdiff_t sstride, \
\ int h, int mx, int my) \
for (y = 0; y < h+1; y++) { \ { \
for (x = 0; x < SIZE; x++) \ int a = 8 - mx, b = mx; \
tmp[x] = (a*src[x] + b*src[x+1] + 4) >> 3; \ int c = 8 - my, d = my; \
tmp += SIZE; \ int x, y; \
src += sstride; \ uint8_t tmp_array[(2 * SIZE + 1) * SIZE]; \
} \ uint8_t *tmp = tmp_array; \
\ for (y = 0; y < h + 1; y++) { \
tmp = tmp_array; \ for (x = 0; x < SIZE; x++) \
\ tmp[x] = (a * src[x] + b * src[x + 1] + 4) >> 3; \
for (y = 0; y < h; y++) { \ tmp += SIZE; \
for (x = 0; x < SIZE; x++) \ src += sstride; \
dst[x] = (c*tmp[x] + d*tmp[x+SIZE] + 4) >> 3; \ } \
dst += dstride; \ tmp = tmp_array; \
tmp += SIZE; \ for (y = 0; y < h; y++) { \
} \ for (x = 0; x < SIZE; x++) \
dst[x] = (c * tmp[x] + d * tmp[x + SIZE] + 4) >> 3; \
dst += dstride; \
tmp += SIZE; \
} \
} }
VP8_BILINEAR(16) VP8_BILINEAR(16)
VP8_BILINEAR(8) VP8_BILINEAR(8)
VP8_BILINEAR(4) VP8_BILINEAR(4)
#define VP8_MC_FUNC(IDX, SIZE) \ #define VP8_MC_FUNC(IDX, SIZE) \
dsp->put_vp8_epel_pixels_tab[IDX][0][0] = put_vp8_pixels ## SIZE ## _c; \ dsp->put_vp8_epel_pixels_tab[IDX][0][0] = put_vp8_pixels ## SIZE ## _c; \
dsp->put_vp8_epel_pixels_tab[IDX][0][1] = put_vp8_epel ## SIZE ## _h4_c; \ dsp->put_vp8_epel_pixels_tab[IDX][0][1] = put_vp8_epel ## SIZE ## _h4_c; \
dsp->put_vp8_epel_pixels_tab[IDX][0][2] = put_vp8_epel ## SIZE ## _h6_c; \ dsp->put_vp8_epel_pixels_tab[IDX][0][2] = put_vp8_epel ## SIZE ## _h6_c; \
dsp->put_vp8_epel_pixels_tab[IDX][1][0] = put_vp8_epel ## SIZE ## _v4_c; \ dsp->put_vp8_epel_pixels_tab[IDX][1][0] = put_vp8_epel ## SIZE ## _v4_c; \
dsp->put_vp8_epel_pixels_tab[IDX][1][1] = put_vp8_epel ## SIZE ## _h4v4_c; \ dsp->put_vp8_epel_pixels_tab[IDX][1][1] = put_vp8_epel ## SIZE ## _h4v4_c; \
dsp->put_vp8_epel_pixels_tab[IDX][1][2] = put_vp8_epel ## SIZE ## _h6v4_c; \ dsp->put_vp8_epel_pixels_tab[IDX][1][2] = put_vp8_epel ## SIZE ## _h6v4_c; \
dsp->put_vp8_epel_pixels_tab[IDX][2][0] = put_vp8_epel ## SIZE ## _v6_c; \ dsp->put_vp8_epel_pixels_tab[IDX][2][0] = put_vp8_epel ## SIZE ## _v6_c; \
dsp->put_vp8_epel_pixels_tab[IDX][2][1] = put_vp8_epel ## SIZE ## _h4v6_c; \ dsp->put_vp8_epel_pixels_tab[IDX][2][1] = put_vp8_epel ## SIZE ## _h4v6_c; \
dsp->put_vp8_epel_pixels_tab[IDX][2][2] = put_vp8_epel ## SIZE ## _h6v6_c dsp->put_vp8_epel_pixels_tab[IDX][2][2] = put_vp8_epel ## SIZE ## _h6v6_c
#define VP8_BILINEAR_MC_FUNC(IDX, SIZE) \ #define VP8_BILINEAR_MC_FUNC(IDX, SIZE) \
dsp->put_vp8_bilinear_pixels_tab[IDX][0][0] = put_vp8_pixels ## SIZE ## _c; \ dsp->put_vp8_bilinear_pixels_tab[IDX][0][0] = put_vp8_pixels ## SIZE ## _c; \
dsp->put_vp8_bilinear_pixels_tab[IDX][0][1] = put_vp8_bilinear ## SIZE ## _h_c; \ dsp->put_vp8_bilinear_pixels_tab[IDX][0][1] = put_vp8_bilinear ## SIZE ## _h_c; \
dsp->put_vp8_bilinear_pixels_tab[IDX][0][2] = put_vp8_bilinear ## SIZE ## _h_c; \ dsp->put_vp8_bilinear_pixels_tab[IDX][0][2] = put_vp8_bilinear ## SIZE ## _h_c; \

4
libavcodec/vp8dsp.h
Unescape View File

@ -30,8 +30,8 @@
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
typedef void (*vp8_mc_func)(uint8_t *dst/*align 8*/, ptrdiff_t dstStride, typedef void (*vp8_mc_func)(uint8_t *dst /* align 8 */, ptrdiff_t dstStride,
uint8_t *src/*align 1*/, ptrdiff_t srcStride, uint8_t *src /* align 1 */, ptrdiff_t srcStride,
int h, int x, int y); int h, int x, int y);
typedef struct VP8DSPContext { typedef struct VP8DSPContext {

Write Preview
Loading…
Cancel
Save