Browse code
Merge remote-tracking branch 'qatar/master'
* qatar/master:
fate: Add tests for more AAC features.
aacps: Add missing newline in error message.
fate: Add tests for vc1/wmapro in ism.
aacdec: Add a fate test for 5.1 channel SBR.
aacdec: Turn off PS for multichannel files that use PCE based configs.
cabac: remove put_cabac_u/ueg from cabac-test.
swscale: RGB4444 and BGR444 input
FATE: add test for xWMA demuxer.
FATE: add test for SMJPEG demuxer and associated IMA ADPCM audio decoder.
mpegaudiodec: optimized iMDCT transform
mpegaudiodec: change imdct window arrangment for better pointer alignment
mpegaudiodec: move imdct and windowing function to mpegaudiodsp
mpegaudiodec: interleave iMDCT buffer to simplify future SIMD implementations
swscale: convert yuy2/uyvy/nv12/nv21ToY/UV from inline asm to yasm.
FATE: test to exercise WTV demuxer.
mjpegdec: K&R formatting cosmetics
swscale: K&R formatting cosmetics for code examples
swscale: K&R reformatting cosmetics for header files
FATE test: cvid-grayscale; ensures that the grayscale Cinepak variant is exercised.
Conflicts:
libavcodec/cabac.c
libavcodec/mjpegdec.c
libavcodec/mpegaudiodec.c
libavcodec/mpegaudiodsp.c
libavcodec/mpegaudiodsp.h
libavcodec/mpegaudiodsp_template.c
libavcodec/x86/Makefile
libavcodec/x86/imdct36_sse.asm
libavcodec/x86/mpegaudiodec_mmx.c
libswscale/swscale-test.c
libswscale/swscale.c
libswscale/swscale_internal.h
libswscale/x86/swscale_template.c
tests/fate/demux.mak
tests/fate/microsoft.mak
tests/fate/video.mak
tests/fate/wma.mak
tests/ref/lavfi/pixfmts_scale
Merged-by: Michael Niedermayer <michaelni@gmx.at>
Michael Niedermayer authored on 2012/01/10 10:50:54Showing 38 changed files
- libavcodec/aac.h
- libavcodec/aacdec.c
- libavcodec/aacps.c
- libavcodec/cabac.c
- libavcodec/mpegaudiodec.c
- libavcodec/mpegaudiodsp.c
- libavcodec/mpegaudiodsp.h
- libavcodec/mpegaudiodsp_template.c
- libavcodec/x86/imdct36_sse.asm
- libavcodec/x86/mpegaudiodec_mmx.c
- libavutil/x86/x86inc.asm
- libswscale/Makefile
- libswscale/colorspace-test.c
- libswscale/ppc/yuv2rgb_altivec.h
- libswscale/rgb2rgb.h
- libswscale/swscale-test.c
- libswscale/swscale.c
- libswscale/swscale.h
- libswscale/swscale_internal.h
- libswscale/utils.c
- libswscale/x86/input.asm
- libswscale/x86/swscale_mmx.c
- libswscale/x86/swscale_template.c
- tests/fate/aac.mak
- tests/fate/demux.mak
- tests/fate/microsoft.mak
- tests/fate/video.mak
- tests/fate/wma.mak
- tests/ref/fate/cvid-grayscale
- tests/ref/fate/smjpeg
- tests/ref/fate/vc1-ism
- tests/ref/fate/wtv-demux
- tests/ref/fate/xwma-demux
- tests/ref/lavfi/pixdesc
- tests/ref/lavfi/pixfmts_copy
- tests/ref/lavfi/pixfmts_null
- tests/ref/lavfi/pixfmts_scale
- tests/ref/lavfi/pixfmts_vflip
| ... | ... |
@@ -163,6 +163,19 @@ static ChannelElement *get_che(AACContext *ac, int type, int elem_id) |
| 163 | 163 |
} |
| 164 | 164 |
} |
| 165 | 165 |
|
| 166 |
+static int count_channels(enum ChannelPosition che_pos[4][MAX_ELEM_ID]) |
|
| 167 |
+{
|
|
| 168 |
+ int i, type, sum = 0; |
|
| 169 |
+ for (i = 0; i < MAX_ELEM_ID; i++) {
|
|
| 170 |
+ for (type = 0; type < 4; type++) {
|
|
| 171 |
+ sum += (1 + (type == TYPE_CPE)) * |
|
| 172 |
+ (che_pos[type][i] != AAC_CHANNEL_OFF && |
|
| 173 |
+ che_pos[type][i] != AAC_CHANNEL_CC); |
|
| 174 |
+ } |
|
| 175 |
+ } |
|
| 176 |
+ return sum; |
|
| 177 |
+} |
|
| 178 |
+ |
|
| 166 | 179 |
/** |
| 167 | 180 |
* Check for the channel element in the current channel position configuration. |
| 168 | 181 |
* If it exists, make sure the appropriate element is allocated and map the |
| ... | ... |
@@ -437,6 +450,12 @@ static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx, |
| 437 | 437 |
if ((ret = set_default_channel_config(avctx, new_che_pos, channel_config))) |
| 438 | 438 |
return ret; |
| 439 | 439 |
} |
| 440 |
+ |
|
| 441 |
+ if (count_channels(new_che_pos) > 1) {
|
|
| 442 |
+ m4ac->ps = 0; |
|
| 443 |
+ } else if (m4ac->sbr == 1 && m4ac->ps == -1) |
|
| 444 |
+ m4ac->ps = 1; |
|
| 445 |
+ |
|
| 440 | 446 |
if (ac && (ret = output_configure(ac, ac->che_pos, new_che_pos, channel_config, OC_GLOBAL_HDR))) |
| 441 | 447 |
return ret; |
| 442 | 448 |
|
| ... | ... |
@@ -495,8 +514,6 @@ static int decode_audio_specific_config(AACContext *ac, |
| 495 | 495 |
av_log(avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", m4ac->sampling_index); |
| 496 | 496 |
return -1; |
| 497 | 497 |
} |
| 498 |
- if (m4ac->sbr == 1 && m4ac->ps == -1) |
|
| 499 |
- m4ac->ps = 1; |
|
| 500 | 498 |
|
| 501 | 499 |
skip_bits_long(&gb, i); |
| 502 | 500 |
|
| ... | ... |
@@ -223,7 +223,7 @@ int ff_ps_read_data(AVCodecContext *avctx, GetBitContext *gb_host, PSContext *ps |
| 223 | 223 |
cnt -= 2 + ps_read_extension_data(gb, ps, ps_extension_id); |
| 224 | 224 |
} |
| 225 | 225 |
if (cnt < 0) {
|
| 226 |
- av_log(avctx, AV_LOG_ERROR, "ps extension overflow %d", cnt); |
|
| 226 |
+ av_log(avctx, AV_LOG_ERROR, "ps extension overflow %d\n", cnt); |
|
| 227 | 227 |
goto err; |
| 228 | 228 |
} |
| 229 | 229 |
skip_bits(gb, cnt); |
| ... | ... |
@@ -252,67 +252,6 @@ static int put_cabac_terminate(CABACContext *c, int bit){
|
| 252 | 252 |
return (put_bits_count(&c->pb)+7)>>3; |
| 253 | 253 |
} |
| 254 | 254 |
|
| 255 |
-/** |
|
| 256 |
- * put (truncated) unary binarization. |
|
| 257 |
- */ |
|
| 258 |
-static void put_cabac_u(CABACContext *c, uint8_t * state, int v, int max, int max_index, int truncated){
|
|
| 259 |
- int i; |
|
| 260 |
- |
|
| 261 |
- assert(v <= max); |
|
| 262 |
- |
|
| 263 |
- for(i=0; i<v; i++){
|
|
| 264 |
- put_cabac(c, state, 1); |
|
| 265 |
- if(i < max_index) state++; |
|
| 266 |
- } |
|
| 267 |
- if(truncated==0 || v<max) |
|
| 268 |
- put_cabac(c, state, 0); |
|
| 269 |
-} |
|
| 270 |
- |
|
| 271 |
-/** |
|
| 272 |
- * put unary exp golomb k-th order binarization. |
|
| 273 |
- */ |
|
| 274 |
-static void put_cabac_ueg(CABACContext *c, uint8_t * state, int v, int max, int is_signed, int k, int max_index){
|
|
| 275 |
- int i; |
|
| 276 |
- |
|
| 277 |
- if(v==0) |
|
| 278 |
- put_cabac(c, state, 0); |
|
| 279 |
- else{
|
|
| 280 |
- const int sign= v < 0; |
|
| 281 |
- |
|
| 282 |
- if(is_signed) v= FFABS(v); |
|
| 283 |
- |
|
| 284 |
- if(v<max){
|
|
| 285 |
- for(i=0; i<v; i++){
|
|
| 286 |
- put_cabac(c, state, 1); |
|
| 287 |
- if(i < max_index) state++; |
|
| 288 |
- } |
|
| 289 |
- |
|
| 290 |
- put_cabac(c, state, 0); |
|
| 291 |
- }else{
|
|
| 292 |
- int m= 1<<k; |
|
| 293 |
- |
|
| 294 |
- for(i=0; i<max; i++){
|
|
| 295 |
- put_cabac(c, state, 1); |
|
| 296 |
- if(i < max_index) state++; |
|
| 297 |
- } |
|
| 298 |
- |
|
| 299 |
- v -= max; |
|
| 300 |
- while(v >= m){ //FIXME optimize
|
|
| 301 |
- put_cabac_bypass(c, 1); |
|
| 302 |
- v-= m; |
|
| 303 |
- m+= m; |
|
| 304 |
- } |
|
| 305 |
- put_cabac_bypass(c, 0); |
|
| 306 |
- while(m>>=1){
|
|
| 307 |
- put_cabac_bypass(c, v&m); |
|
| 308 |
- } |
|
| 309 |
- } |
|
| 310 |
- |
|
| 311 |
- if(is_signed) |
|
| 312 |
- put_cabac_bypass(c, sign); |
|
| 313 |
- } |
|
| 314 |
-} |
|
| 315 |
- |
|
| 316 | 255 |
int main(void){
|
| 317 | 256 |
CABACContext c; |
| 318 | 257 |
uint8_t b[9*SIZE]; |
| ... | ... |
@@ -342,19 +281,6 @@ START_TIMER |
| 342 | 342 |
STOP_TIMER("put_cabac")
|
| 343 | 343 |
} |
| 344 | 344 |
|
| 345 |
-#if 0 |
|
| 346 |
- for(i=0; i<SIZE; i++){
|
|
| 347 |
-START_TIMER |
|
| 348 |
- put_cabac_u(&c, state, r[i], 6, 3, i&1); |
|
| 349 |
-STOP_TIMER("put_cabac_u")
|
|
| 350 |
- } |
|
| 351 |
- |
|
| 352 |
- for(i=0; i<SIZE; i++){
|
|
| 353 |
-START_TIMER |
|
| 354 |
- put_cabac_ueg(&c, state, r[i], 3, 0, 1, 2); |
|
| 355 |
-STOP_TIMER("put_cabac_ueg")
|
|
| 356 |
- } |
|
| 357 |
-#endif |
|
| 358 | 345 |
put_cabac_terminate(&c, 1); |
| 359 | 346 |
|
| 360 | 347 |
ff_init_cabac_decoder(&c, b, SIZE); |
| ... | ... |
@@ -132,10 +132,6 @@ static uint16_t band_index_long[9][23]; |
| 132 | 132 |
static INTFLOAT is_table[2][16]; |
| 133 | 133 |
static INTFLOAT is_table_lsf[2][2][16]; |
| 134 | 134 |
static INTFLOAT csa_table[8][4]; |
| 135 |
-/** Window for MDCT. Note that only the component [0,17] and [20,37] are used, |
|
| 136 |
- the components 18 and 19 are there only to assure 128-bit alignment for asm |
|
| 137 |
- */ |
|
| 138 |
-DECLARE_ALIGNED(16, static INTFLOAT, mdct_win)[8][40]; |
|
| 139 | 135 |
|
| 140 | 136 |
static int16_t division_tab3[1<<6 ]; |
| 141 | 137 |
static int16_t division_tab5[1<<8 ]; |
| ... | ... |
@@ -422,45 +418,6 @@ static av_cold void decode_init_static(void) |
| 422 | 422 |
csa_table[i][3] = ca - cs; |
| 423 | 423 |
#endif |
| 424 | 424 |
} |
| 425 |
- |
|
| 426 |
- /* compute mdct windows */ |
|
| 427 |
- for (i = 0; i < 36; i++) {
|
|
| 428 |
- for (j = 0; j < 4; j++) {
|
|
| 429 |
- double d; |
|
| 430 |
- |
|
| 431 |
- if (j == 2 && i % 3 != 1) |
|
| 432 |
- continue; |
|
| 433 |
- |
|
| 434 |
- d = sin(M_PI * (i + 0.5) / 36.0); |
|
| 435 |
- if (j == 1) {
|
|
| 436 |
- if (i >= 30) d = 0; |
|
| 437 |
- else if (i >= 24) d = sin(M_PI * (i - 18 + 0.5) / 12.0); |
|
| 438 |
- else if (i >= 18) d = 1; |
|
| 439 |
- } else if (j == 3) {
|
|
| 440 |
- if (i < 6) d = 0; |
|
| 441 |
- else if (i < 12) d = sin(M_PI * (i - 6 + 0.5) / 12.0); |
|
| 442 |
- else if (i < 18) d = 1; |
|
| 443 |
- } |
|
| 444 |
- //merge last stage of imdct into the window coefficients |
|
| 445 |
- d *= 0.5 / cos(M_PI * (2 * i + 19) / 72); |
|
| 446 |
- |
|
| 447 |
- if (j == 2) |
|
| 448 |
- mdct_win[j][i/3] = FIXHR((d / (1<<5))); |
|
| 449 |
- else {
|
|
| 450 |
- int idx = i < 18 ? i : i + 2; |
|
| 451 |
- mdct_win[j][idx] = FIXHR((d / (1<<5))); |
|
| 452 |
- } |
|
| 453 |
- } |
|
| 454 |
- } |
|
| 455 |
- |
|
| 456 |
- /* NOTE: we do frequency inversion adter the MDCT by changing |
|
| 457 |
- the sign of the right window coefs */ |
|
| 458 |
- for (j = 0; j < 4; j++) {
|
|
| 459 |
- for (i = 0; i < 40; i += 2) {
|
|
| 460 |
- mdct_win[j + 4][i ] = mdct_win[j][i ]; |
|
| 461 |
- mdct_win[j + 4][i + 1] = -mdct_win[j][i + 1]; |
|
| 462 |
- } |
|
| 463 |
- } |
|
| 464 | 425 |
} |
| 465 | 426 |
|
| 466 | 427 |
static av_cold int decode_init(AVCodecContext * avctx) |
| ... | ... |
@@ -1284,59 +1241,53 @@ static void compute_imdct(MPADecodeContext *s, GranuleDef *g, |
| 1284 | 1284 |
mdct_long_end = sblimit; |
| 1285 | 1285 |
} |
| 1286 | 1286 |
|
| 1287 |
- buf = mdct_buf; |
|
| 1288 |
- ptr = g->sb_hybrid; |
|
| 1289 |
- for (j = 0; j < mdct_long_end; j++) {
|
|
| 1290 |
- int win_idx = (g->switch_point && j < 2) ? 0 : g->block_type; |
|
| 1291 |
- /* apply window & overlap with previous buffer */ |
|
| 1292 |
- out_ptr = sb_samples + j; |
|
| 1293 |
- /* select window */ |
|
| 1294 |
- win = mdct_win[win_idx + (4 & -(j & 1))]; |
|
| 1295 |
- s->mpadsp.RENAME(imdct36)(out_ptr, buf, ptr, win); |
|
| 1296 |
- out_ptr += 18 * SBLIMIT; |
|
| 1297 |
- ptr += 18; |
|
| 1298 |
- buf += 18; |
|
| 1299 |
- } |
|
| 1287 |
+ s->mpadsp.RENAME(imdct36_blocks)(sb_samples, mdct_buf, g->sb_hybrid, |
|
| 1288 |
+ mdct_long_end, g->switch_point, |
|
| 1289 |
+ g->block_type); |
|
| 1290 |
+ |
|
| 1291 |
+ buf = mdct_buf + 4*18*(mdct_long_end >> 2) + (mdct_long_end & 3); |
|
| 1292 |
+ ptr = g->sb_hybrid + 18 * mdct_long_end; |
|
| 1293 |
+ |
|
| 1300 | 1294 |
for (j = mdct_long_end; j < sblimit; j++) {
|
| 1301 | 1295 |
/* select frequency inversion */ |
| 1302 |
- win = mdct_win[2 + (4 & -(j & 1))]; |
|
| 1296 |
+ win = RENAME(ff_mdct_win)[2 + (4 & -(j & 1))]; |
|
| 1303 | 1297 |
out_ptr = sb_samples + j; |
| 1304 | 1298 |
|
| 1305 | 1299 |
for (i = 0; i < 6; i++) {
|
| 1306 |
- *out_ptr = buf[i]; |
|
| 1300 |
+ *out_ptr = buf[4*i]; |
|
| 1307 | 1301 |
out_ptr += SBLIMIT; |
| 1308 | 1302 |
} |
| 1309 | 1303 |
imdct12(out2, ptr + 0); |
| 1310 | 1304 |
for (i = 0; i < 6; i++) {
|
| 1311 |
- *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[i + 6*1]; |
|
| 1312 |
- buf[i + 6*2] = MULH3(out2[i + 6], win[i + 6], 1); |
|
| 1305 |
+ *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*1)]; |
|
| 1306 |
+ buf[4*(i + 6*2)] = MULH3(out2[i + 6], win[i + 6], 1); |
|
| 1313 | 1307 |
out_ptr += SBLIMIT; |
| 1314 | 1308 |
} |
| 1315 | 1309 |
imdct12(out2, ptr + 1); |
| 1316 | 1310 |
for (i = 0; i < 6; i++) {
|
| 1317 |
- *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[i + 6*2]; |
|
| 1318 |
- buf[i + 6*0] = MULH3(out2[i + 6], win[i + 6], 1); |
|
| 1311 |
+ *out_ptr = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*2)]; |
|
| 1312 |
+ buf[4*(i + 6*0)] = MULH3(out2[i + 6], win[i + 6], 1); |
|
| 1319 | 1313 |
out_ptr += SBLIMIT; |
| 1320 | 1314 |
} |
| 1321 | 1315 |
imdct12(out2, ptr + 2); |
| 1322 | 1316 |
for (i = 0; i < 6; i++) {
|
| 1323 |
- buf[i + 6*0] = MULH3(out2[i ], win[i ], 1) + buf[i + 6*0]; |
|
| 1324 |
- buf[i + 6*1] = MULH3(out2[i + 6], win[i + 6], 1); |
|
| 1325 |
- buf[i + 6*2] = 0; |
|
| 1317 |
+ buf[4*(i + 6*0)] = MULH3(out2[i ], win[i ], 1) + buf[4*(i + 6*0)]; |
|
| 1318 |
+ buf[4*(i + 6*1)] = MULH3(out2[i + 6], win[i + 6], 1); |
|
| 1319 |
+ buf[4*(i + 6*2)] = 0; |
|
| 1326 | 1320 |
} |
| 1327 | 1321 |
ptr += 18; |
| 1328 |
- buf += 18; |
|
| 1322 |
+ buf += (j&3) != 3 ? 1 : (4*18-3); |
|
| 1329 | 1323 |
} |
| 1330 | 1324 |
/* zero bands */ |
| 1331 | 1325 |
for (j = sblimit; j < SBLIMIT; j++) {
|
| 1332 | 1326 |
/* overlap */ |
| 1333 | 1327 |
out_ptr = sb_samples + j; |
| 1334 | 1328 |
for (i = 0; i < 18; i++) {
|
| 1335 |
- *out_ptr = buf[i]; |
|
| 1336 |
- buf[i] = 0; |
|
| 1329 |
+ *out_ptr = buf[4*i]; |
|
| 1330 |
+ buf[4*i] = 0; |
|
| 1337 | 1331 |
out_ptr += SBLIMIT; |
| 1338 | 1332 |
} |
| 1339 |
- buf += 18; |
|
| 1333 |
+ buf += (j&3) != 3 ? 1 : (4*18-3); |
|
| 1340 | 1334 |
} |
| 1341 | 1335 |
} |
| 1342 | 1336 |
|
| ... | ... |
@@ -28,6 +28,8 @@ void ff_mpadsp_init(MPADSPContext *s) |
| 28 | 28 |
DCTContext dct; |
| 29 | 29 |
|
| 30 | 30 |
ff_dct_init(&dct, 5, DCT_II); |
| 31 |
+ ff_init_mpadsp_tabs_float(); |
|
| 32 |
+ ff_init_mpadsp_tabs_fixed(); |
|
| 31 | 33 |
|
| 32 | 34 |
s->apply_window_float = ff_mpadsp_apply_window_float; |
| 33 | 35 |
s->apply_window_fixed = ff_mpadsp_apply_window_fixed; |
| ... | ... |
@@ -35,8 +37,8 @@ void ff_mpadsp_init(MPADSPContext *s) |
| 35 | 35 |
s->dct32_float = dct.dct32; |
| 36 | 36 |
s->dct32_fixed = ff_dct32_fixed; |
| 37 | 37 |
|
| 38 |
- s->imdct36_float = ff_imdct36_float; |
|
| 39 |
- s->imdct36_fixed = ff_imdct36_fixed; |
|
| 38 |
+ s->imdct36_blocks_float = ff_imdct36_blocks_float; |
|
| 39 |
+ s->imdct36_blocks_fixed = ff_imdct36_blocks_fixed; |
|
| 40 | 40 |
|
| 41 | 41 |
if (ARCH_ARM) ff_mpadsp_init_arm(s); |
| 42 | 42 |
if (HAVE_MMX) ff_mpadsp_init_mmx(s); |
| ... | ... |
@@ -20,6 +20,7 @@ |
| 20 | 20 |
#define AVCODEC_MPEGAUDIODSP_H |
| 21 | 21 |
|
| 22 | 22 |
#include <stdint.h> |
| 23 |
+#include "libavutil/common.h" |
|
| 23 | 24 |
|
| 24 | 25 |
typedef struct MPADSPContext {
|
| 25 | 26 |
void (*apply_window_float)(float *synth_buf, float *window, |
| ... | ... |
@@ -28,8 +29,11 @@ typedef struct MPADSPContext {
|
| 28 | 28 |
int *dither_state, int16_t *samples, int incr); |
| 29 | 29 |
void (*dct32_float)(float *dst, const float *src); |
| 30 | 30 |
void (*dct32_fixed)(int *dst, const int *src); |
| 31 |
- void (*imdct36_float)(float *out, float *buf, float *in, float *win); |
|
| 32 |
- void (*imdct36_fixed)(int *out, int *buf, int *in, int *win); |
|
| 31 |
+ |
|
| 32 |
+ void (*imdct36_blocks_float)(float *out, float *buf, float *in, |
|
| 33 |
+ int count, int switch_point, int block_type); |
|
| 34 |
+ void (*imdct36_blocks_fixed)(int *out, int *buf, int *in, |
|
| 35 |
+ int count, int switch_point, int block_type); |
|
| 33 | 36 |
} MPADSPContext; |
| 34 | 37 |
|
| 35 | 38 |
void ff_mpadsp_init(MPADSPContext *s); |
| ... | ... |
@@ -63,7 +67,19 @@ void ff_mpadsp_apply_window_fixed(int32_t *synth_buf, int32_t *window, |
| 63 | 63 |
int *dither_state, int16_t *samples, |
| 64 | 64 |
int incr); |
| 65 | 65 |
|
| 66 |
-void ff_imdct36_fixed(int *out, int *buf, int *in, int *win); |
|
| 67 |
-void ff_imdct36_float(float *out, float *buf, float *in, float *win); |
|
| 66 |
+void ff_imdct36_blocks_float(float *out, float *buf, float *in, |
|
| 67 |
+ int count, int switch_point, int block_type); |
|
| 68 |
+ |
|
| 69 |
+void ff_imdct36_blocks_fixed(int *out, int *buf, int *in, |
|
| 70 |
+ int count, int switch_point, int block_type); |
|
| 71 |
+ |
|
| 72 |
+void ff_init_mpadsp_tabs_float(void); |
|
| 73 |
+void ff_init_mpadsp_tabs_fixed(void); |
|
| 74 |
+ |
|
| 75 |
+/** For SSE implementation, MDCT_BUF_SIZE/2 should be 128-bit aligned */ |
|
| 76 |
+#define MDCT_BUF_SIZE FFALIGN(36, 2*4) |
|
| 77 |
+ |
|
| 78 |
+extern int ff_mdct_win_fixed[8][MDCT_BUF_SIZE]; |
|
| 79 |
+extern float ff_mdct_win_float[8][MDCT_BUF_SIZE]; |
|
| 68 | 80 |
|
| 69 | 81 |
#endif /* AVCODEC_MPEGAUDIODSP_H */ |
| ... | ... |
@@ -69,6 +69,12 @@ static inline int round_sample(int64_t *sum) |
| 69 | 69 |
# define FIXHR(a) ((int)((a) * (1LL<<32) + 0.5)) |
| 70 | 70 |
#endif |
| 71 | 71 |
|
| 72 |
+/** Window for MDCT. Actually only the elements in [0,17] and |
|
| 73 |
+ [MDCT_BUF_SIZE/2, MDCT_BUF_SIZE/2 + 17] are actually used. The rest |
|
| 74 |
+ is just to preserve alignment for SIMD implementations. |
|
| 75 |
+*/ |
|
| 76 |
+DECLARE_ALIGNED(16, INTFLOAT, RENAME(ff_mdct_win))[8][MDCT_BUF_SIZE]; |
|
| 77 |
+ |
|
| 72 | 78 |
DECLARE_ALIGNED(16, MPA_INT, RENAME(ff_mpa_synth_window))[512+256]; |
| 73 | 79 |
|
| 74 | 80 |
#define SUM8(op, sum, w, p) \ |
| ... | ... |
@@ -204,6 +210,7 @@ void av_cold RENAME(ff_mpa_synth_init)(MPA_INT *window) |
| 204 | 204 |
window[512 - i] = v; |
| 205 | 205 |
} |
| 206 | 206 |
|
| 207 |
+ |
|
| 207 | 208 |
// Needed for avoiding shuffles in ASM implementations |
| 208 | 209 |
for(i=0; i < 8; i++) |
| 209 | 210 |
for(j=0; j < 16; j++) |
| ... | ... |
@@ -214,6 +221,48 @@ void av_cold RENAME(ff_mpa_synth_init)(MPA_INT *window) |
| 214 | 214 |
window[512+128+16*i+j] = window[64*i+48-j]; |
| 215 | 215 |
} |
| 216 | 216 |
|
| 217 |
+void RENAME(ff_init_mpadsp_tabs)(void) |
|
| 218 |
+{
|
|
| 219 |
+ int i, j; |
|
| 220 |
+ /* compute mdct windows */ |
|
| 221 |
+ for (i = 0; i < 36; i++) {
|
|
| 222 |
+ for (j = 0; j < 4; j++) {
|
|
| 223 |
+ double d; |
|
| 224 |
+ |
|
| 225 |
+ if (j == 2 && i % 3 != 1) |
|
| 226 |
+ continue; |
|
| 227 |
+ |
|
| 228 |
+ d = sin(M_PI * (i + 0.5) / 36.0); |
|
| 229 |
+ if (j == 1) {
|
|
| 230 |
+ if (i >= 30) d = 0; |
|
| 231 |
+ else if (i >= 24) d = sin(M_PI * (i - 18 + 0.5) / 12.0); |
|
| 232 |
+ else if (i >= 18) d = 1; |
|
| 233 |
+ } else if (j == 3) {
|
|
| 234 |
+ if (i < 6) d = 0; |
|
| 235 |
+ else if (i < 12) d = sin(M_PI * (i - 6 + 0.5) / 12.0); |
|
| 236 |
+ else if (i < 18) d = 1; |
|
| 237 |
+ } |
|
| 238 |
+ //merge last stage of imdct into the window coefficients |
|
| 239 |
+ d *= 0.5 / cos(M_PI * (2 * i + 19) / 72); |
|
| 240 |
+ |
|
| 241 |
+ if (j == 2) |
|
| 242 |
+ RENAME(ff_mdct_win)[j][i/3] = FIXHR((d / (1<<5))); |
|
| 243 |
+ else {
|
|
| 244 |
+ int idx = i < 18 ? i : i + (MDCT_BUF_SIZE/2 - 18); |
|
| 245 |
+ RENAME(ff_mdct_win)[j][idx] = FIXHR((d / (1<<5))); |
|
| 246 |
+ } |
|
| 247 |
+ } |
|
| 248 |
+ } |
|
| 249 |
+ |
|
| 250 |
+ /* NOTE: we do frequency inversion adter the MDCT by changing |
|
| 251 |
+ the sign of the right window coefs */ |
|
| 252 |
+ for (j = 0; j < 4; j++) {
|
|
| 253 |
+ for (i = 0; i < MDCT_BUF_SIZE; i += 2) {
|
|
| 254 |
+ RENAME(ff_mdct_win)[j + 4][i ] = RENAME(ff_mdct_win)[j][i ]; |
|
| 255 |
+ RENAME(ff_mdct_win)[j + 4][i + 1] = -RENAME(ff_mdct_win)[j][i + 1]; |
|
| 256 |
+ } |
|
| 257 |
+ } |
|
| 258 |
+} |
|
| 217 | 259 |
/* cos(pi*i/18) */ |
| 218 | 260 |
#define C1 FIXHR(0.98480775301220805936/2) |
| 219 | 261 |
#define C2 FIXHR(0.93969262078590838405/2) |
| ... | ... |
@@ -227,43 +276,42 @@ void av_cold RENAME(ff_mpa_synth_init)(MPA_INT *window) |
| 227 | 227 |
/* 0.5 / cos(pi*(2*i+1)/36) */ |
| 228 | 228 |
static const INTFLOAT icos36[9] = {
|
| 229 | 229 |
FIXR(0.50190991877167369479), |
| 230 |
- FIXR(0.51763809020504152469), |
|
| 230 |
+ FIXR(0.51763809020504152469), //0 |
|
| 231 | 231 |
FIXR(0.55168895948124587824), |
| 232 | 232 |
FIXR(0.61038729438072803416), |
| 233 |
- FIXR(0.70710678118654752439), |
|
| 233 |
+ FIXR(0.70710678118654752439), //1 |
|
| 234 | 234 |
FIXR(0.87172339781054900991), |
| 235 | 235 |
FIXR(1.18310079157624925896), |
| 236 |
- FIXR(1.93185165257813657349), |
|
| 236 |
+ FIXR(1.93185165257813657349), //2 |
|
| 237 | 237 |
FIXR(5.73685662283492756461), |
| 238 | 238 |
}; |
| 239 | 239 |
|
| 240 | 240 |
/* 0.5 / cos(pi*(2*i+1)/36) */ |
| 241 | 241 |
static const INTFLOAT icos36h[9] = {
|
| 242 | 242 |
FIXHR(0.50190991877167369479/2), |
| 243 |
- FIXHR(0.51763809020504152469/2), |
|
| 243 |
+ FIXHR(0.51763809020504152469/2), //0 |
|
| 244 | 244 |
FIXHR(0.55168895948124587824/2), |
| 245 | 245 |
FIXHR(0.61038729438072803416/2), |
| 246 |
- FIXHR(0.70710678118654752439/2), |
|
| 246 |
+ FIXHR(0.70710678118654752439/2), //1 |
|
| 247 | 247 |
FIXHR(0.87172339781054900991/2), |
| 248 | 248 |
FIXHR(1.18310079157624925896/4), |
| 249 |
- FIXHR(1.93185165257813657349/4), |
|
| 249 |
+ FIXHR(1.93185165257813657349/4), //2 |
|
| 250 |
+// FIXHR(5.73685662283492756461), |
|
| 250 | 251 |
}; |
| 251 | 252 |
|
| 252 |
- |
|
| 253 | 253 |
/* using Lee like decomposition followed by hand coded 9 points DCT */ |
| 254 |
-void RENAME(ff_imdct36)(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in, |
|
| 255 |
- INTFLOAT *win) |
|
| 254 |
+static void imdct36(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in, INTFLOAT *win) |
|
| 256 | 255 |
{
|
| 257 | 256 |
int i, j; |
| 258 | 257 |
INTFLOAT t0, t1, t2, t3, s0, s1, s2, s3; |
| 259 | 258 |
INTFLOAT tmp[18], *tmp1, *in1; |
| 260 | 259 |
|
| 261 |
- for(i=17;i>=1;i--) |
|
| 260 |
+ for (i = 17; i >= 1; i--) |
|
| 262 | 261 |
in[i] += in[i-1]; |
| 263 |
- for(i=17;i>=3;i-=2) |
|
| 262 |
+ for (i = 17; i >= 3; i -= 2) |
|
| 264 | 263 |
in[i] += in[i-2]; |
| 265 | 264 |
|
| 266 |
- for(j=0;j<2;j++) {
|
|
| 265 |
+ for (j = 0; j < 2; j++) {
|
|
| 267 | 266 |
tmp1 = tmp + j; |
| 268 | 267 |
in1 = in + j; |
| 269 | 268 |
|
| ... | ... |
@@ -295,7 +343,7 @@ void RENAME(ff_imdct36)(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in, |
| 295 | 295 |
} |
| 296 | 296 |
|
| 297 | 297 |
i = 0; |
| 298 |
- for(j=0;j<4;j++) {
|
|
| 298 |
+ for (j = 0; j < 4; j++) {
|
|
| 299 | 299 |
t0 = tmp[i]; |
| 300 | 300 |
t1 = tmp[i + 2]; |
| 301 | 301 |
s0 = t1 + t0; |
| ... | ... |
@@ -303,22 +351,22 @@ void RENAME(ff_imdct36)(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in, |
| 303 | 303 |
|
| 304 | 304 |
t2 = tmp[i + 1]; |
| 305 | 305 |
t3 = tmp[i + 3]; |
| 306 |
- s1 = MULH3(t3 + t2, icos36h[j], 2); |
|
| 307 |
- s3 = MULLx(t3 - t2, icos36[8 - j], FRAC_BITS); |
|
| 306 |
+ s1 = MULH3(t3 + t2, icos36h[ j], 2); |
|
| 307 |
+ s3 = MULLx(t3 - t2, icos36 [8 - j], FRAC_BITS); |
|
| 308 | 308 |
|
| 309 | 309 |
t0 = s0 + s1; |
| 310 | 310 |
t1 = s0 - s1; |
| 311 |
- out[(9 + j)*SBLIMIT] = MULH3(t1, win[9 + j], 1) + buf[9 + j]; |
|
| 312 |
- out[(8 - j)*SBLIMIT] = MULH3(t1, win[8 - j], 1) + buf[8 - j]; |
|
| 313 |
- buf[9 + j] = MULH3(t0, win[20 + 9 + j], 1); |
|
| 314 |
- buf[8 - j] = MULH3(t0, win[20 + 8 - j], 1); |
|
| 311 |
+ out[(9 + j) * SBLIMIT] = MULH3(t1, win[ 9 + j], 1) + buf[4*(9 + j)]; |
|
| 312 |
+ out[(8 - j) * SBLIMIT] = MULH3(t1, win[ 8 - j], 1) + buf[4*(8 - j)]; |
|
| 313 |
+ buf[4 * ( 9 + j )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + 9 + j], 1); |
|
| 314 |
+ buf[4 * ( 8 - j )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + 8 - j], 1); |
|
| 315 | 315 |
|
| 316 | 316 |
t0 = s2 + s3; |
| 317 | 317 |
t1 = s2 - s3; |
| 318 |
- out[(9 + 8 - j)*SBLIMIT] = MULH3(t1, win[9 + 8 - j], 1) + buf[9 + 8 - j]; |
|
| 319 |
- out[( j)*SBLIMIT] = MULH3(t1, win[ j], 1) + buf[ j]; |
|
| 320 |
- buf[9 + 8 - j] = MULH3(t0, win[20 + 9 + 8 - j], 1); |
|
| 321 |
- buf[ + j] = MULH3(t0, win[20 + j], 1); |
|
| 318 |
+ out[(9 + 8 - j) * SBLIMIT] = MULH3(t1, win[ 9 + 8 - j], 1) + buf[4*(9 + 8 - j)]; |
|
| 319 |
+ out[ j * SBLIMIT] = MULH3(t1, win[ j], 1) + buf[4*( j)]; |
|
| 320 |
+ buf[4 * ( 9 + 8 - j )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + 9 + 8 - j], 1); |
|
| 321 |
+ buf[4 * ( j )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + j], 1); |
|
| 322 | 322 |
i += 4; |
| 323 | 323 |
} |
| 324 | 324 |
|
| ... | ... |
@@ -326,9 +374,28 @@ void RENAME(ff_imdct36)(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in, |
| 326 | 326 |
s1 = MULH3(tmp[17], icos36h[4], 2); |
| 327 | 327 |
t0 = s0 + s1; |
| 328 | 328 |
t1 = s0 - s1; |
| 329 |
- out[(9 + 4)*SBLIMIT] = MULH3(t1, win[9 + 4], 1) + buf[9 + 4]; |
|
| 330 |
- out[(8 - 4)*SBLIMIT] = MULH3(t1, win[8 - 4], 1) + buf[8 - 4]; |
|
| 331 |
- buf[9 + 4] = MULH3(t0, win[20 + 9 + 4], 1); |
|
| 332 |
- buf[8 - 4] = MULH3(t0, win[20 + 8 - 4], 1); |
|
| 329 |
+ out[(9 + 4) * SBLIMIT] = MULH3(t1, win[ 9 + 4], 1) + buf[4*(9 + 4)]; |
|
| 330 |
+ out[(8 - 4) * SBLIMIT] = MULH3(t1, win[ 8 - 4], 1) + buf[4*(8 - 4)]; |
|
| 331 |
+ buf[4 * ( 9 + 4 )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + 9 + 4], 1); |
|
| 332 |
+ buf[4 * ( 8 - 4 )] = MULH3(t0, win[MDCT_BUF_SIZE/2 + 8 - 4], 1); |
|
| 333 |
+} |
|
| 334 |
+ |
|
| 335 |
+void RENAME(ff_imdct36_blocks)(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in, |
|
| 336 |
+ int count, int switch_point, int block_type) |
|
| 337 |
+{
|
|
| 338 |
+ int j; |
|
| 339 |
+ for (j=0 ; j < count; j++) {
|
|
| 340 |
+ /* apply window & overlap with previous buffer */ |
|
| 341 |
+ |
|
| 342 |
+ /* select window */ |
|
| 343 |
+ int win_idx = (switch_point && j < 2) ? 0 : block_type; |
|
| 344 |
+ INTFLOAT *win = RENAME(ff_mdct_win)[win_idx + (4 & -(j & 1))]; |
|
| 345 |
+ |
|
| 346 |
+ imdct36(out, buf, in, win); |
|
| 347 |
+ |
|
| 348 |
+ in += 18; |
|
| 349 |
+ buf += ((j&3) != 3 ? 1 : (72-3)); |
|
| 350 |
+ out++; |
|
| 351 |
+ } |
|
| 333 | 352 |
} |
| 334 | 353 |
|
| ... | ... |
@@ -53,92 +53,118 @@ ps_cosh_sse3: dd 1.0, -0.50190991877167369479, 1.0, -5.73685662283492756461 |
| 53 | 53 |
dd 1.0, -0.61038729438072803416, -1.0, 0.87172339781054900991 |
| 54 | 54 |
dd 1.0, 0.70710678118654752439, 0.0, 0.0 |
| 55 | 55 |
|
| 56 |
+costabs: times 4 dd 0.98480773 |
|
| 57 |
+ times 4 dd 0.93969262 |
|
| 58 |
+ times 4 dd 0.86602539 |
|
| 59 |
+ times 4 dd -0.76604444 |
|
| 60 |
+ times 4 dd -0.64278764 |
|
| 61 |
+ times 4 dd 0.50000000 |
|
| 62 |
+ times 4 dd -0.50000000 |
|
| 63 |
+ times 4 dd -0.34202015 |
|
| 64 |
+ times 4 dd -0.17364818 |
|
| 65 |
+ times 4 dd 0.50190992 |
|
| 66 |
+ times 4 dd 0.51763808 |
|
| 67 |
+ times 4 dd 0.55168896 |
|
| 68 |
+ times 4 dd 0.61038726 |
|
| 69 |
+ times 4 dd 0.70710677 |
|
| 70 |
+ times 4 dd 0.87172341 |
|
| 71 |
+ times 4 dd 1.18310082 |
|
| 72 |
+ times 4 dd 1.93185163 |
|
| 73 |
+ times 4 dd 5.73685646 |
|
| 74 |
+ |
|
| 56 | 75 |
%define SBLIMIT 32 |
| 57 | 76 |
SECTION_TEXT |
| 58 | 77 |
|
| 59 |
-%macro PSHUFD_SSE_AVX 3 |
|
| 60 |
- shufps %1, %2, %2, %3 |
|
| 61 |
-%endmacro |
|
| 62 |
-%macro PSHUFD_SSE2 3 |
|
| 78 |
+%macro PSHUFD 3 |
|
| 79 |
+%if cpuflag(sse2) && notcpuflag(avx) |
|
| 63 | 80 |
pshufd %1, %2, %3 |
| 81 |
+%else |
|
| 82 |
+ shufps %1, %2, %2, %3 |
|
| 83 |
+%endif |
|
| 64 | 84 |
%endmacro |
| 65 | 85 |
|
| 66 |
-; input %1={x1,x2,x3,x4}, %2={y1,y2,y3,y4}
|
|
| 67 |
-; output %3={x3,x4,y1,y2}
|
|
| 68 |
-%macro BUILDINVHIGHLOW_SSE 3 |
|
| 69 |
- movlhps %3, %2 |
|
| 70 |
- movhlps %3, %1 |
|
| 71 |
-%endmacro |
|
| 72 |
-%macro BUILDINVHIGHLOW_AVX 3 |
|
| 73 |
- shufps %3, %1, %2, 0x4e |
|
| 86 |
+; input %2={x1,x2,x3,x4}, %3={y1,y2,y3,y4}
|
|
| 87 |
+; output %1={x3,x4,y1,y2}
|
|
| 88 |
+%macro BUILDINVHIGHLOW 3 |
|
| 89 |
+%if cpuflag(avx) |
|
| 90 |
+ shufps %1, %2, %3, 0x4e |
|
| 91 |
+%else |
|
| 92 |
+ movlhps %1, %3 |
|
| 93 |
+ movhlps %1, %2 |
|
| 94 |
+%endif |
|
| 74 | 95 |
%endmacro |
| 75 | 96 |
|
| 76 |
-; input %1={x1,x2,x3,x4}, %2={y1,y2,y3,y4}
|
|
| 77 |
-; output %3={x4,y1,y2,y3}
|
|
| 78 |
-%macro ROTLEFT_SSE 3 |
|
| 97 |
+; input %2={x1,x2,x3,x4}, %3={y1,y2,y3,y4}
|
|
| 98 |
+; output %1={x4,y1,y2,y3}
|
|
| 99 |
+%macro ROTLEFT 3 |
|
| 100 |
+%if cpuflag(ssse3) |
|
| 101 |
+ palignr %1, %3, %2, 12 |
|
| 102 |
+%else |
|
| 79 | 103 |
BUILDINVHIGHLOW %1, %2, %3 |
| 80 |
- shufps %3, %3, %2, 0x99 |
|
| 81 |
-%endmacro |
|
| 82 |
- |
|
| 83 |
-%macro ROTLEFT_SSSE3 3 |
|
| 84 |
- palignr %3, %2, %1, 12 |
|
| 104 |
+ shufps %1, %1, %3, 0x99 |
|
| 105 |
+%endif |
|
| 85 | 106 |
%endmacro |
| 86 | 107 |
|
| 87 |
-%macro INVERTHL_SSE1 2 |
|
| 108 |
+%macro INVERTHL 2 |
|
| 109 |
+%if cpuflag(sse2) |
|
| 110 |
+ PSHUFD %1, %2, 0x4e |
|
| 111 |
+%else |
|
| 88 | 112 |
movhlps %1, %2 |
| 89 | 113 |
movlhps %1, %2 |
| 114 |
+%endif |
|
| 90 | 115 |
%endmacro |
| 91 | 116 |
|
| 92 |
-%macro INVERTHL_SSE2 2 |
|
| 93 |
- PSHUFD %1, %2, 0x4e |
|
| 94 |
-%endmacro |
|
| 95 |
- |
|
| 96 |
-%macro BUTTERF_SSE12 3 |
|
| 117 |
+%macro BUTTERF 3 |
|
| 97 | 118 |
INVERTHL %2, %1 |
| 98 | 119 |
xorps %1, [ps_p1p1m1m1] |
| 99 | 120 |
addps %1, %2 |
| 121 |
+%if cpuflag(sse3) |
|
| 122 |
+ mulps %1, %1, [ps_cosh_sse3 + %3] |
|
| 123 |
+ PSHUFD %2, %1, 0xb1 |
|
| 124 |
+ addsubps %1, %1, %2 |
|
| 125 |
+%else |
|
| 100 | 126 |
mulps %1, [ps_cosh + %3] |
| 101 | 127 |
PSHUFD %2, %1, 0xb1 |
| 102 | 128 |
xorps %1, [ps_p1m1p1m1] |
| 103 | 129 |
addps %1, %2 |
| 104 |
-%endmacro |
|
| 105 |
-%macro BUTTERF_SSE3 3 |
|
| 106 |
- INVERTHL %2, %1 |
|
| 107 |
- xorps %1, %1, [ps_p1p1m1m1] |
|
| 108 |
- addps %1, %1, %2 |
|
| 109 |
- mulps %1, %1, [ps_cosh_sse3 + %3] |
|
| 110 |
- PSHUFD %2, %1, 0xb1 |
|
| 111 |
- addsubps %1, %1, %2 |
|
| 130 |
+%endif |
|
| 112 | 131 |
%endmacro |
| 113 | 132 |
|
| 114 |
-%macro STORE 3 |
|
| 133 |
+%macro STORE 4 |
|
| 115 | 134 |
movhlps %2, %1 |
| 116 |
- movss [%3 ], %1 |
|
| 117 |
- movss [%3 + 8*SBLIMIT], %2 |
|
| 135 |
+ movss [%3 ], %1 |
|
| 136 |
+ movss [%3 + 2*%4], %2 |
|
| 118 | 137 |
shufps %1, %1, 0xb1 |
| 119 |
- movss [%3 + 4*SBLIMIT], %1 |
|
| 138 |
+ movss [%3 + %4], %1 |
|
| 120 | 139 |
movhlps %2, %1 |
| 121 |
- movss [%3 + 12*SBLIMIT], %2 |
|
| 140 |
+ movss [%3 + 3*%4], %2 |
|
| 141 |
+%endmacro |
|
| 142 |
+ |
|
| 143 |
+%macro LOAD 4 |
|
| 144 |
+ movlps %1, [%3 ] |
|
| 145 |
+ movhps %1, [%3 + %4] |
|
| 146 |
+ movlps %2, [%3 + 2*%4] |
|
| 147 |
+ movhps %2, [%3 + 3*%4] |
|
| 148 |
+ shufps %1, %2, 0x88 |
|
| 122 | 149 |
%endmacro |
| 123 | 150 |
|
| 124 | 151 |
%macro LOADA64 2 |
| 152 |
+%if cpuflag(avx) |
|
| 153 |
+ movu %1, [%2] |
|
| 154 |
+%else |
|
| 125 | 155 |
movlps %1, [%2] |
| 126 | 156 |
movhps %1, [%2 + 8] |
| 157 |
+%endif |
|
| 127 | 158 |
%endmacro |
| 128 | 159 |
|
| 129 |
-%macro STOREA64 2 |
|
| 130 |
- movlps [%1 ], %2 |
|
| 131 |
- movhps [%1 + 8], %2 |
|
| 132 |
-%endmacro |
|
| 133 |
- |
|
| 134 |
-%macro DEFINE_IMDCT 1 |
|
| 135 |
-cglobal imdct36_float_%1, 4,4,9, out, buf, in, win |
|
| 160 |
+%macro DEFINE_IMDCT 0 |
|
| 161 |
+cglobal imdct36_float, 4,4,9, out, buf, in, win |
|
| 136 | 162 |
|
| 137 | 163 |
; for(i=17;i>=1;i--) in[i] += in[i-1]; |
| 138 | 164 |
LOADA64 m0, inq |
| 139 | 165 |
LOADA64 m1, inq + 16 |
| 140 | 166 |
|
| 141 |
- ROTLEFT m0, m1, m5 |
|
| 167 |
+ ROTLEFT m5, m0, m1 |
|
| 142 | 168 |
|
| 143 | 169 |
PSHUFD m6, m0, 0x93 |
| 144 | 170 |
andps m6, m6, [ps_mask] |
| ... | ... |
@@ -146,16 +172,16 @@ cglobal imdct36_float_%1, 4,4,9, out, buf, in, win |
| 146 | 146 |
|
| 147 | 147 |
LOADA64 m2, inq + 32 |
| 148 | 148 |
|
| 149 |
- ROTLEFT m1, m2, m7 |
|
| 149 |
+ ROTLEFT m7, m1, m2 |
|
| 150 | 150 |
|
| 151 | 151 |
addps m1, m1, m5 |
| 152 | 152 |
LOADA64 m3, inq + 48 |
| 153 | 153 |
|
| 154 |
- ROTLEFT m2, m3, m5 |
|
| 154 |
+ ROTLEFT m5, m2, m3 |
|
| 155 | 155 |
|
| 156 | 156 |
xorps m4, m4, m4 |
| 157 | 157 |
movlps m4, [inq+64] |
| 158 |
- BUILDINVHIGHLOW m3, m4, m6 |
|
| 158 |
+ BUILDINVHIGHLOW m6, m3, m4 |
|
| 159 | 159 |
shufps m6, m6, m4, 0xa9 |
| 160 | 160 |
|
| 161 | 161 |
addps m4, m4, m6 |
| ... | ... |
@@ -166,17 +192,17 @@ cglobal imdct36_float_%1, 4,4,9, out, buf, in, win |
| 166 | 166 |
movlhps m5, m5, m0 |
| 167 | 167 |
andps m5, m5, [ps_mask3] |
| 168 | 168 |
|
| 169 |
- BUILDINVHIGHLOW m0, m1, m7 |
|
| 169 |
+ BUILDINVHIGHLOW m7, m0, m1 |
|
| 170 | 170 |
andps m7, m7, [ps_mask2] |
| 171 | 171 |
|
| 172 | 172 |
addps m0, m0, m5 |
| 173 | 173 |
|
| 174 |
- BUILDINVHIGHLOW m1, m2, m6 |
|
| 174 |
+ BUILDINVHIGHLOW m6, m1, m2 |
|
| 175 | 175 |
andps m6, m6, [ps_mask2] |
| 176 | 176 |
|
| 177 | 177 |
addps m1, m1, m7 |
| 178 | 178 |
|
| 179 |
- BUILDINVHIGHLOW m2, m3, m7 |
|
| 179 |
+ BUILDINVHIGHLOW m7, m2, m3 |
|
| 180 | 180 |
andps m7, m7, [ps_mask2] |
| 181 | 181 |
|
| 182 | 182 |
addps m2, m2, m6 |
| ... | ... |
@@ -245,7 +271,7 @@ cglobal imdct36_float_%1, 4,4,9, out, buf, in, win |
| 245 | 245 |
subps m0, m0, m1 |
| 246 | 246 |
addps m0, m0, m6 |
| 247 | 247 |
|
| 248 |
- BUILDINVHIGHLOW m2, m3, m4 |
|
| 248 |
+ BUILDINVHIGHLOW m4, m2, m3 |
|
| 249 | 249 |
shufps m3, m3, m2, 0x4e |
| 250 | 250 |
|
| 251 | 251 |
; we have tmp = {SwAPLH(m0), SwAPLH(m7), m3, m4, m5}
|
| ... | ... |
@@ -280,7 +306,9 @@ cglobal imdct36_float_%1, 4,4,9, out, buf, in, win |
| 280 | 280 |
; permutation done |
| 281 | 281 |
|
| 282 | 282 |
PSHUFD m6, m2, 0xb1 |
| 283 |
- movlps m7, [bufq + 64] |
|
| 283 |
+ movss m4, [bufq + 4*68] |
|
| 284 |
+ movss m7, [bufq + 4*64] |
|
| 285 |
+ unpcklps m7, m7, m4 |
|
| 284 | 286 |
mulps m6, m6, [winq + 16*4] |
| 285 | 287 |
addps m6, m6, m7 |
| 286 | 288 |
movss [outq + 64*SBLIMIT], m6 |
| ... | ... |
@@ -288,74 +316,406 @@ cglobal imdct36_float_%1, 4,4,9, out, buf, in, win |
| 288 | 288 |
movss [outq + 68*SBLIMIT], m6 |
| 289 | 289 |
|
| 290 | 290 |
mulps m6, m3, [winq + 4*4] |
| 291 |
- LOADA64 m4, bufq + 16 |
|
| 291 |
+ LOAD m4, m7, bufq + 4*16, 16 |
|
| 292 | 292 |
addps m6, m6, m4 |
| 293 |
- STORE m6, m7, outq + 16*SBLIMIT |
|
| 293 |
+ STORE m6, m7, outq + 16*SBLIMIT, 4*SBLIMIT |
|
| 294 | 294 |
|
| 295 | 295 |
shufps m4, m0, m3, 0xb5 |
| 296 | 296 |
mulps m4, m4, [winq + 8*4] |
| 297 |
- LOADA64 m7, bufq + 32 |
|
| 297 |
+ LOAD m7, m6, bufq + 4*32, 16 |
|
| 298 | 298 |
addps m4, m4, m7 |
| 299 |
- STORE m4, m6, outq + 32*SBLIMIT |
|
| 299 |
+ STORE m4, m6, outq + 32*SBLIMIT, 4*SBLIMIT |
|
| 300 | 300 |
|
| 301 | 301 |
shufps m3, m3, m2, 0xb1 |
| 302 | 302 |
mulps m3, m3, [winq + 12*4] |
| 303 |
- LOADA64 m7, bufq + 48 |
|
| 303 |
+ LOAD m7, m6, bufq + 4*48, 16 |
|
| 304 | 304 |
addps m3, m3, m7 |
| 305 |
- STORE m3, m7, outq + 48*SBLIMIT |
|
| 305 |
+ STORE m3, m7, outq + 48*SBLIMIT, 4*SBLIMIT |
|
| 306 | 306 |
|
| 307 | 307 |
mulps m2, m2, [winq] |
| 308 |
- LOADA64 m6, bufq |
|
| 308 |
+ LOAD m6, m7, bufq, 16 |
|
| 309 | 309 |
addps m2, m2, m6 |
| 310 |
- STORE m2, m7, outq |
|
| 310 |
+ STORE m2, m7, outq, 4*SBLIMIT |
|
| 311 | 311 |
|
| 312 | 312 |
mulps m4, m1, [winq + 20*4] |
| 313 |
- STOREA64 bufq, m4 |
|
| 313 |
+ STORE m4, m7, bufq, 16 |
|
| 314 | 314 |
|
| 315 | 315 |
mulps m3, m5, [winq + 24*4] |
| 316 |
- STOREA64 bufq + 16, m3 |
|
| 316 |
+ STORE m3, m7, bufq + 4*16, 16 |
|
| 317 | 317 |
|
| 318 | 318 |
shufps m0, m0, m5, 0xb0 |
| 319 | 319 |
mulps m0, m0, [winq + 28*4] |
| 320 |
- STOREA64 bufq + 32, m0 |
|
| 320 |
+ STORE m0, m7, bufq + 4*32, 16 |
|
| 321 | 321 |
|
| 322 | 322 |
shufps m5, m5, m1, 0xb1 |
| 323 | 323 |
mulps m5, m5, [winq + 32*4] |
| 324 |
- STOREA64 bufq + 48, m5 |
|
| 324 |
+ STORE m5, m7, bufq + 4*48, 16 |
|
| 325 | 325 |
|
| 326 | 326 |
shufps m1, m1, m1, 0xb1 |
| 327 | 327 |
mulps m1, m1, [winq + 36*4] |
| 328 |
- movlps [bufq + 64], m1 |
|
| 328 |
+ movss [bufq + 4*64], m1 |
|
| 329 |
+ shufps m1, m1, 0xb1 |
|
| 330 |
+ movss [bufq + 4*68], m1 |
|
| 329 | 331 |
RET |
| 330 | 332 |
%endmacro |
| 331 | 333 |
|
| 332 |
-%define PSHUFD PSHUFD_SSE_AVX |
|
| 333 |
-%define INVERTHL INVERTHL_SSE1 |
|
| 334 |
-%define BUTTERF BUTTERF_SSE12 |
|
| 335 |
-%define BUTTERF0 BUTTERF0_SSE12 |
|
| 336 |
-%define BUILDINVHIGHLOW BUILDINVHIGHLOW_SSE |
|
| 337 |
-%define ROTLEFT ROTLEFT_SSE |
|
| 334 |
+INIT_XMM sse |
|
| 335 |
+DEFINE_IMDCT |
|
| 338 | 336 |
|
| 339 |
-INIT_XMM |
|
| 337 |
+INIT_XMM sse2 |
|
| 338 |
+DEFINE_IMDCT |
|
| 340 | 339 |
|
| 341 |
-DEFINE_IMDCT sse |
|
| 340 |
+INIT_XMM sse3 |
|
| 341 |
+DEFINE_IMDCT |
|
| 342 | 342 |
|
| 343 |
-%define PSHUFD PSHUFD_SSE2 |
|
| 344 |
-%define INVERTHL INVERTHL_SSE2 |
|
| 343 |
+INIT_XMM ssse3 |
|
| 344 |
+DEFINE_IMDCT |
|
| 345 | 345 |
|
| 346 |
-DEFINE_IMDCT sse2 |
|
| 346 |
+INIT_XMM avx |
|
| 347 |
+DEFINE_IMDCT |
|
| 347 | 348 |
|
| 348 |
-%define BUTTERF BUTTERF_SSE3 |
|
| 349 |
-%define BUTTERF0 BUTTERF0_SSE3 |
|
| 349 |
+INIT_XMM sse |
|
| 350 | 350 |
|
| 351 |
-DEFINE_IMDCT sse3 |
|
| 352 |
- |
|
| 353 |
-%define ROTLEFT ROTLEFT_SSSE3 |
|
| 351 |
+%ifdef ARCH_X86_64 |
|
| 352 |
+%define SPILL SWAP |
|
| 353 |
+%define UNSPILL SWAP |
|
| 354 |
+%define SPILLED(x) m %+ x |
|
| 355 |
+%else |
|
| 356 |
+%define SPILLED(x) [tmpq+(x-8)*16 + 32*4] |
|
| 357 |
+%macro SPILL 2 ; xmm#, mempos |
|
| 358 |
+ movaps SPILLED(%2), m%1 |
|
| 359 |
+%endmacro |
|
| 360 |
+%macro UNSPILL 2 |
|
| 361 |
+ movaps m%1, SPILLED(%2) |
|
| 362 |
+%endmacro |
|
| 363 |
+%endif |
|
| 354 | 364 |
|
| 355 |
-DEFINE_IMDCT ssse3 |
|
| 365 |
+%macro DEFINE_FOUR_IMDCT 0 |
|
| 366 |
+cglobal four_imdct36_float, 5,5,8, out, buf, in, win, tmp |
|
| 367 |
+ movlps m0, [inq+64] |
|
| 368 |
+ movhps m0, [inq+64 + 72] |
|
| 369 |
+ movlps m3, [inq+64 + 2*72] |
|
| 370 |
+ movhps m3, [inq+64 + 3*72] |
|
| 371 |
+ |
|
| 372 |
+ shufps m5, m0, m3, 0xdd |
|
| 373 |
+ shufps m0, m0, m3, 0x88 |
|
| 374 |
+ |
|
| 375 |
+ mova m1, [inq+48] |
|
| 376 |
+ movu m6, [inq+48 + 72] |
|
| 377 |
+ mova m7, [inq+48 + 2*72] |
|
| 378 |
+ movu m3, [inq+48 + 3*72] |
|
| 379 |
+ |
|
| 380 |
+ TRANSPOSE4x4PS 1, 6, 7, 3, 4 |
|
| 381 |
+ |
|
| 382 |
+ addps m4, m6, m7 |
|
| 383 |
+ mova [tmpq+4*28], m4 |
|
| 384 |
+ |
|
| 385 |
+ addps m7, m3 |
|
| 386 |
+ addps m6, m1 |
|
| 387 |
+ addps m3, m0 |
|
| 388 |
+ addps m0, m5 |
|
| 389 |
+ addps m0, m7 |
|
| 390 |
+ addps m7, m6 |
|
| 391 |
+ mova [tmpq+4*12], m7 |
|
| 392 |
+ SPILL 3, 12 |
|
| 393 |
+ |
|
| 394 |
+ mova m4, [inq+32] |
|
| 395 |
+ movu m5, [inq+32 + 72] |
|
| 396 |
+ mova m2, [inq+32 + 2*72] |
|
| 397 |
+ movu m7, [inq+32 + 3*72] |
|
| 398 |
+ |
|
| 399 |
+ TRANSPOSE4x4PS 4, 5, 2, 7, 3 |
|
| 400 |
+ |
|
| 401 |
+ addps m1, m7 |
|
| 402 |
+ SPILL 1, 11 |
|
| 403 |
+ |
|
| 404 |
+ addps m3, m5, m2 |
|
| 405 |
+ SPILL 3, 13 |
|
| 406 |
+ |
|
| 407 |
+ addps m7, m2 |
|
| 408 |
+ addps m5, m4 |
|
| 409 |
+ addps m6, m7 |
|
| 410 |
+ mova [tmpq], m6 |
|
| 411 |
+ addps m7, m5 |
|
| 412 |
+ mova [tmpq+4*16], m7 |
|
| 413 |
+ |
|
| 414 |
+ mova m2, [inq+16] |
|
| 415 |
+ movu m7, [inq+16 + 72] |
|
| 416 |
+ mova m1, [inq+16 + 2*72] |
|
| 417 |
+ movu m6, [inq+16 + 3*72] |
|
| 418 |
+ |
|
| 419 |
+ TRANSPOSE4x4PS 2, 7, 1, 6, 3 |
|
| 420 |
+ |
|
| 421 |
+ addps m4, m6 |
|
| 422 |
+ addps m6, m1 |
|
| 423 |
+ addps m1, m7 |
|
| 424 |
+ addps m7, m2 |
|
| 425 |
+ addps m5, m6 |
|
| 426 |
+ SPILL 5, 15 |
|
| 427 |
+ addps m6, m7 |
|
| 428 |
+ mulps m6, [costabs + 16*2] |
|
| 429 |
+ mova [tmpq+4*8], m6 |
|
| 430 |
+ SPILL 1, 10 |
|
| 431 |
+ SPILL 0, 14 |
|
| 432 |
+ |
|
| 433 |
+ mova m1, [inq] |
|
| 434 |
+ movu m6, [inq + 72] |
|
| 435 |
+ mova m3, [inq + 2*72] |
|
| 436 |
+ movu m5, [inq + 3*72] |
|
| 437 |
+ |
|
| 438 |
+ TRANSPOSE4x4PS 1, 6, 3, 5, 0 |
|
| 439 |
+ |
|
| 440 |
+ addps m2, m5 |
|
| 441 |
+ addps m5, m3 |
|
| 442 |
+ addps m7, m5 |
|
| 443 |
+ addps m3, m6 |
|
| 444 |
+ addps m6, m1 |
|
| 445 |
+ SPILL 7, 8 |
|
| 446 |
+ addps m5, m6 |
|
| 447 |
+ SPILL 6, 9 |
|
| 448 |
+ addps m6, m4, SPILLED(12) |
|
| 449 |
+ subps m6, m2 |
|
| 450 |
+ UNSPILL 7, 11 |
|
| 451 |
+ SPILL 5, 11 |
|
| 452 |
+ subps m5, m1, m7 |
|
| 453 |
+ mulps m7, [costabs + 16*5] |
|
| 454 |
+ addps m7, m1 |
|
| 455 |
+ mulps m0, m6, [costabs + 16*6] |
|
| 456 |
+ addps m0, m5 |
|
| 457 |
+ mova [tmpq+4*24], m0 |
|
| 458 |
+ addps m6, m5 |
|
| 459 |
+ mova [tmpq+4*4], m6 |
|
| 460 |
+ addps m6, m4, m2 |
|
| 461 |
+ mulps m6, [costabs + 16*1] |
|
| 462 |
+ subps m4, SPILLED(12) |
|
| 463 |
+ mulps m4, [costabs + 16*8] |
|
| 464 |
+ addps m2, SPILLED(12) |
|
| 465 |
+ mulps m2, [costabs + 16*3] |
|
| 466 |
+ subps m5, m7, m6 |
|
| 467 |
+ subps m5, m2 |
|
| 468 |
+ addps m6, m7 |
|
| 469 |
+ addps m6, m4 |
|
| 470 |
+ addps m7, m2 |
|
| 471 |
+ subps m7, m4 |
|
| 472 |
+ mova [tmpq+4*20], m7 |
|
| 473 |
+ mova m2, [tmpq+4*28] |
|
| 474 |
+ mova [tmpq+4*28], m5 |
|
| 475 |
+ UNSPILL 7, 13 |
|
| 476 |
+ subps m5, m7, m2 |
|
| 477 |
+ mulps m5, [costabs + 16*7] |
|
| 478 |
+ UNSPILL 1, 10 |
|
| 479 |
+ mulps m1, [costabs + 16*2] |
|
| 480 |
+ addps m4, m3, m2 |
|
| 481 |
+ mulps m4, [costabs + 16*4] |
|
| 482 |
+ addps m2, m7 |
|
| 483 |
+ addps m7, m3 |
|
| 484 |
+ mulps m7, [costabs] |
|
| 485 |
+ subps m3, m2 |
|
| 486 |
+ mulps m3, [costabs + 16*2] |
|
| 487 |
+ addps m2, m7, m5 |
|
| 488 |
+ addps m2, m1 |
|
| 489 |
+ SPILL 2, 10 |
|
| 490 |
+ addps m7, m4 |
|
| 491 |
+ subps m7, m1 |
|
| 492 |
+ SPILL 7, 12 |
|
| 493 |
+ subps m5, m4 |
|
| 494 |
+ subps m5, m1 |
|
| 495 |
+ UNSPILL 0, 14 |
|
| 496 |
+ SPILL 5, 13 |
|
| 497 |
+ addps m1, m0, SPILLED(15) |
|
| 498 |
+ subps m1, SPILLED(8) |
|
| 499 |
+ mova m4, [costabs + 16*5] |
|
| 500 |
+ mulps m4, [tmpq] |
|
| 501 |
+ UNSPILL 2, 9 |
|
| 502 |
+ addps m4, m2 |
|
| 503 |
+ subps m2, [tmpq] |
|
| 504 |
+ mulps m5, m1, [costabs + 16*6] |
|
| 505 |
+ addps m5, m2 |
|
| 506 |
+ SPILL 5, 9 |
|
| 507 |
+ addps m2, m1 |
|
| 508 |
+ SPILL 2, 14 |
|
| 509 |
+ UNSPILL 5, 15 |
|
| 510 |
+ subps m7, m5, m0 |
|
| 511 |
+ addps m5, SPILLED(8) |
|
| 512 |
+ mulps m5, [costabs + 16*1] |
|
| 513 |
+ mulps m7, [costabs + 16*8] |
|
| 514 |
+ addps m0, SPILLED(8) |
|
| 515 |
+ mulps m0, [costabs + 16*3] |
|
| 516 |
+ subps m2, m4, m5 |
|
| 517 |
+ subps m2, m0 |
|
| 518 |
+ SPILL 2, 15 |
|
| 519 |
+ addps m5, m4 |
|
| 520 |
+ addps m5, m7 |
|
| 521 |
+ addps m4, m0 |
|
| 522 |
+ subps m4, m7 |
|
| 523 |
+ SPILL 4, 8 |
|
| 524 |
+ mova m7, [tmpq+4*16] |
|
| 525 |
+ mova m2, [tmpq+4*12] |
|
| 526 |
+ addps m0, m7, m2 |
|
| 527 |
+ subps m0, SPILLED(11) |
|
| 528 |
+ mulps m0, [costabs + 16*2] |
|
| 529 |
+ addps m4, m7, SPILLED(11) |
|
| 530 |
+ mulps m4, [costabs] |
|
| 531 |
+ subps m7, m2 |
|
| 532 |
+ mulps m7, [costabs + 16*7] |
|
| 533 |
+ addps m2, SPILLED(11) |
|
| 534 |
+ mulps m2, [costabs + 16*4] |
|
| 535 |
+ addps m1, m7, [tmpq+4*8] |
|
| 536 |
+ addps m1, m4 |
|
| 537 |
+ addps m4, m2 |
|
| 538 |
+ subps m4, [tmpq+4*8] |
|
| 539 |
+ SPILL 4, 11 |
|
| 540 |
+ subps m7, m2 |
|
| 541 |
+ subps m7, [tmpq+4*8] |
|
| 542 |
+ addps m4, m6, SPILLED(10) |
|
| 543 |
+ subps m6, SPILLED(10) |
|
| 544 |
+ addps m2, m5, m1 |
|
| 545 |
+ mulps m2, [costabs + 16*9] |
|
| 546 |
+ subps m5, m1 |
|
| 547 |
+ mulps m5, [costabs + 16*17] |
|
| 548 |
+ subps m1, m4, m2 |
|
| 549 |
+ addps m4, m2 |
|
| 550 |
+ mulps m2, m1, [winq+4*36] |
|
| 551 |
+ addps m2, [bufq+4*36] |
|
| 552 |
+ mova [outq+1152], m2 |
|
| 553 |
+ mulps m1, [winq+4*32] |
|
| 554 |
+ addps m1, [bufq+4*32] |
|
| 555 |
+ mova [outq+1024], m1 |
|
| 556 |
+ mulps m1, m4, [winq+4*116] |
|
| 557 |
+ mova [bufq+4*36], m1 |
|
| 558 |
+ mulps m4, [winq+4*112] |
|
| 559 |
+ mova [bufq+4*32], m4 |
|
| 560 |
+ addps m2, m6, m5 |
|
| 561 |
+ subps m6, m5 |
|
| 562 |
+ mulps m1, m6, [winq+4*68] |
|
| 563 |
+ addps m1, [bufq+4*68] |
|
| 564 |
+ mova [outq+2176], m1 |
|
| 565 |
+ mulps m6, [winq] |
|
| 566 |
+ addps m6, [bufq] |
|
| 567 |
+ mova [outq], m6 |
|
| 568 |
+ mulps m1, m2, [winq+4*148] |
|
| 569 |
+ mova [bufq+4*68], m1 |
|
| 570 |
+ mulps m2, [winq+4*80] |
|
| 571 |
+ mova [bufq], m2 |
|
| 572 |
+ addps m5, m3, [tmpq+4*24] |
|
| 573 |
+ mova m2, [tmpq+4*24] |
|
| 574 |
+ subps m2, m3 |
|
| 575 |
+ mova m1, SPILLED(9) |
|
| 576 |
+ subps m1, m0 |
|
| 577 |
+ mulps m1, [costabs + 16*10] |
|
| 578 |
+ addps m0, SPILLED(9) |
|
| 579 |
+ mulps m0, [costabs + 16*16] |
|
| 580 |
+ addps m6, m5, m1 |
|
| 581 |
+ subps m5, m1 |
|
| 582 |
+ mulps m3, m5, [winq+4*40] |
|
| 583 |
+ addps m3, [bufq+4*40] |
|
| 584 |
+ mova [outq+1280], m3 |
|
| 585 |
+ mulps m5, [winq+4*28] |
|
| 586 |
+ addps m5, [bufq+4*28] |
|
| 587 |
+ mova [outq+896], m5 |
|
| 588 |
+ mulps m1, m6, [winq+4*120] |
|
| 589 |
+ mova [bufq+4*40], m1 |
|
| 590 |
+ mulps m6, [winq+4*108] |
|
| 591 |
+ mova [bufq+4*28], m6 |
|
| 592 |
+ addps m1, m2, m0 |
|
| 593 |
+ subps m2, m0 |
|
| 594 |
+ mulps m5, m2, [winq+4*64] |
|
| 595 |
+ addps m5, [bufq+4*64] |
|
| 596 |
+ mova [outq+2048], m5 |
|
| 597 |
+ mulps m2, [winq+4*4] |
|
| 598 |
+ addps m2, [bufq+4*4] |
|
| 599 |
+ mova [outq+128], m2 |
|
| 600 |
+ mulps m0, m1, [winq+4*144] |
|
| 601 |
+ mova [bufq+4*64], m0 |
|
| 602 |
+ mulps m1, [winq+4*84] |
|
| 603 |
+ mova [bufq+4*4], m1 |
|
| 604 |
+ mova m1, [tmpq+4*28] |
|
| 605 |
+ mova m5, m1 |
|
| 606 |
+ addps m1, SPILLED(13) |
|
| 607 |
+ subps m5, SPILLED(13) |
|
| 608 |
+ UNSPILL 3, 15 |
|
| 609 |
+ addps m2, m7, m3 |
|
| 610 |
+ mulps m2, [costabs + 16*11] |
|
| 611 |
+ subps m3, m7 |
|
| 612 |
+ mulps m3, [costabs + 16*15] |
|
| 613 |
+ addps m0, m2, m1 |
|
| 614 |
+ subps m1, m2 |
|
| 615 |
+ SWAP m0, m2 |
|
| 616 |
+ mulps m6, m1, [winq+4*44] |
|
| 617 |
+ addps m6, [bufq+4*44] |
|
| 618 |
+ mova [outq+1408], m6 |
|
| 619 |
+ mulps m1, [winq+4*24] |
|
| 620 |
+ addps m1, [bufq+4*24] |
|
| 621 |
+ mova [outq+768], m1 |
|
| 622 |
+ mulps m0, m2, [winq+4*124] |
|
| 623 |
+ mova [bufq+4*44], m0 |
|
| 624 |
+ mulps m2, [winq+4*104] |
|
| 625 |
+ mova [bufq+4*24], m2 |
|
| 626 |
+ addps m0, m5, m3 |
|
| 627 |
+ subps m5, m3 |
|
| 628 |
+ mulps m1, m5, [winq+4*60] |
|
| 629 |
+ addps m1, [bufq+4*60] |
|
| 630 |
+ mova [outq+1920], m1 |
|
| 631 |
+ mulps m5, [winq+4*8] |
|
| 632 |
+ addps m5, [bufq+4*8] |
|
| 633 |
+ mova [outq+256], m5 |
|
| 634 |
+ mulps m1, m0, [winq+4*140] |
|
| 635 |
+ mova [bufq+4*60], m1 |
|
| 636 |
+ mulps m0, [winq+4*88] |
|
| 637 |
+ mova [bufq+4*8], m0 |
|
| 638 |
+ mova m1, [tmpq+4*20] |
|
| 639 |
+ addps m1, SPILLED(12) |
|
| 640 |
+ mova m2, [tmpq+4*20] |
|
| 641 |
+ subps m2, SPILLED(12) |
|
| 642 |
+ UNSPILL 7, 8 |
|
| 643 |
+ subps m0, m7, SPILLED(11) |
|
| 644 |
+ addps m7, SPILLED(11) |
|
| 645 |
+ mulps m4, m7, [costabs + 16*12] |
|
| 646 |
+ mulps m0, [costabs + 16*14] |
|
| 647 |
+ addps m5, m1, m4 |
|
| 648 |
+ subps m1, m4 |
|
| 649 |
+ mulps m7, m1, [winq+4*48] |
|
| 650 |
+ addps m7, [bufq+4*48] |
|
| 651 |
+ mova [outq+1536], m7 |
|
| 652 |
+ mulps m1, [winq+4*20] |
|
| 653 |
+ addps m1, [bufq+4*20] |
|
| 654 |
+ mova [outq+640], m1 |
|
| 655 |
+ mulps m1, m5, [winq+4*128] |
|
| 656 |
+ mova [bufq+4*48], m1 |
|
| 657 |
+ mulps m5, [winq+4*100] |
|
| 658 |
+ mova [bufq+4*20], m5 |
|
| 659 |
+ addps m6, m2, m0 |
|
| 660 |
+ subps m2, m0 |
|
| 661 |
+ mulps m1, m2, [winq+4*56] |
|
| 662 |
+ addps m1, [bufq+4*56] |
|
| 663 |
+ mova [outq+1792], m1 |
|
| 664 |
+ mulps m2, [winq+4*12] |
|
| 665 |
+ addps m2, [bufq+4*12] |
|
| 666 |
+ mova [outq+384], m2 |
|
| 667 |
+ mulps m0, m6, [winq+4*136] |
|
| 668 |
+ mova [bufq+4*56], m0 |
|
| 669 |
+ mulps m6, [winq+4*92] |
|
| 670 |
+ mova [bufq+4*12], m6 |
|
| 671 |
+ UNSPILL 0, 14 |
|
| 672 |
+ mulps m0, [costabs + 16*13] |
|
| 673 |
+ mova m3, [tmpq+4*4] |
|
| 674 |
+ addps m2, m0, m3 |
|
| 675 |
+ subps m3, m0 |
|
| 676 |
+ mulps m0, m3, [winq+4*52] |
|
| 677 |
+ addps m0, [bufq+4*52] |
|
| 678 |
+ mova [outq+1664], m0 |
|
| 679 |
+ mulps m3, [winq+4*16] |
|
| 680 |
+ addps m3, [bufq+4*16] |
|
| 681 |
+ mova [outq+512], m3 |
|
| 682 |
+ mulps m0, m2, [winq+4*132] |
|
| 683 |
+ mova [bufq+4*52], m0 |
|
| 684 |
+ mulps m2, [winq+4*96] |
|
| 685 |
+ mova [bufq+4*16], m2 |
|
| 686 |
+ RET |
|
| 687 |
+%endmacro |
|
| 356 | 688 |
|
| 357 |
-%define BUILDINVHIGHLOW BUILDINVHIGHLOW_AVX |
|
| 358 |
-%define PSHUFD PSHUFD_SSE_AVX |
|
| 689 |
+INIT_XMM sse |
|
| 690 |
+DEFINE_FOUR_IMDCT |
|
| 359 | 691 |
|
| 360 |
-INIT_AVX |
|
| 361 |
-DEFINE_IMDCT avx |
|
| 692 |
+INIT_XMM avx |
|
| 693 |
+DEFINE_FOUR_IMDCT |
| ... | ... |
@@ -29,6 +29,12 @@ void ff_imdct36_float_sse2(float *out, float *buf, float *in, float *win); |
| 29 | 29 |
void ff_imdct36_float_sse3(float *out, float *buf, float *in, float *win); |
| 30 | 30 |
void ff_imdct36_float_ssse3(float *out, float *buf, float *in, float *win); |
| 31 | 31 |
void ff_imdct36_float_avx(float *out, float *buf, float *in, float *win); |
| 32 |
+void ff_four_imdct36_float_sse(float *out, float *buf, float *in, float *win, |
|
| 33 |
+ float *tmpbuf); |
|
| 34 |
+void ff_four_imdct36_float_avx(float *out, float *buf, float *in, float *win, |
|
| 35 |
+ float *tmpbuf); |
|
| 36 |
+ |
|
| 37 |
+DECLARE_ALIGNED(16, static float, mdct_win_sse)[2][4][4*40]; |
|
| 32 | 38 |
|
| 33 | 39 |
#define MACS(rt, ra, rb) rt+=(ra)*(rb) |
| 34 | 40 |
#define MLSS(rt, ra, rb) rt-=(ra)*(rb) |
| ... | ... |
@@ -153,26 +159,79 @@ static void apply_window_mp3(float *in, float *win, int *unused, float *out, |
| 153 | 153 |
*out = sum; |
| 154 | 154 |
} |
| 155 | 155 |
|
| 156 |
+ |
|
| 157 |
+#define DECL_IMDCT_BLOCKS(CPU1, CPU2) \ |
|
| 158 |
+static void imdct36_blocks_ ## CPU1(float *out, float *buf, float *in, \ |
|
| 159 |
+ int count, int switch_point, int block_type) \ |
|
| 160 |
+{ \
|
|
| 161 |
+ int align_end = count - (count & 3); \ |
|
| 162 |
+ int j; \ |
|
| 163 |
+ for (j = 0; j < align_end; j+= 4) { \
|
|
| 164 |
+ LOCAL_ALIGNED_16(float, tmpbuf, [1024]); \ |
|
| 165 |
+ float *win = mdct_win_sse[switch_point && j < 4][block_type]; \ |
|
| 166 |
+ /* apply window & overlap with previous buffer */ \ |
|
| 167 |
+ \ |
|
| 168 |
+ /* select window */ \ |
|
| 169 |
+ ff_four_imdct36_float_ ## CPU2(out, buf, in, win, tmpbuf); \ |
|
| 170 |
+ in += 4*18; \ |
|
| 171 |
+ buf += 4*18; \ |
|
| 172 |
+ out += 4; \ |
|
| 173 |
+ } \ |
|
| 174 |
+ for (; j < count; j++) { \
|
|
| 175 |
+ /* apply window & overlap with previous buffer */ \ |
|
| 176 |
+ \ |
|
| 177 |
+ /* select window */ \ |
|
| 178 |
+ int win_idx = (switch_point && j < 2) ? 0 : block_type; \ |
|
| 179 |
+ float *win = ff_mdct_win_float[win_idx + (4 & -(j & 1))]; \ |
|
| 180 |
+ \ |
|
| 181 |
+ ff_imdct36_float_ ## CPU1(out, buf, in, win); \ |
|
| 182 |
+ \ |
|
| 183 |
+ in += 18; \ |
|
| 184 |
+ buf++; \ |
|
| 185 |
+ out++; \ |
|
| 186 |
+ } \ |
|
| 187 |
+} |
|
| 188 |
+ |
|
| 189 |
+DECL_IMDCT_BLOCKS(sse,sse) |
|
| 190 |
+DECL_IMDCT_BLOCKS(sse2,sse) |
|
| 191 |
+DECL_IMDCT_BLOCKS(sse3,sse) |
|
| 192 |
+DECL_IMDCT_BLOCKS(ssse3,sse) |
|
| 193 |
+DECL_IMDCT_BLOCKS(avx,avx) |
|
| 194 |
+ |
|
| 156 | 195 |
void ff_mpadsp_init_mmx(MPADSPContext *s) |
| 157 | 196 |
{
|
| 158 | 197 |
int mm_flags = av_get_cpu_flags(); |
| 159 | 198 |
|
| 199 |
+ int i, j; |
|
| 200 |
+ for (j = 0; j < 4; j++) {
|
|
| 201 |
+ for (i = 0; i < 40; i ++) {
|
|
| 202 |
+ mdct_win_sse[0][j][4*i ] = ff_mdct_win_float[j ][i]; |
|
| 203 |
+ mdct_win_sse[0][j][4*i + 1] = ff_mdct_win_float[j + 4][i]; |
|
| 204 |
+ mdct_win_sse[0][j][4*i + 2] = ff_mdct_win_float[j ][i]; |
|
| 205 |
+ mdct_win_sse[0][j][4*i + 3] = ff_mdct_win_float[j + 4][i]; |
|
| 206 |
+ mdct_win_sse[1][j][4*i ] = ff_mdct_win_float[0 ][i]; |
|
| 207 |
+ mdct_win_sse[1][j][4*i + 1] = ff_mdct_win_float[4 ][i]; |
|
| 208 |
+ mdct_win_sse[1][j][4*i + 2] = ff_mdct_win_float[j ][i]; |
|
| 209 |
+ mdct_win_sse[1][j][4*i + 3] = ff_mdct_win_float[j + 4][i]; |
|
| 210 |
+ } |
|
| 211 |
+ } |
|
| 212 |
+ |
|
| 160 | 213 |
if (mm_flags & AV_CPU_FLAG_SSE2) {
|
| 161 | 214 |
s->apply_window_float = apply_window_mp3; |
| 162 | 215 |
} |
| 163 |
- if (HAVE_YASM && mm_flags & AV_CPU_FLAG_AVX && HAVE_AVX) {
|
|
| 164 |
- s->imdct36_float = ff_imdct36_float_avx; |
|
| 165 |
- } |
|
| 166 |
- else if (HAVE_YASM && mm_flags & AV_CPU_FLAG_SSSE3 && HAVE_SSE) {
|
|
| 167 |
- s->imdct36_float = ff_imdct36_float_ssse3; |
|
| 168 |
- } |
|
| 169 |
- else if (HAVE_YASM && mm_flags & AV_CPU_FLAG_SSE3 && HAVE_SSE) {
|
|
| 170 |
- s->imdct36_float = ff_imdct36_float_sse3; |
|
| 171 |
- } |
|
| 172 |
- else if (HAVE_YASM && mm_flags & AV_CPU_FLAG_SSE2 && HAVE_SSE) {
|
|
| 173 |
- s->imdct36_float = ff_imdct36_float_sse2; |
|
| 174 |
- } |
|
| 175 |
- else if (HAVE_YASM && mm_flags & AV_CPU_FLAG_SSE && HAVE_SSE) {
|
|
| 176 |
- s->imdct36_float = ff_imdct36_float_sse; |
|
| 216 |
+#if HAVE_YASM |
|
| 217 |
+ if (mm_flags & AV_CPU_FLAG_AVX && HAVE_AVX) {
|
|
| 218 |
+ s->imdct36_blocks_float = imdct36_blocks_avx; |
|
| 219 |
+#if HAVE_SSE |
|
| 220 |
+ } else if (mm_flags & AV_CPU_FLAG_SSSE3) {
|
|
| 221 |
+ s->imdct36_blocks_float = imdct36_blocks_ssse3; |
|
| 222 |
+ } else if (mm_flags & AV_CPU_FLAG_SSE3) {
|
|
| 223 |
+ s->imdct36_blocks_float = imdct36_blocks_sse3; |
|
| 224 |
+ } else if (mm_flags & AV_CPU_FLAG_SSE2) {
|
|
| 225 |
+ s->imdct36_blocks_float = imdct36_blocks_sse2; |
|
| 226 |
+ } else if (mm_flags & AV_CPU_FLAG_SSE) {
|
|
| 227 |
+ s->imdct36_blocks_float = imdct36_blocks_sse; |
|
| 228 |
+#endif /* HAVE_SSE */ |
|
| 177 | 229 |
} |
| 230 |
+#endif /* HAVE_YASM */ |
|
| 178 | 231 |
} |
| ... | ... |
@@ -931,6 +931,8 @@ AVX_INSTR minpd, 1, 0, 1 |
| 931 | 931 |
AVX_INSTR minps, 1, 0, 1 |
| 932 | 932 |
AVX_INSTR minsd, 1, 0, 1 |
| 933 | 933 |
AVX_INSTR minss, 1, 0, 1 |
| 934 |
+AVX_INSTR movhlps, 1, 0, 0 |
|
| 935 |
+AVX_INSTR movlhps, 1, 0, 0 |
|
| 934 | 936 |
AVX_INSTR movsd, 1, 0, 0 |
| 935 | 937 |
AVX_INSTR movss, 1, 0, 0 |
| 936 | 938 |
AVX_INSTR mpsadbw, 0, 1, 0 |
| ... | ... |
@@ -19,7 +19,8 @@ OBJS-$(HAVE_MMX) += x86/rgb2rgb.o \ |
| 19 | 19 |
x86/swscale_mmx.o \ |
| 20 | 20 |
x86/yuv2rgb_mmx.o |
| 21 | 21 |
OBJS-$(HAVE_VIS) += sparc/yuv2rgb_vis.o |
| 22 |
-MMX-OBJS-$(HAVE_YASM) += x86/output.o \ |
|
| 22 |
+MMX-OBJS-$(HAVE_YASM) += x86/input.o \ |
|
| 23 |
+ x86/output.o \ |
|
| 23 | 24 |
x86/scale.o |
| 24 | 25 |
|
| 25 | 26 |
$(SUBDIR)x86/swscale_mmx.o: CFLAGS += $(NOREDZONE_FLAGS) |
| ... | ... |
@@ -27,19 +27,19 @@ |
| 27 | 27 |
#include "swscale.h" |
| 28 | 28 |
#include "rgb2rgb.h" |
| 29 | 29 |
|
| 30 |
-#define SIZE 1000 |
|
| 30 |
+#define SIZE 1000 |
|
| 31 | 31 |
#define srcByte 0x55 |
| 32 | 32 |
#define dstByte 0xBB |
| 33 | 33 |
|
| 34 |
-#define FUNC(s,d,n) {s,d,#n,n}
|
|
| 34 |
+#define FUNC(s, d, n) { s, d, #n, n }
|
|
| 35 | 35 |
|
| 36 | 36 |
int main(int argc, char **argv) |
| 37 | 37 |
{
|
| 38 | 38 |
int i, funcNum; |
| 39 | 39 |
uint8_t *srcBuffer = av_malloc(SIZE); |
| 40 | 40 |
uint8_t *dstBuffer = av_malloc(SIZE); |
| 41 |
- int failedNum=0; |
|
| 42 |
- int passedNum=0; |
|
| 41 |
+ int failedNum = 0; |
|
| 42 |
+ int passedNum = 0; |
|
| 43 | 43 |
|
| 44 | 44 |
if (!srcBuffer || !dstBuffer) |
| 45 | 45 |
return -1; |
| ... | ... |
@@ -47,7 +47,7 @@ int main(int argc, char **argv) |
| 47 | 47 |
av_log(NULL, AV_LOG_INFO, "memory corruption test ...\n"); |
| 48 | 48 |
sws_rgb2rgb_init(); |
| 49 | 49 |
|
| 50 |
- for(funcNum=0; ; funcNum++) {
|
|
| 50 |
+ for (funcNum = 0; ; funcNum++) {
|
|
| 51 | 51 |
struct func_info_s {
|
| 52 | 52 |
int src_bpp; |
| 53 | 53 |
int dst_bpp; |
| ... | ... |
@@ -85,67 +85,78 @@ int main(int argc, char **argv) |
| 85 | 85 |
FUNC(0, 0, NULL) |
| 86 | 86 |
}; |
| 87 | 87 |
int width; |
| 88 |
- int failed=0; |
|
| 89 |
- int srcBpp=0; |
|
| 90 |
- int dstBpp=0; |
|
| 88 |
+ int failed = 0; |
|
| 89 |
+ int srcBpp = 0; |
|
| 90 |
+ int dstBpp = 0; |
|
| 91 | 91 |
|
| 92 |
- if (!func_info[funcNum].func) break; |
|
| 92 |
+ if (!func_info[funcNum].func) |
|
| 93 |
+ break; |
|
| 93 | 94 |
|
| 94 |
- av_log(NULL, AV_LOG_INFO,"."); |
|
| 95 |
+ av_log(NULL, AV_LOG_INFO, "."); |
|
| 95 | 96 |
memset(srcBuffer, srcByte, SIZE); |
| 96 | 97 |
|
| 97 |
- for(width=63; width>0; width--) {
|
|
| 98 |
+ for (width = 63; width > 0; width--) {
|
|
| 98 | 99 |
int dstOffset; |
| 99 |
- for(dstOffset=128; dstOffset<196; dstOffset+=4) {
|
|
| 100 |
+ for (dstOffset = 128; dstOffset < 196; dstOffset += 4) {
|
|
| 100 | 101 |
int srcOffset; |
| 101 | 102 |
memset(dstBuffer, dstByte, SIZE); |
| 102 | 103 |
|
| 103 |
- for(srcOffset=128; srcOffset<196; srcOffset+=4) {
|
|
| 104 |
- uint8_t *src= srcBuffer+srcOffset; |
|
| 105 |
- uint8_t *dst= dstBuffer+dstOffset; |
|
| 106 |
- const char *name=NULL; |
|
| 104 |
+ for (srcOffset = 128; srcOffset < 196; srcOffset += 4) {
|
|
| 105 |
+ uint8_t *src = srcBuffer + srcOffset; |
|
| 106 |
+ uint8_t *dst = dstBuffer + dstOffset; |
|
| 107 |
+ const char *name = NULL; |
|
| 107 | 108 |
|
| 108 |
- if(failed) break; //don't fill the screen with shit ... |
|
| 109 |
+ // don't fill the screen with shit ... |
|
| 110 |
+ if (failed) |
|
| 111 |
+ break; |
|
| 109 | 112 |
|
| 110 | 113 |
srcBpp = func_info[funcNum].src_bpp; |
| 111 | 114 |
dstBpp = func_info[funcNum].dst_bpp; |
| 112 | 115 |
name = func_info[funcNum].name; |
| 113 | 116 |
|
| 114 |
- func_info[funcNum].func(src, dst, width*srcBpp); |
|
| 117 |
+ func_info[funcNum].func(src, dst, width * srcBpp); |
|
| 115 | 118 |
|
| 116 |
- if(!srcBpp) break; |
|
| 119 |
+ if (!srcBpp) |
|
| 120 |
+ break; |
|
| 117 | 121 |
|
| 118 |
- for(i=0; i<SIZE; i++) {
|
|
| 119 |
- if(srcBuffer[i]!=srcByte) {
|
|
| 120 |
- av_log(NULL, AV_LOG_INFO, "src damaged at %d w:%d src:%d dst:%d %s\n", |
|
| 122 |
+ for (i = 0; i < SIZE; i++) {
|
|
| 123 |
+ if (srcBuffer[i] != srcByte) {
|
|
| 124 |
+ av_log(NULL, AV_LOG_INFO, |
|
| 125 |
+ "src damaged at %d w:%d src:%d dst:%d %s\n", |
|
| 121 | 126 |
i, width, srcOffset, dstOffset, name); |
| 122 |
- failed=1; |
|
| 127 |
+ failed = 1; |
|
| 123 | 128 |
break; |
| 124 | 129 |
} |
| 125 | 130 |
} |
| 126 |
- for(i=0; i<dstOffset; i++) {
|
|
| 127 |
- if(dstBuffer[i]!=dstByte) {
|
|
| 128 |
- av_log(NULL, AV_LOG_INFO, "dst damaged at %d w:%d src:%d dst:%d %s\n", |
|
| 131 |
+ for (i = 0; i < dstOffset; i++) {
|
|
| 132 |
+ if (dstBuffer[i] != dstByte) {
|
|
| 133 |
+ av_log(NULL, AV_LOG_INFO, |
|
| 134 |
+ "dst damaged at %d w:%d src:%d dst:%d %s\n", |
|
| 129 | 135 |
i, width, srcOffset, dstOffset, name); |
| 130 |
- failed=1; |
|
| 136 |
+ failed = 1; |
|
| 131 | 137 |
break; |
| 132 | 138 |
} |
| 133 | 139 |
} |
| 134 |
- for(i=dstOffset + width*dstBpp; i<SIZE; i++) {
|
|
| 135 |
- if(dstBuffer[i]!=dstByte) {
|
|
| 136 |
- av_log(NULL, AV_LOG_INFO, "dst damaged at %d w:%d src:%d dst:%d %s\n", |
|
| 140 |
+ for (i = dstOffset + width * dstBpp; i < SIZE; i++) {
|
|
| 141 |
+ if (dstBuffer[i] != dstByte) {
|
|
| 142 |
+ av_log(NULL, AV_LOG_INFO, |
|
| 143 |
+ "dst damaged at %d w:%d src:%d dst:%d %s\n", |
|
| 137 | 144 |
i, width, srcOffset, dstOffset, name); |
| 138 |
- failed=1; |
|
| 145 |
+ failed = 1; |
|
| 139 | 146 |
break; |
| 140 | 147 |
} |
| 141 | 148 |
} |
| 142 | 149 |
} |
| 143 | 150 |
} |
| 144 | 151 |
} |
| 145 |
- if(failed) failedNum++; |
|
| 146 |
- else if(srcBpp) passedNum++; |
|
| 152 |
+ if (failed) |
|
| 153 |
+ failedNum++; |
|
| 154 |
+ else if (srcBpp) |
|
| 155 |
+ passedNum++; |
|
| 147 | 156 |
} |
| 148 | 157 |
|
| 149 |
- av_log(NULL, AV_LOG_INFO, "\n%d converters passed, %d converters randomly overwrote memory\n", passedNum, failedNum); |
|
| 158 |
+ av_log(NULL, AV_LOG_INFO, |
|
| 159 |
+ "\n%d converters passed, %d converters randomly overwrote memory\n", |
|
| 160 |
+ passedNum, failedNum); |
|
| 150 | 161 |
return failedNum; |
| 151 | 162 |
} |
| ... | ... |
@@ -24,13 +24,18 @@ |
| 24 | 24 |
#ifndef SWSCALE_PPC_YUV2RGB_ALTIVEC_H |
| 25 | 25 |
#define SWSCALE_PPC_YUV2RGB_ALTIVEC_H |
| 26 | 26 |
|
| 27 |
-#define YUV2PACKEDX_HEADER(suffix) \ |
|
| 28 |
-void ff_yuv2 ## suffix ## _X_altivec(SwsContext *c, const int16_t *lumFilter, \ |
|
| 29 |
- const int16_t **lumSrc, int lumFilterSize, \ |
|
| 30 |
- const int16_t *chrFilter, const int16_t **chrUSrc, \ |
|
| 31 |
- const int16_t **chrVSrc, int chrFilterSize, \ |
|
| 32 |
- const int16_t **alpSrc, uint8_t *dest, \ |
|
| 33 |
- int dstW, int dstY); |
|
| 27 |
+#define YUV2PACKEDX_HEADER(suffix) \ |
|
| 28 |
+ void ff_yuv2 ## suffix ## _X_altivec(SwsContext *c, \ |
|
| 29 |
+ const int16_t *lumFilter, \ |
|
| 30 |
+ const int16_t **lumSrc, \ |
|
| 31 |
+ int lumFilterSize, \ |
|
| 32 |
+ const int16_t *chrFilter, \ |
|
| 33 |
+ const int16_t **chrUSrc, \ |
|
| 34 |
+ const int16_t **chrVSrc, \ |
|
| 35 |
+ int chrFilterSize, \ |
|
| 36 |
+ const int16_t **alpSrc, \ |
|
| 37 |
+ uint8_t *dest, \ |
|
| 38 |
+ int dstW, int dstY); |
|
| 34 | 39 |
|
| 35 | 40 |
YUV2PACKEDX_HEADER(abgr); |
| 36 | 41 |
YUV2PACKEDX_HEADER(bgra); |
| ... | ... |
@@ -36,32 +36,33 @@ extern void (*rgb24tobgr32)(const uint8_t *src, uint8_t *dst, int src_size); |
| 36 | 36 |
extern void (*rgb24tobgr16)(const uint8_t *src, uint8_t *dst, int src_size); |
| 37 | 37 |
extern void (*rgb24tobgr15)(const uint8_t *src, uint8_t *dst, int src_size); |
| 38 | 38 |
extern void (*rgb32tobgr24)(const uint8_t *src, uint8_t *dst, int src_size); |
| 39 |
-extern void (*rgb32to16) (const uint8_t *src, uint8_t *dst, int src_size); |
|
| 40 |
-extern void (*rgb32to15) (const uint8_t *src, uint8_t *dst, int src_size); |
|
| 41 |
-extern void (*rgb15to16) (const uint8_t *src, uint8_t *dst, int src_size); |
|
| 39 |
+extern void (*rgb32to16)(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 40 |
+extern void (*rgb32to15)(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 41 |
+extern void (*rgb15to16)(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 42 | 42 |
extern void (*rgb15tobgr24)(const uint8_t *src, uint8_t *dst, int src_size); |
| 43 |
-extern void (*rgb15to32) (const uint8_t *src, uint8_t *dst, int src_size); |
|
| 44 |
-extern void (*rgb16to15) (const uint8_t *src, uint8_t *dst, int src_size); |
|
| 43 |
+extern void (*rgb15to32)(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 44 |
+extern void (*rgb16to15)(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 45 | 45 |
extern void (*rgb16tobgr24)(const uint8_t *src, uint8_t *dst, int src_size); |
| 46 |
-extern void (*rgb16to32) (const uint8_t *src, uint8_t *dst, int src_size); |
|
| 46 |
+extern void (*rgb16to32)(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 47 | 47 |
extern void (*rgb24tobgr24)(const uint8_t *src, uint8_t *dst, int src_size); |
| 48 |
-extern void (*rgb24to16) (const uint8_t *src, uint8_t *dst, int src_size); |
|
| 49 |
-extern void (*rgb24to15) (const uint8_t *src, uint8_t *dst, int src_size); |
|
| 50 |
-extern void (*shuffle_bytes_2103)(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 48 |
+extern void (*rgb24to16)(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 49 |
+extern void (*rgb24to15)(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 51 | 50 |
extern void (*rgb32tobgr16)(const uint8_t *src, uint8_t *dst, int src_size); |
| 52 | 51 |
extern void (*rgb32tobgr15)(const uint8_t *src, uint8_t *dst, int src_size); |
| 53 | 52 |
|
| 54 |
-void rgb24to32 (const uint8_t *src, uint8_t *dst, int src_size); |
|
| 55 |
-void rgb32to24 (const uint8_t *src, uint8_t *dst, int src_size); |
|
| 53 |
+extern void (*shuffle_bytes_2103)(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 54 |
+ |
|
| 55 |
+void rgb24to32(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 56 |
+void rgb32to24(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 56 | 57 |
void rgb16tobgr32(const uint8_t *src, uint8_t *dst, int src_size); |
| 57 |
-void rgb16to24 (const uint8_t *src, uint8_t *dst, int src_size); |
|
| 58 |
+void rgb16to24(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 58 | 59 |
void rgb16tobgr16(const uint8_t *src, uint8_t *dst, int src_size); |
| 59 | 60 |
void rgb16tobgr15(const uint8_t *src, uint8_t *dst, int src_size); |
| 60 | 61 |
void rgb15tobgr32(const uint8_t *src, uint8_t *dst, int src_size); |
| 61 |
-void rgb15to24 (const uint8_t *src, uint8_t *dst, int src_size); |
|
| 62 |
+void rgb15to24(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 62 | 63 |
void rgb15tobgr16(const uint8_t *src, uint8_t *dst, int src_size); |
| 63 | 64 |
void rgb15tobgr15(const uint8_t *src, uint8_t *dst, int src_size); |
| 64 |
-void bgr8torgb8 (const uint8_t *src, uint8_t *dst, int src_size); |
|
| 65 |
+void bgr8torgb8(const uint8_t *src, uint8_t *dst, int src_size); |
|
| 65 | 66 |
|
| 66 | 67 |
void shuffle_bytes_0321(const uint8_t *src, uint8_t *dst, int src_size); |
| 67 | 68 |
void shuffle_bytes_1230(const uint8_t *src, uint8_t *dst, int src_size); |
| ... | ... |
@@ -138,7 +139,6 @@ extern void (*yvu9_to_yuy2)(const uint8_t *src1, const uint8_t *src2, const uint |
| 138 | 138 |
int srcStride1, int srcStride2, |
| 139 | 139 |
int srcStride3, int dstStride); |
| 140 | 140 |
|
| 141 |
- |
|
| 142 | 141 |
extern void (*uyvytoyuv420)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src, |
| 143 | 142 |
int width, int height, |
| 144 | 143 |
int lumStride, int chromStride, int srcStride); |
| ... | ... |
@@ -35,33 +35,32 @@ |
| 35 | 35 |
|
| 36 | 36 |
/* HACK Duplicated from swscale_internal.h. |
| 37 | 37 |
* Should be removed when a cleaner pixel format system exists. */ |
| 38 |
-#define isGray(x) ( \ |
|
| 39 |
- (x)==PIX_FMT_GRAY8 \ |
|
| 40 |
- || (x)==PIX_FMT_GRAY16BE \ |
|
| 41 |
- || (x)==PIX_FMT_GRAY16LE \ |
|
| 42 |
- ) |
|
| 43 |
-#define hasChroma(x) (!( \ |
|
| 44 |
- isGray(x) \ |
|
| 45 |
- || (x)==PIX_FMT_MONOBLACK \ |
|
| 46 |
- || (x)==PIX_FMT_MONOWHITE \ |
|
| 47 |
- )) |
|
| 48 |
-#define isALPHA(x) ( \ |
|
| 49 |
- (x)==PIX_FMT_BGR32 \ |
|
| 50 |
- || (x)==PIX_FMT_BGR32_1 \ |
|
| 51 |
- || (x)==PIX_FMT_RGB32 \ |
|
| 52 |
- || (x)==PIX_FMT_RGB32_1 \ |
|
| 53 |
- || (x)==PIX_FMT_YUVA420P \ |
|
| 54 |
- ) |
|
| 55 |
- |
|
| 56 |
-static uint64_t getSSD(uint8_t *src1, uint8_t *src2, int stride1, int stride2, int w, int h) |
|
| 38 |
+#define isGray(x) \ |
|
| 39 |
+ ((x) == PIX_FMT_GRAY8 || \ |
|
| 40 |
+ (x) == PIX_FMT_Y400A || \ |
|
| 41 |
+ (x) == PIX_FMT_GRAY16BE || \ |
|
| 42 |
+ (x) == PIX_FMT_GRAY16LE) |
|
| 43 |
+#define hasChroma(x) \ |
|
| 44 |
+ (!(isGray(x) || \ |
|
| 45 |
+ (x) == PIX_FMT_MONOBLACK || \ |
|
| 46 |
+ (x) == PIX_FMT_MONOWHITE)) |
|
| 47 |
+#define isALPHA(x) \ |
|
| 48 |
+ ((x) == PIX_FMT_BGR32 || \ |
|
| 49 |
+ (x) == PIX_FMT_BGR32_1 || \ |
|
| 50 |
+ (x) == PIX_FMT_RGB32 || \ |
|
| 51 |
+ (x) == PIX_FMT_RGB32_1 || \ |
|
| 52 |
+ (x) == PIX_FMT_YUVA420P) |
|
| 53 |
+ |
|
| 54 |
+static uint64_t getSSD(uint8_t *src1, uint8_t *src2, int stride1, |
|
| 55 |
+ int stride2, int w, int h) |
|
| 57 | 56 |
{
|
| 58 |
- int x,y; |
|
| 59 |
- uint64_t ssd=0; |
|
| 57 |
+ int x, y; |
|
| 58 |
+ uint64_t ssd = 0; |
|
| 60 | 59 |
|
| 61 |
- for (y=0; y<h; y++) {
|
|
| 62 |
- for (x=0; x<w; x++) {
|
|
| 63 |
- int d= src1[x + y*stride1] - src2[x + y*stride2]; |
|
| 64 |
- ssd+= d*d; |
|
| 60 |
+ for (y = 0; y < h; y++) {
|
|
| 61 |
+ for (x = 0; x < w; x++) {
|
|
| 62 |
+ int d = src1[x + y * stride1] - src2[x + y * stride2]; |
|
| 63 |
+ ssd += d * d; |
|
| 65 | 64 |
} |
| 66 | 65 |
} |
| 67 | 66 |
return ssd; |
| ... | ... |
@@ -86,14 +85,14 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h, |
| 86 | 86 |
static int cur_srcW, cur_srcH; |
| 87 | 87 |
static uint8_t *src[4]; |
| 88 | 88 |
static int srcStride[4]; |
| 89 |
- uint8_t *dst[4] = {0};
|
|
| 90 |
- uint8_t *out[4] = {0};
|
|
| 89 |
+ uint8_t *dst[4] = { 0 };
|
|
| 90 |
+ uint8_t *out[4] = { 0 };
|
|
| 91 | 91 |
int dstStride[4]; |
| 92 | 92 |
int i; |
| 93 |
- uint64_t ssdY, ssdU=0, ssdV=0, ssdA=0; |
|
| 93 |
+ uint64_t ssdY, ssdU = 0, ssdV = 0, ssdA = 0; |
|
| 94 | 94 |
struct SwsContext *dstContext = NULL, *outContext = NULL; |
| 95 | 95 |
uint32_t crc = 0; |
| 96 |
- int res = 0; |
|
| 96 |
+ int res = 0; |
|
| 97 | 97 |
|
| 98 | 98 |
if (cur_srcFormat != srcFormat || cur_srcW != srcW || cur_srcH != srcH) {
|
| 99 | 99 |
struct SwsContext *srcContext = NULL; |
| ... | ... |
@@ -106,11 +105,10 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h, |
| 106 | 106 |
for (p = 0; p < 4; p++) {
|
| 107 | 107 |
srcStride[p] = FFALIGN(srcStride[p], 16); |
| 108 | 108 |
if (srcStride[p]) |
| 109 |
- src[p] = av_mallocz(srcStride[p]*srcH+16); |
|
| 109 |
+ src[p] = av_mallocz(srcStride[p] * srcH + 16); |
|
| 110 | 110 |
if (srcStride[p] && !src[p]) {
|
| 111 | 111 |
perror("Malloc");
|
| 112 | 112 |
res = -1; |
| 113 |
- |
|
| 114 | 113 |
goto end; |
| 115 | 114 |
} |
| 116 | 115 |
} |
| ... | ... |
@@ -121,19 +119,18 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h, |
| 121 | 121 |
av_pix_fmt_descriptors[PIX_FMT_YUVA420P].name, |
| 122 | 122 |
av_pix_fmt_descriptors[srcFormat].name); |
| 123 | 123 |
res = -1; |
| 124 |
- |
|
| 125 | 124 |
goto end; |
| 126 | 125 |
} |
| 127 | 126 |
sws_scale(srcContext, ref, refStride, 0, h, src, srcStride); |
| 128 | 127 |
sws_freeContext(srcContext); |
| 129 | 128 |
|
| 130 | 129 |
cur_srcFormat = srcFormat; |
| 131 |
- cur_srcW = srcW; |
|
| 132 |
- cur_srcH = srcH; |
|
| 130 |
+ cur_srcW = srcW; |
|
| 131 |
+ cur_srcH = srcH; |
|
| 133 | 132 |
} |
| 134 | 133 |
|
| 135 | 134 |
av_image_fill_linesizes(dstStride, dstFormat, dstW); |
| 136 |
- for (i=0; i<4; i++) {
|
|
| 135 |
+ for (i = 0; i < 4; i++) {
|
|
| 137 | 136 |
/* Image buffers passed into libswscale can be allocated any way you |
| 138 | 137 |
* prefer, as long as they're aligned enough for the architecture, and |
| 139 | 138 |
* they're freed appropriately (such as using av_free for buffers |
| ... | ... |
@@ -142,7 +139,7 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h, |
| 142 | 142 |
* out of bounds. */ |
| 143 | 143 |
dstStride[i] = FFALIGN(dstStride[i], 16); |
| 144 | 144 |
if (dstStride[i]) |
| 145 |
- dst[i]= av_mallocz(dstStride[i]*dstH+16); |
|
| 145 |
+ dst[i] = av_mallocz(dstStride[i] * dstH + 16); |
|
| 146 | 146 |
if (dstStride[i] && !dst[i]) {
|
| 147 | 147 |
perror("Malloc");
|
| 148 | 148 |
res = -1; |
| ... | ... |
@@ -151,13 +148,13 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h, |
| 151 | 151 |
} |
| 152 | 152 |
} |
| 153 | 153 |
|
| 154 |
- dstContext= sws_getContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat, flags, NULL, NULL, NULL); |
|
| 154 |
+ dstContext = sws_getContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat, |
|
| 155 |
+ flags, NULL, NULL, NULL); |
|
| 155 | 156 |
if (!dstContext) {
|
| 156 | 157 |
fprintf(stderr, "Failed to get %s ---> %s\n", |
| 157 | 158 |
av_pix_fmt_descriptors[srcFormat].name, |
| 158 | 159 |
av_pix_fmt_descriptors[dstFormat].name); |
| 159 | 160 |
res = -1; |
| 160 |
- |
|
| 161 | 161 |
goto end; |
| 162 | 162 |
} |
| 163 | 163 |
|
| ... | ... |
@@ -169,9 +166,9 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h, |
| 169 | 169 |
|
| 170 | 170 |
sws_scale(dstContext, src, srcStride, 0, srcH, dst, dstStride); |
| 171 | 171 |
|
| 172 |
- for (i = 0; i < 4 && dstStride[i]; i++) {
|
|
| 173 |
- crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), crc, dst[i], dstStride[i] * dstH); |
|
| 174 |
- } |
|
| 172 |
+ for (i = 0; i < 4 && dstStride[i]; i++) |
|
| 173 |
+ crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), crc, dst[i], |
|
| 174 |
+ dstStride[i] * dstH); |
|
| 175 | 175 |
|
| 176 | 176 |
if (r && crc == r->crc) {
|
| 177 | 177 |
ssdY = r->ssdY; |
| ... | ... |
@@ -179,61 +176,60 @@ static int doTest(uint8_t *ref[4], int refStride[4], int w, int h, |
| 179 | 179 |
ssdV = r->ssdV; |
| 180 | 180 |
ssdA = r->ssdA; |
| 181 | 181 |
} else {
|
| 182 |
- for (i=0; i<4; i++) {
|
|
| 182 |
+ for (i = 0; i < 4; i++) {
|
|
| 183 | 183 |
refStride[i] = FFALIGN(refStride[i], 16); |
| 184 | 184 |
if (refStride[i]) |
| 185 |
- out[i]= av_mallocz(refStride[i]*h); |
|
| 185 |
+ out[i] = av_mallocz(refStride[i] * h); |
|
| 186 | 186 |
if (refStride[i] && !out[i]) {
|
| 187 | 187 |
perror("Malloc");
|
| 188 | 188 |
res = -1; |
| 189 |
- |
|
| 190 | 189 |
goto end; |
| 191 | 190 |
} |
| 192 | 191 |
} |
| 193 |
- outContext= sws_getContext(dstW, dstH, dstFormat, w, h, PIX_FMT_YUVA420P, SWS_BILINEAR, NULL, NULL, NULL); |
|
| 192 |
+ outContext = sws_getContext(dstW, dstH, dstFormat, w, h, |
|
| 193 |
+ PIX_FMT_YUVA420P, SWS_BILINEAR, |
|
| 194 |
+ NULL, NULL, NULL); |
|
| 194 | 195 |
if (!outContext) {
|
| 195 | 196 |
fprintf(stderr, "Failed to get %s ---> %s\n", |
| 196 | 197 |
av_pix_fmt_descriptors[dstFormat].name, |
| 197 | 198 |
av_pix_fmt_descriptors[PIX_FMT_YUVA420P].name); |
| 198 | 199 |
res = -1; |
| 199 |
- |
|
| 200 | 200 |
goto end; |
| 201 | 201 |
} |
| 202 | 202 |
sws_scale(outContext, dst, dstStride, 0, dstH, out, refStride); |
| 203 | 203 |
|
| 204 |
- ssdY= getSSD(ref[0], out[0], refStride[0], refStride[0], w, h); |
|
| 204 |
+ ssdY = getSSD(ref[0], out[0], refStride[0], refStride[0], w, h); |
|
| 205 | 205 |
if (hasChroma(srcFormat) && hasChroma(dstFormat)) {
|
| 206 | 206 |
//FIXME check that output is really gray |
| 207 |
- ssdU= getSSD(ref[1], out[1], refStride[1], refStride[1], (w+1)>>1, (h+1)>>1); |
|
| 208 |
- ssdV= getSSD(ref[2], out[2], refStride[2], refStride[2], (w+1)>>1, (h+1)>>1); |
|
| 207 |
+ ssdU = getSSD(ref[1], out[1], refStride[1], refStride[1], |
|
| 208 |
+ (w + 1) >> 1, (h + 1) >> 1); |
|
| 209 |
+ ssdV = getSSD(ref[2], out[2], refStride[2], refStride[2], |
|
| 210 |
+ (w + 1) >> 1, (h + 1) >> 1); |
|
| 209 | 211 |
} |
| 210 | 212 |
if (isALPHA(srcFormat) && isALPHA(dstFormat)) |
| 211 |
- ssdA= getSSD(ref[3], out[3], refStride[3], refStride[3], w, h); |
|
| 213 |
+ ssdA = getSSD(ref[3], out[3], refStride[3], refStride[3], w, h); |
|
| 212 | 214 |
|
| 213 |
- ssdY/= w*h; |
|
| 214 |
- ssdU/= w*h/4; |
|
| 215 |
- ssdV/= w*h/4; |
|
| 216 |
- ssdA/= w*h; |
|
| 215 |
+ ssdY /= w * h; |
|
| 216 |
+ ssdU /= w * h / 4; |
|
| 217 |
+ ssdV /= w * h / 4; |
|
| 218 |
+ ssdA /= w * h; |
|
| 217 | 219 |
|
| 218 | 220 |
sws_freeContext(outContext); |
| 219 | 221 |
|
| 220 |
- for (i=0; i<4; i++) {
|
|
| 222 |
+ for (i = 0; i < 4; i++) |
|
| 221 | 223 |
if (refStride[i]) |
| 222 | 224 |
av_free(out[i]); |
| 223 |
- } |
|
| 224 | 225 |
} |
| 225 | 226 |
|
| 226 |
- printf(" CRC=%08x SSD=%5"PRId64",%5"PRId64",%5"PRId64",%5"PRId64"\n",
|
|
| 227 |
+ printf(" CRC=%08x SSD=%5"PRId64 ",%5"PRId64 ",%5"PRId64 ",%5"PRId64 "\n",
|
|
| 227 | 228 |
crc, ssdY, ssdU, ssdV, ssdA); |
| 228 | 229 |
|
| 229 | 230 |
end: |
| 230 |
- |
|
| 231 | 231 |
sws_freeContext(dstContext); |
| 232 | 232 |
|
| 233 |
- for (i=0; i<4; i++) {
|
|
| 233 |
+ for (i = 0; i < 4; i++) |
|
| 234 | 234 |
if (dstStride[i]) |
| 235 | 235 |
av_free(dst[i]); |
| 236 |
- } |
|
| 237 | 236 |
|
| 238 | 237 |
return res; |
| 239 | 238 |
} |
| ... | ... |
@@ -242,18 +238,18 @@ static void selfTest(uint8_t *ref[4], int refStride[4], int w, int h, |
| 242 | 242 |
enum PixelFormat srcFormat_in, |
| 243 | 243 |
enum PixelFormat dstFormat_in) |
| 244 | 244 |
{
|
| 245 |
- const int flags[] = { SWS_FAST_BILINEAR,
|
|
| 246 |
- SWS_BILINEAR, SWS_BICUBIC, |
|
| 247 |
- SWS_X , SWS_POINT , SWS_AREA, 0 }; |
|
| 248 |
- const int srcW = w; |
|
| 249 |
- const int srcH = h; |
|
| 250 |
- const int dstW[] = { srcW - srcW/3, srcW, srcW + srcW/3, 0 };
|
|
| 251 |
- const int dstH[] = { srcH - srcH/3, srcH, srcH + srcH/3, 0 };
|
|
| 245 |
+ const int flags[] = { SWS_FAST_BILINEAR, SWS_BILINEAR, SWS_BICUBIC,
|
|
| 246 |
+ SWS_X, SWS_POINT, SWS_AREA, 0 }; |
|
| 247 |
+ const int srcW = w; |
|
| 248 |
+ const int srcH = h; |
|
| 249 |
+ const int dstW[] = { srcW - srcW / 3, srcW, srcW + srcW / 3, 0 };
|
|
| 250 |
+ const int dstH[] = { srcH - srcH / 3, srcH, srcH + srcH / 3, 0 };
|
|
| 252 | 251 |
enum PixelFormat srcFormat, dstFormat; |
| 253 | 252 |
|
| 254 | 253 |
for (srcFormat = srcFormat_in != PIX_FMT_NONE ? srcFormat_in : 0; |
| 255 | 254 |
srcFormat < PIX_FMT_NB; srcFormat++) {
|
| 256 |
- if (!sws_isSupportedInput(srcFormat) || !sws_isSupportedOutput(srcFormat)) |
|
| 255 |
+ if (!sws_isSupportedInput(srcFormat) || |
|
| 256 |
+ !sws_isSupportedOutput(srcFormat)) |
|
| 257 | 257 |
continue; |
| 258 | 258 |
|
| 259 | 259 |
for (dstFormat = dstFormat_in != PIX_FMT_NONE ? dstFormat_in : 0; |
| ... | ... |
@@ -261,7 +257,8 @@ static void selfTest(uint8_t *ref[4], int refStride[4], int w, int h, |
| 261 | 261 |
int i, j, k; |
| 262 | 262 |
int res = 0; |
| 263 | 263 |
|
| 264 |
- if (!sws_isSupportedInput(dstFormat) || !sws_isSupportedOutput(dstFormat)) |
|
| 264 |
+ if (!sws_isSupportedInput(dstFormat) || |
|
| 265 |
+ !sws_isSupportedOutput(dstFormat)) |
|
| 265 | 266 |
continue; |
| 266 | 267 |
|
| 267 | 268 |
printf("%s -> %s\n",
|
| ... | ... |
@@ -269,14 +266,13 @@ static void selfTest(uint8_t *ref[4], int refStride[4], int w, int h, |
| 269 | 269 |
av_pix_fmt_descriptors[dstFormat].name); |
| 270 | 270 |
fflush(stdout); |
| 271 | 271 |
|
| 272 |
- for (k = 0; flags[k] && !res; k++) {
|
|
| 272 |
+ for (k = 0; flags[k] && !res; k++) |
|
| 273 | 273 |
for (i = 0; dstW[i] && !res; i++) |
| 274 | 274 |
for (j = 0; dstH[j] && !res; j++) |
| 275 | 275 |
res = doTest(ref, refStride, w, h, |
| 276 | 276 |
srcFormat, dstFormat, |
| 277 | 277 |
srcW, srcH, dstW[i], dstH[j], flags[k], |
| 278 | 278 |
NULL); |
| 279 |
- } |
|
| 280 | 279 |
if (dstFormat_in != PIX_FMT_NONE) |
| 281 | 280 |
break; |
| 282 | 281 |
} |
| ... | ... |
@@ -302,13 +298,14 @@ static int fileTest(uint8_t *ref[4], int refStride[4], int w, int h, FILE *fp, |
| 302 | 302 |
int flags; |
| 303 | 303 |
int ret; |
| 304 | 304 |
|
| 305 |
- ret = sscanf(buf, " %12s %dx%d -> %12s %dx%d flags=%d CRC=%x" |
|
| 306 |
- " SSD=%"PRId64", %"PRId64", %"PRId64", %"PRId64"\n", |
|
| 307 |
- srcStr, &srcW, &srcH, dstStr, &dstW, &dstH, |
|
| 308 |
- &flags, &r.crc, &r.ssdY, &r.ssdU, &r.ssdV, &r.ssdA); |
|
| 305 |
+ ret = sscanf(buf, |
|
| 306 |
+ " %12s %dx%d -> %12s %dx%d flags=%d CRC=%x" |
|
| 307 |
+ " SSD=%"PRId64 ", %"PRId64 ", %"PRId64 ", %"PRId64 "\n", |
|
| 308 |
+ srcStr, &srcW, &srcH, dstStr, &dstW, &dstH, |
|
| 309 |
+ &flags, &r.crc, &r.ssdY, &r.ssdU, &r.ssdV, &r.ssdA); |
|
| 309 | 310 |
if (ret != 12) {
|
| 310 | 311 |
srcStr[0] = dstStr[0] = 0; |
| 311 |
- ret = sscanf(buf, "%12s -> %12s\n", srcStr, dstStr); |
|
| 312 |
+ ret = sscanf(buf, "%12s -> %12s\n", srcStr, dstStr); |
|
| 312 | 313 |
} |
| 313 | 314 |
|
| 314 | 315 |
srcFormat = av_get_pix_fmt(srcStr); |
| ... | ... |
@@ -342,12 +339,12 @@ int main(int argc, char **argv) |
| 342 | 342 |
{
|
| 343 | 343 |
enum PixelFormat srcFormat = PIX_FMT_NONE; |
| 344 | 344 |
enum PixelFormat dstFormat = PIX_FMT_NONE; |
| 345 |
- uint8_t *rgb_data = av_malloc (W*H*4); |
|
| 346 |
- uint8_t *rgb_src[3]= {rgb_data, NULL, NULL};
|
|
| 347 |
- int rgb_stride[3]={4*W, 0, 0};
|
|
| 348 |
- uint8_t *data = av_malloc (4*W*H); |
|
| 349 |
- uint8_t *src[4]= {data, data+W*H, data+W*H*2, data+W*H*3};
|
|
| 350 |
- int stride[4]={W, W, W, W};
|
|
| 345 |
+ uint8_t *rgb_data = av_malloc(W * H * 4); |
|
| 346 |
+ uint8_t *rgb_src[3] = { rgb_data, NULL, NULL };
|
|
| 347 |
+ int rgb_stride[3] = { 4 * W, 0, 0 };
|
|
| 348 |
+ uint8_t *data = av_malloc(4 * W * H); |
|
| 349 |
+ uint8_t *src[4] = { data, data + W * H, data + W * H * 2, data + W * H * 3 };
|
|
| 350 |
+ int stride[4] = { W, W, W, W };
|
|
| 351 | 351 |
int x, y; |
| 352 | 352 |
struct SwsContext *sws; |
| 353 | 353 |
AVLFG rand; |
| ... | ... |
@@ -357,41 +354,40 @@ int main(int argc, char **argv) |
| 357 | 357 |
if (!rgb_data || !data) |
| 358 | 358 |
return -1; |
| 359 | 359 |
|
| 360 |
- sws= sws_getContext(W/12, H/12, PIX_FMT_RGB32, W, H, PIX_FMT_YUVA420P, SWS_BILINEAR, NULL, NULL, NULL); |
|
| 360 |
+ sws = sws_getContext(W / 12, H / 12, PIX_FMT_RGB32, W, H, |
|
| 361 |
+ PIX_FMT_YUVA420P, SWS_BILINEAR, NULL, NULL, NULL); |
|
| 361 | 362 |
|
| 362 | 363 |
av_lfg_init(&rand, 1); |
| 363 | 364 |
|
| 364 |
- for (y=0; y<H; y++) {
|
|
| 365 |
- for (x=0; x<W*4; x++) {
|
|
| 366 |
- rgb_data[ x + y*4*W]= av_lfg_get(&rand); |
|
| 367 |
- } |
|
| 368 |
- } |
|
| 365 |
+ for (y = 0; y < H; y++) |
|
| 366 |
+ for (x = 0; x < W * 4; x++) |
|
| 367 |
+ rgb_data[ x + y * 4 * W] = av_lfg_get(&rand); |
|
| 369 | 368 |
sws_scale(sws, rgb_src, rgb_stride, 0, H, src, stride); |
| 370 | 369 |
sws_freeContext(sws); |
| 371 | 370 |
av_free(rgb_data); |
| 372 | 371 |
|
| 373 | 372 |
for (i = 1; i < argc; i += 2) {
|
| 374 |
- if (argv[i][0] != '-' || i+1 == argc) |
|
| 373 |
+ if (argv[i][0] != '-' || i + 1 == argc) |
|
| 375 | 374 |
goto bad_option; |
| 376 | 375 |
if (!strcmp(argv[i], "-ref")) {
|
| 377 |
- FILE *fp = fopen(argv[i+1], "r"); |
|
| 376 |
+ FILE *fp = fopen(argv[i + 1], "r"); |
|
| 378 | 377 |
if (!fp) {
|
| 379 |
- fprintf(stderr, "could not open '%s'\n", argv[i+1]); |
|
| 378 |
+ fprintf(stderr, "could not open '%s'\n", argv[i + 1]); |
|
| 380 | 379 |
goto error; |
| 381 | 380 |
} |
| 382 | 381 |
res = fileTest(src, stride, W, H, fp, srcFormat, dstFormat); |
| 383 | 382 |
fclose(fp); |
| 384 | 383 |
goto end; |
| 385 | 384 |
} else if (!strcmp(argv[i], "-src")) {
|
| 386 |
- srcFormat = av_get_pix_fmt(argv[i+1]); |
|
| 385 |
+ srcFormat = av_get_pix_fmt(argv[i + 1]); |
|
| 387 | 386 |
if (srcFormat == PIX_FMT_NONE) {
|
| 388 |
- fprintf(stderr, "invalid pixel format %s\n", argv[i+1]); |
|
| 387 |
+ fprintf(stderr, "invalid pixel format %s\n", argv[i + 1]); |
|
| 389 | 388 |
return -1; |
| 390 | 389 |
} |
| 391 | 390 |
} else if (!strcmp(argv[i], "-dst")) {
|
| 392 |
- dstFormat = av_get_pix_fmt(argv[i+1]); |
|
| 391 |
+ dstFormat = av_get_pix_fmt(argv[i + 1]); |
|
| 393 | 392 |
if (dstFormat == PIX_FMT_NONE) {
|
| 394 |
- fprintf(stderr, "invalid pixel format %s\n", argv[i+1]); |
|
| 393 |
+ fprintf(stderr, "invalid pixel format %s\n", argv[i + 1]); |
|
| 395 | 394 |
return -1; |
| 396 | 395 |
} |
| 397 | 396 |
} else {
|
| ... | ... |
@@ -1637,12 +1637,16 @@ rgb16_32_wrapper(PIX_FMT_RGB32, rgb32, 0, 0, 16, 0, 0x00FF, 0xFF00, 0xFF0 |
| 1637 | 1637 |
rgb16_32_wrapper(PIX_FMT_RGB32_1, rgb321, 0, 0, 16, 8, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT+8) |
| 1638 | 1638 |
rgb16_32_wrapper(PIX_FMT_BGR565LE, bgr16le, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT+8) |
| 1639 | 1639 |
rgb16_32_wrapper(PIX_FMT_BGR555LE, bgr15le, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT+7) |
| 1640 |
+rgb16_32_wrapper(PIX_FMT_BGR444LE, bgr12le, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT+4) |
|
| 1640 | 1641 |
rgb16_32_wrapper(PIX_FMT_RGB565LE, rgb16le, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT+8) |
| 1641 | 1642 |
rgb16_32_wrapper(PIX_FMT_RGB555LE, rgb15le, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT+7) |
| 1643 |
+rgb16_32_wrapper(PIX_FMT_RGB444LE, rgb12le, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT+4) |
|
| 1642 | 1644 |
rgb16_32_wrapper(PIX_FMT_BGR565BE, bgr16be, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT+8) |
| 1643 | 1645 |
rgb16_32_wrapper(PIX_FMT_BGR555BE, bgr15be, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT+7) |
| 1646 |
+rgb16_32_wrapper(PIX_FMT_BGR444BE, bgr12be, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT+4) |
|
| 1644 | 1647 |
rgb16_32_wrapper(PIX_FMT_RGB565BE, rgb16be, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT+8) |
| 1645 | 1648 |
rgb16_32_wrapper(PIX_FMT_RGB555BE, rgb15be, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT+7) |
| 1649 |
+rgb16_32_wrapper(PIX_FMT_RGB444BE, rgb12be, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT+4) |
|
| 1646 | 1650 |
|
| 1647 | 1651 |
static void gbr24pToUV_half_c(uint16_t *dstU, uint16_t *dstV, |
| 1648 | 1652 |
const uint8_t *gsrc, const uint8_t *bsrc, const uint8_t *rsrc, |
| ... | ... |
@@ -2887,6 +2891,8 @@ static av_cold void sws_init_swScale_c(SwsContext *c) |
| 2887 | 2887 |
case PIX_FMT_BGR565BE: c->chrToYV12 = bgr16beToUV_half_c; break; |
| 2888 | 2888 |
case PIX_FMT_BGR555LE: c->chrToYV12 = bgr15leToUV_half_c; break; |
| 2889 | 2889 |
case PIX_FMT_BGR555BE: c->chrToYV12 = bgr15beToUV_half_c; break; |
| 2890 |
+ case PIX_FMT_BGR444LE: c->chrToYV12 = bgr12leToUV_half_c; break; |
|
| 2891 |
+ case PIX_FMT_BGR444BE: c->chrToYV12 = bgr12beToUV_half_c; break; |
|
| 2890 | 2892 |
case PIX_FMT_BGR32 : c->chrToYV12 = rgb32ToUV_half_c; break; |
| 2891 | 2893 |
case PIX_FMT_BGR32_1 : c->chrToYV12 = rgb321ToUV_half_c; break; |
| 2892 | 2894 |
case PIX_FMT_RGB24 : c->chrToYV12 = rgb24ToUV_half_c; break; |
| ... | ... |
@@ -2895,6 +2901,8 @@ static av_cold void sws_init_swScale_c(SwsContext *c) |
| 2895 | 2895 |
case PIX_FMT_RGB555LE: c->chrToYV12 = rgb15leToUV_half_c; break; |
| 2896 | 2896 |
case PIX_FMT_RGB555BE: c->chrToYV12 = rgb15beToUV_half_c; break; |
| 2897 | 2897 |
case PIX_FMT_GBR24P : c->chrToYV12 = gbr24pToUV_half_c; break; |
| 2898 |
+ case PIX_FMT_RGB444LE: c->chrToYV12 = rgb12leToUV_half_c; break; |
|
| 2899 |
+ case PIX_FMT_RGB444BE: c->chrToYV12 = rgb12beToUV_half_c; break; |
|
| 2898 | 2900 |
} |
| 2899 | 2901 |
} else {
|
| 2900 | 2902 |
switch(srcFormat) {
|
| ... | ... |
@@ -2909,6 +2917,8 @@ static av_cold void sws_init_swScale_c(SwsContext *c) |
| 2909 | 2909 |
case PIX_FMT_BGR565BE: c->chrToYV12 = bgr16beToUV_c; break; |
| 2910 | 2910 |
case PIX_FMT_BGR555LE: c->chrToYV12 = bgr15leToUV_c; break; |
| 2911 | 2911 |
case PIX_FMT_BGR555BE: c->chrToYV12 = bgr15beToUV_c; break; |
| 2912 |
+ case PIX_FMT_BGR444LE: c->chrToYV12 = bgr12leToUV_c; break; |
|
| 2913 |
+ case PIX_FMT_BGR444BE: c->chrToYV12 = bgr12beToUV_c; break; |
|
| 2912 | 2914 |
case PIX_FMT_BGR32 : c->chrToYV12 = rgb32ToUV_c; break; |
| 2913 | 2915 |
case PIX_FMT_BGR32_1 : c->chrToYV12 = rgb321ToUV_c; break; |
| 2914 | 2916 |
case PIX_FMT_RGB24 : c->chrToYV12 = rgb24ToUV_c; break; |
| ... | ... |
@@ -2916,6 +2926,8 @@ static av_cold void sws_init_swScale_c(SwsContext *c) |
| 2916 | 2916 |
case PIX_FMT_RGB565BE: c->chrToYV12 = rgb16beToUV_c; break; |
| 2917 | 2917 |
case PIX_FMT_RGB555LE: c->chrToYV12 = rgb15leToUV_c; break; |
| 2918 | 2918 |
case PIX_FMT_RGB555BE: c->chrToYV12 = rgb15beToUV_c; break; |
| 2919 |
+ case PIX_FMT_RGB444LE: c->chrToYV12 = rgb12leToUV_c; break; |
|
| 2920 |
+ case PIX_FMT_RGB444BE: c->chrToYV12 = rgb12beToUV_c; break; |
|
| 2919 | 2921 |
} |
| 2920 | 2922 |
} |
| 2921 | 2923 |
|
| ... | ... |
@@ -2960,11 +2972,15 @@ static av_cold void sws_init_swScale_c(SwsContext *c) |
| 2960 | 2960 |
case PIX_FMT_BGR565BE : c->lumToYV12 = bgr16beToY_c; break; |
| 2961 | 2961 |
case PIX_FMT_BGR555LE : c->lumToYV12 = bgr15leToY_c; break; |
| 2962 | 2962 |
case PIX_FMT_BGR555BE : c->lumToYV12 = bgr15beToY_c; break; |
| 2963 |
+ case PIX_FMT_BGR444LE : c->lumToYV12 = bgr12leToY_c; break; |
|
| 2964 |
+ case PIX_FMT_BGR444BE : c->lumToYV12 = bgr12beToY_c; break; |
|
| 2963 | 2965 |
case PIX_FMT_RGB24 : c->lumToYV12 = rgb24ToY_c; break; |
| 2964 | 2966 |
case PIX_FMT_RGB565LE : c->lumToYV12 = rgb16leToY_c; break; |
| 2965 | 2967 |
case PIX_FMT_RGB565BE : c->lumToYV12 = rgb16beToY_c; break; |
| 2966 | 2968 |
case PIX_FMT_RGB555LE : c->lumToYV12 = rgb15leToY_c; break; |
| 2967 | 2969 |
case PIX_FMT_RGB555BE : c->lumToYV12 = rgb15beToY_c; break; |
| 2970 |
+ case PIX_FMT_RGB444LE : c->lumToYV12 = rgb12leToY_c; break; |
|
| 2971 |
+ case PIX_FMT_RGB444BE : c->lumToYV12 = rgb12beToY_c; break; |
|
| 2968 | 2972 |
case PIX_FMT_RGB8 : |
| 2969 | 2973 |
case PIX_FMT_BGR8 : |
| 2970 | 2974 |
case PIX_FMT_PAL8 : |
| ... | ... |
@@ -135,7 +135,6 @@ const char *swscale_license(void); |
| 135 | 135 |
*/ |
| 136 | 136 |
const int *sws_getCoefficients(int colorspace); |
| 137 | 137 |
|
| 138 |
- |
|
| 139 | 138 |
// when used for filters they must have an odd number of elements |
| 140 | 139 |
// coeffs cannot be shared between vectors |
| 141 | 140 |
typedef struct {
|
| ... | ... |
@@ -235,9 +234,9 @@ struct SwsContext *sws_getContext(int srcW, int srcH, enum PixelFormat srcFormat |
| 235 | 235 |
* the destination image |
| 236 | 236 |
* @return the height of the output slice |
| 237 | 237 |
*/ |
| 238 |
-int sws_scale(struct SwsContext *c, const uint8_t* const srcSlice[], |
|
| 238 |
+int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[], |
|
| 239 | 239 |
const int srcStride[], int srcSliceY, int srcSliceH, |
| 240 |
- uint8_t* const dst[], const int dstStride[]); |
|
| 240 |
+ uint8_t *const dst[], const int dstStride[]); |
|
| 241 | 241 |
|
| 242 | 242 |
/** |
| 243 | 243 |
* @param inv_table the yuv2rgb coefficients, normally ff_yuv2rgb_coeffs[x] |
| ... | ... |
@@ -32,9 +32,9 @@ |
| 32 | 32 |
#include "libavutil/pixfmt.h" |
| 33 | 33 |
#include "libavutil/pixdesc.h" |
| 34 | 34 |
|
| 35 |
-#define STR(s) AV_TOSTRING(s) //AV_STRINGIFY is too long |
|
| 35 |
+#define STR(s) AV_TOSTRING(s) // AV_STRINGIFY is too long |
|
| 36 | 36 |
|
| 37 |
-#define FAST_BGR2YV12 //use 7-bit instead of 15-bit coefficients |
|
| 37 |
+#define FAST_BGR2YV12 // use 7-bit instead of 15-bit coefficients |
|
| 38 | 38 |
|
| 39 | 39 |
#define MAX_FILTER_SIZE 256 |
| 40 | 40 |
|
| ... | ... |
@@ -47,21 +47,20 @@ |
| 47 | 47 |
#endif |
| 48 | 48 |
|
| 49 | 49 |
#if ARCH_X86_64 |
| 50 |
-# define APCK_PTR2 8 |
|
| 50 |
+# define APCK_PTR2 8 |
|
| 51 | 51 |
# define APCK_COEF 16 |
| 52 | 52 |
# define APCK_SIZE 24 |
| 53 | 53 |
#else |
| 54 |
-# define APCK_PTR2 4 |
|
| 55 |
-# define APCK_COEF 8 |
|
| 54 |
+# define APCK_PTR2 4 |
|
| 55 |
+# define APCK_COEF 8 |
|
| 56 | 56 |
# define APCK_SIZE 16 |
| 57 | 57 |
#endif |
| 58 | 58 |
|
| 59 | 59 |
struct SwsContext; |
| 60 | 60 |
|
| 61 |
-typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t* src[], |
|
| 61 |
+typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t *src[], |
|
| 62 | 62 |
int srcStride[], int srcSliceY, int srcSliceH, |
| 63 |
- uint8_t* dst[], int dstStride[]); |
|
| 64 |
- |
|
| 63 |
+ uint8_t *dst[], int dstStride[]); |
|
| 65 | 64 |
|
| 66 | 65 |
/** |
| 67 | 66 |
* Write one line of horizontally scaled data to planar output |
| ... | ... |
@@ -75,8 +74,8 @@ typedef int (*SwsFunc)(struct SwsContext *context, const uint8_t* src[], |
| 75 | 75 |
* @param dither ordered dither array of type int16_t and size 8 |
| 76 | 76 |
* @param offset Dither offset |
| 77 | 77 |
*/ |
| 78 |
-typedef void (*yuv2planar1_fn) (const int16_t *src, uint8_t *dest, int dstW, |
|
| 79 |
- const uint8_t *dither, int offset); |
|
| 78 |
+typedef void (*yuv2planar1_fn)(const int16_t *src, uint8_t *dest, int dstW, |
|
| 79 |
+ const uint8_t *dither, int offset); |
|
| 80 | 80 |
|
| 81 | 81 |
/** |
| 82 | 82 |
* Write one line of horizontally scaled data to planar output |
| ... | ... |
@@ -91,9 +90,9 @@ typedef void (*yuv2planar1_fn) (const int16_t *src, uint8_t *dest, int dstW, |
| 91 | 91 |
* @param dstW width of destination pixels |
| 92 | 92 |
* @param offset Dither offset |
| 93 | 93 |
*/ |
| 94 |
-typedef void (*yuv2planarX_fn) (const int16_t *filter, int filterSize, |
|
| 95 |
- const int16_t **src, uint8_t *dest, int dstW, |
|
| 96 |
- const uint8_t *dither, int offset); |
|
| 94 |
+typedef void (*yuv2planarX_fn)(const int16_t *filter, int filterSize, |
|
| 95 |
+ const int16_t **src, uint8_t *dest, int dstW, |
|
| 96 |
+ const uint8_t *dither, int offset); |
|
| 97 | 97 |
|
| 98 | 98 |
/** |
| 99 | 99 |
* Write one line of horizontally scaled chroma to interleaved output |
| ... | ... |
@@ -110,9 +109,12 @@ typedef void (*yuv2planarX_fn) (const int16_t *filter, int filterSize, |
| 110 | 110 |
* output, this is in uint16_t |
| 111 | 111 |
* @param dstW width of chroma planes |
| 112 | 112 |
*/ |
| 113 |
-typedef void (*yuv2interleavedX_fn) (struct SwsContext *c, const int16_t *chrFilter, int chrFilterSize, |
|
| 114 |
- const int16_t **chrUSrc, const int16_t **chrVSrc, |
|
| 115 |
- uint8_t *dest, int dstW); |
|
| 113 |
+typedef void (*yuv2interleavedX_fn)(struct SwsContext *c, |
|
| 114 |
+ const int16_t *chrFilter, |
|
| 115 |
+ int chrFilterSize, |
|
| 116 |
+ const int16_t **chrUSrc, |
|
| 117 |
+ const int16_t **chrVSrc, |
|
| 118 |
+ uint8_t *dest, int dstW); |
|
| 116 | 119 |
|
| 117 | 120 |
/** |
| 118 | 121 |
* Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB |
| ... | ... |
@@ -143,10 +145,11 @@ typedef void (*yuv2interleavedX_fn) (struct SwsContext *c, const int16_t *chrFil |
| 143 | 143 |
* but can be used to generate comfort noise using dithering |
| 144 | 144 |
* for some output formats. |
| 145 | 145 |
*/ |
| 146 |
-typedef void (*yuv2packed1_fn) (struct SwsContext *c, const int16_t *lumSrc, |
|
| 147 |
- const int16_t *chrUSrc[2], const int16_t *chrVSrc[2], |
|
| 148 |
- const int16_t *alpSrc, uint8_t *dest, |
|
| 149 |
- int dstW, int uvalpha, int y); |
|
| 146 |
+typedef void (*yuv2packed1_fn)(struct SwsContext *c, const int16_t *lumSrc, |
|
| 147 |
+ const int16_t *chrUSrc[2], |
|
| 148 |
+ const int16_t *chrVSrc[2], |
|
| 149 |
+ const int16_t *alpSrc, uint8_t *dest, |
|
| 150 |
+ int dstW, int uvalpha, int y); |
|
| 150 | 151 |
/** |
| 151 | 152 |
* Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB |
| 152 | 153 |
* output by doing bilinear scaling between two input lines. |
| ... | ... |
@@ -175,10 +178,12 @@ typedef void (*yuv2packed1_fn) (struct SwsContext *c, const int16_t *lumSrc, |
| 175 | 175 |
* but can be used to generate comfort noise using dithering |
| 176 | 176 |
* for some output formats. |
| 177 | 177 |
*/ |
| 178 |
-typedef void (*yuv2packed2_fn) (struct SwsContext *c, const int16_t *lumSrc[2], |
|
| 179 |
- const int16_t *chrUSrc[2], const int16_t *chrVSrc[2], |
|
| 180 |
- const int16_t *alpSrc[2], uint8_t *dest, |
|
| 181 |
- int dstW, int yalpha, int uvalpha, int y); |
|
| 178 |
+typedef void (*yuv2packed2_fn)(struct SwsContext *c, const int16_t *lumSrc[2], |
|
| 179 |
+ const int16_t *chrUSrc[2], |
|
| 180 |
+ const int16_t *chrVSrc[2], |
|
| 181 |
+ const int16_t *alpSrc[2], |
|
| 182 |
+ uint8_t *dest, |
|
| 183 |
+ int dstW, int yalpha, int uvalpha, int y); |
|
| 182 | 184 |
/** |
| 183 | 185 |
* Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB |
| 184 | 186 |
* output by doing multi-point vertical scaling between input pixels. |
| ... | ... |
@@ -205,12 +210,13 @@ typedef void (*yuv2packed2_fn) (struct SwsContext *c, const int16_t *lumSrc[2], |
| 205 | 205 |
* but can be used to generate comfort noise using dithering |
| 206 | 206 |
* or some output formats. |
| 207 | 207 |
*/ |
| 208 |
-typedef void (*yuv2packedX_fn) (struct SwsContext *c, const int16_t *lumFilter, |
|
| 209 |
- const int16_t **lumSrc, int lumFilterSize, |
|
| 210 |
- const int16_t *chrFilter, const int16_t **chrUSrc, |
|
| 211 |
- const int16_t **chrVSrc, int chrFilterSize, |
|
| 212 |
- const int16_t **alpSrc, uint8_t *dest, |
|
| 213 |
- int dstW, int y); |
|
| 208 |
+typedef void (*yuv2packedX_fn)(struct SwsContext *c, const int16_t *lumFilter, |
|
| 209 |
+ const int16_t **lumSrc, int lumFilterSize, |
|
| 210 |
+ const int16_t *chrFilter, |
|
| 211 |
+ const int16_t **chrUSrc, |
|
| 212 |
+ const int16_t **chrVSrc, int chrFilterSize, |
|
| 213 |
+ const int16_t **alpSrc, uint8_t *dest, |
|
| 214 |
+ int dstW, int y); |
|
| 214 | 215 |
|
| 215 | 216 |
/* This struct should be aligned on at least a 32-byte boundary. */ |
| 216 | 217 |
typedef struct SwsContext {
|
| ... | ... |
@@ -263,12 +269,12 @@ typedef struct SwsContext {
|
| 263 | 263 |
int16_t **chrUPixBuf; ///< Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler. |
| 264 | 264 |
int16_t **chrVPixBuf; ///< Ring buffer for scaled horizontal chroma plane lines to be fed to the vertical scaler. |
| 265 | 265 |
int16_t **alpPixBuf; ///< Ring buffer for scaled horizontal alpha plane lines to be fed to the vertical scaler. |
| 266 |
- int vLumBufSize; ///< Number of vertical luma/alpha lines allocated in the ring buffer. |
|
| 267 |
- int vChrBufSize; ///< Number of vertical chroma lines allocated in the ring buffer. |
|
| 268 |
- int lastInLumBuf; ///< Last scaled horizontal luma/alpha line from source in the ring buffer. |
|
| 269 |
- int lastInChrBuf; ///< Last scaled horizontal chroma line from source in the ring buffer. |
|
| 270 |
- int lumBufIndex; ///< Index in ring buffer of the last scaled horizontal luma/alpha line from source. |
|
| 271 |
- int chrBufIndex; ///< Index in ring buffer of the last scaled horizontal chroma line from source. |
|
| 266 |
+ int vLumBufSize; ///< Number of vertical luma/alpha lines allocated in the ring buffer. |
|
| 267 |
+ int vChrBufSize; ///< Number of vertical chroma lines allocated in the ring buffer. |
|
| 268 |
+ int lastInLumBuf; ///< Last scaled horizontal luma/alpha line from source in the ring buffer. |
|
| 269 |
+ int lastInChrBuf; ///< Last scaled horizontal chroma line from source in the ring buffer. |
|
| 270 |
+ int lumBufIndex; ///< Index in ring buffer of the last scaled horizontal luma/alpha line from source. |
|
| 271 |
+ int chrBufIndex; ///< Index in ring buffer of the last scaled horizontal chroma line from source. |
|
| 272 | 272 |
//@} |
| 273 | 273 |
|
| 274 | 274 |
uint8_t *formatConvBuffer; |
| ... | ... |
@@ -295,10 +301,10 @@ typedef struct SwsContext {
|
| 295 | 295 |
int16_t *hChrFilterPos; ///< Array of horizontal filter starting positions for each dst[i] for chroma planes. |
| 296 | 296 |
int16_t *vLumFilterPos; ///< Array of vertical filter starting positions for each dst[i] for luma/alpha planes. |
| 297 | 297 |
int16_t *vChrFilterPos; ///< Array of vertical filter starting positions for each dst[i] for chroma planes. |
| 298 |
- int hLumFilterSize; ///< Horizontal filter size for luma/alpha pixels. |
|
| 299 |
- int hChrFilterSize; ///< Horizontal filter size for chroma pixels. |
|
| 300 |
- int vLumFilterSize; ///< Vertical filter size for luma/alpha pixels. |
|
| 301 |
- int vChrFilterSize; ///< Vertical filter size for chroma pixels. |
|
| 298 |
+ int hLumFilterSize; ///< Horizontal filter size for luma/alpha pixels. |
|
| 299 |
+ int hChrFilterSize; ///< Horizontal filter size for chroma pixels. |
|
| 300 |
+ int vLumFilterSize; ///< Vertical filter size for luma/alpha pixels. |
|
| 301 |
+ int vChrFilterSize; ///< Vertical filter size for chroma pixels. |
|
| 302 | 302 |
//@} |
| 303 | 303 |
|
| 304 | 304 |
int lumMmx2FilterCodeSize; ///< Runtime-generated MMX2 horizontal fast bilinear scaler code size for luma/alpha planes. |
| ... | ... |
@@ -310,11 +316,11 @@ typedef struct SwsContext {
|
| 310 | 310 |
|
| 311 | 311 |
int dstY; ///< Last destination vertical line output from last slice. |
| 312 | 312 |
int flags; ///< Flags passed by the user to select scaler algorithm, optimizations, subsampling, etc... |
| 313 |
- void * yuvTable; // pointer to the yuv->rgb table start so it can be freed() |
|
| 314 |
- uint8_t * table_rV[256]; |
|
| 315 |
- uint8_t * table_gU[256]; |
|
| 316 |
- int table_gV[256]; |
|
| 317 |
- uint8_t * table_bU[256]; |
|
| 313 |
+ void *yuvTable; // pointer to the yuv->rgb table start so it can be freed() |
|
| 314 |
+ uint8_t *table_rV[256]; |
|
| 315 |
+ uint8_t *table_gU[256]; |
|
| 316 |
+ int table_gV[256]; |
|
| 317 |
+ uint8_t *table_bU[256]; |
|
| 318 | 318 |
|
| 319 | 319 |
//Colorspace stuff |
| 320 | 320 |
int contrast, brightness, saturation; // for sws_getColorspaceDetails |
| ... | ... |
@@ -366,15 +372,15 @@ typedef struct SwsContext {
|
| 366 | 366 |
DECLARE_ALIGNED(8, uint64_t, yOffset); |
| 367 | 367 |
DECLARE_ALIGNED(8, uint64_t, uOffset); |
| 368 | 368 |
DECLARE_ALIGNED(8, uint64_t, vOffset); |
| 369 |
- int32_t lumMmxFilter[4*MAX_FILTER_SIZE]; |
|
| 370 |
- int32_t chrMmxFilter[4*MAX_FILTER_SIZE]; |
|
| 369 |
+ int32_t lumMmxFilter[4 * MAX_FILTER_SIZE]; |
|
| 370 |
+ int32_t chrMmxFilter[4 * MAX_FILTER_SIZE]; |
|
| 371 | 371 |
int dstW; ///< Width of destination luma/alpha planes. |
| 372 | 372 |
DECLARE_ALIGNED(8, uint64_t, esp); |
| 373 | 373 |
DECLARE_ALIGNED(8, uint64_t, vRounder); |
| 374 | 374 |
DECLARE_ALIGNED(8, uint64_t, u_temp); |
| 375 | 375 |
DECLARE_ALIGNED(8, uint64_t, v_temp); |
| 376 | 376 |
DECLARE_ALIGNED(8, uint64_t, y_temp); |
| 377 |
- int32_t alpMmxFilter[4*MAX_FILTER_SIZE]; |
|
| 377 |
+ int32_t alpMmxFilter[4 * MAX_FILTER_SIZE]; |
|
| 378 | 378 |
// alignment of these values is not necessary, but merely here |
| 379 | 379 |
// to maintain the same offset across x8632 and x86-64. Once we |
| 380 | 380 |
// use proper offset macros in the asm, they can be removed. |
| ... | ... |
@@ -393,7 +399,7 @@ typedef struct SwsContext {
|
| 393 | 393 |
vector signed short CGV; |
| 394 | 394 |
vector signed short OY; |
| 395 | 395 |
vector unsigned short CSHIFT; |
| 396 |
- vector signed short *vYCoeffsBank, *vCCoeffsBank; |
|
| 396 |
+ vector signed short *vYCoeffsBank, *vCCoeffsBank; |
|
| 397 | 397 |
#endif |
| 398 | 398 |
|
| 399 | 399 |
#if ARCH_BFIN |
| ... | ... |
@@ -423,21 +429,25 @@ typedef struct SwsContext {
|
| 423 | 423 |
yuv2packed2_fn yuv2packed2; |
| 424 | 424 |
yuv2packedX_fn yuv2packedX; |
| 425 | 425 |
|
| 426 |
+ /// Unscaled conversion of luma plane to YV12 for horizontal scaler. |
|
| 426 | 427 |
void (*lumToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3, |
| 427 |
- int width, uint32_t *pal); ///< Unscaled conversion of luma plane to YV12 for horizontal scaler. |
|
| 428 |
+ int width, uint32_t *pal); |
|
| 429 |
+ /// Unscaled conversion of alpha plane to YV12 for horizontal scaler. |
|
| 428 | 430 |
void (*alpToYV12)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3, |
| 429 |
- int width, uint32_t *pal); ///< Unscaled conversion of alpha plane to YV12 for horizontal scaler. |
|
| 431 |
+ int width, uint32_t *pal); |
|
| 432 |
+ /// Unscaled conversion of chroma planes to YV12 for horizontal scaler. |
|
| 430 | 433 |
void (*chrToYV12)(uint8_t *dstU, uint8_t *dstV, |
| 431 | 434 |
const uint8_t *src1, const uint8_t *src2, const uint8_t *src3, |
| 432 |
- int width, uint32_t *pal); ///< Unscaled conversion of chroma planes to YV12 for horizontal scaler. |
|
| 435 |
+ int width, uint32_t *pal); |
|
| 433 | 436 |
|
| 434 | 437 |
/** |
| 435 |
- * Functions to read planar input, such as planar RGB, and convert |
|
| 436 |
- * internally to Y/UV. |
|
| 437 |
- */ |
|
| 438 |
+ * Functions to read planar input, such as planar RGB, and convert |
|
| 439 |
+ * internally to Y/UV. |
|
| 440 |
+ */ |
|
| 438 | 441 |
/** @{ */
|
| 439 | 442 |
void (*readLumPlanar)(uint8_t *dst, const uint8_t *src[4], int width); |
| 440 |
- void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4], int width); |
|
| 443 |
+ void (*readChrPlanar)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4], |
|
| 444 |
+ int width); |
|
| 441 | 445 |
/** @} */ |
| 442 | 446 |
|
| 443 | 447 |
/** |
| ... | ... |
@@ -499,19 +509,20 @@ typedef struct SwsContext {
|
| 499 | 499 |
* to simplify creating SIMD code. |
| 500 | 500 |
*/ |
| 501 | 501 |
/** @{ */
|
| 502 |
- void (*hyScale)(struct SwsContext *c, int16_t *dst, int dstW, const uint8_t *src, |
|
| 503 |
- const int16_t *filter, const int16_t *filterPos, |
|
| 504 |
- int filterSize); |
|
| 505 |
- void (*hcScale)(struct SwsContext *c, int16_t *dst, int dstW, const uint8_t *src, |
|
| 506 |
- const int16_t *filter, const int16_t *filterPos, |
|
| 507 |
- int filterSize); |
|
| 502 |
+ void (*hyScale)(struct SwsContext *c, int16_t *dst, int dstW, |
|
| 503 |
+ const uint8_t *src, const int16_t *filter, |
|
| 504 |
+ const int16_t *filterPos, int filterSize); |
|
| 505 |
+ void (*hcScale)(struct SwsContext *c, int16_t *dst, int dstW, |
|
| 506 |
+ const uint8_t *src, const int16_t *filter, |
|
| 507 |
+ const int16_t *filterPos, int filterSize); |
|
| 508 | 508 |
/** @} */ |
| 509 | 509 |
|
| 510 |
- void (*lumConvertRange)(int16_t *dst, int width); ///< Color range conversion function for luma plane if needed. |
|
| 511 |
- void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width); ///< Color range conversion function for chroma planes if needed. |
|
| 510 |
+ /// Color range conversion function for luma plane if needed. |
|
| 511 |
+ void (*lumConvertRange)(int16_t *dst, int width); |
|
| 512 |
+ /// Color range conversion function for chroma planes if needed. |
|
| 513 |
+ void (*chrConvertRange)(int16_t *dst1, int16_t *dst2, int width); |
|
| 512 | 514 |
|
| 513 | 515 |
int needs_hcscale; ///< Set if there are chroma planes to be converted. |
| 514 |
- |
|
| 515 | 516 |
} SwsContext; |
| 516 | 517 |
//FIXME check init (where 0) |
| 517 | 518 |
|
| ... | ... |
@@ -567,53 +578,54 @@ const char *sws_format_name(enum PixelFormat format); |
| 567 | 567 |
(!(av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL) && \ |
| 568 | 568 |
av_pix_fmt_descriptors[x].nb_components <= 2) |
| 569 | 569 |
#else |
| 570 |
-#define isGray(x) ( \ |
|
| 571 |
- (x)==PIX_FMT_GRAY8 \ |
|
| 572 |
- || (x)==PIX_FMT_GRAY8A \ |
|
| 573 |
- || (x)==PIX_FMT_GRAY16BE \ |
|
| 574 |
- || (x)==PIX_FMT_GRAY16LE \ |
|
| 575 |
- ) |
|
| 570 |
+#define isGray(x) \ |
|
| 571 |
+ ((x) == PIX_FMT_GRAY8 || \ |
|
| 572 |
+ (x) == PIX_FMT_Y400A || \ |
|
| 573 |
+ (x) == PIX_FMT_GRAY16BE || \ |
|
| 574 |
+ (x) == PIX_FMT_GRAY16LE) |
|
| 576 | 575 |
#endif |
| 577 | 576 |
|
| 578 |
-#define isRGBinInt(x) ( \ |
|
| 579 |
- (x)==PIX_FMT_RGB48BE \ |
|
| 580 |
- || (x)==PIX_FMT_RGB48LE \ |
|
| 581 |
- || (x)==PIX_FMT_RGBA64BE \ |
|
| 582 |
- || (x)==PIX_FMT_RGBA64LE \ |
|
| 583 |
- || (x)==PIX_FMT_RGB32 \ |
|
| 584 |
- || (x)==PIX_FMT_RGB32_1 \ |
|
| 585 |
- || (x)==PIX_FMT_RGB24 \ |
|
| 586 |
- || (x)==PIX_FMT_RGB565BE \ |
|
| 587 |
- || (x)==PIX_FMT_RGB565LE \ |
|
| 588 |
- || (x)==PIX_FMT_RGB555BE \ |
|
| 589 |
- || (x)==PIX_FMT_RGB555LE \ |
|
| 590 |
- || (x)==PIX_FMT_RGB444BE \ |
|
| 591 |
- || (x)==PIX_FMT_RGB444LE \ |
|
| 592 |
- || (x)==PIX_FMT_RGB8 \ |
|
| 593 |
- || (x)==PIX_FMT_RGB4 \ |
|
| 594 |
- || (x)==PIX_FMT_RGB4_BYTE \ |
|
| 595 |
- || (x)==PIX_FMT_MONOBLACK \ |
|
| 596 |
- || (x)==PIX_FMT_MONOWHITE \ |
|
| 577 |
+#define isRGBinInt(x) \ |
|
| 578 |
+ ( \ |
|
| 579 |
+ (x)==PIX_FMT_RGB48BE || \ |
|
| 580 |
+ (x)==PIX_FMT_RGB48LE || \ |
|
| 581 |
+ (x)==PIX_FMT_RGBA64BE || \ |
|
| 582 |
+ (x)==PIX_FMT_RGBA64LE || \ |
|
| 583 |
+ (x)==PIX_FMT_RGB32 || \ |
|
| 584 |
+ (x)==PIX_FMT_RGB32_1 || \ |
|
| 585 |
+ (x)==PIX_FMT_RGB24 || \ |
|
| 586 |
+ (x)==PIX_FMT_RGB565BE || \ |
|
| 587 |
+ (x)==PIX_FMT_RGB565LE || \ |
|
| 588 |
+ (x)==PIX_FMT_RGB555BE || \ |
|
| 589 |
+ (x)==PIX_FMT_RGB555LE || \ |
|
| 590 |
+ (x)==PIX_FMT_RGB444BE || \ |
|
| 591 |
+ (x)==PIX_FMT_RGB444LE || \ |
|
| 592 |
+ (x)==PIX_FMT_RGB8 || \ |
|
| 593 |
+ (x)==PIX_FMT_RGB4 || \ |
|
| 594 |
+ (x)==PIX_FMT_RGB4_BYTE || \ |
|
| 595 |
+ (x)==PIX_FMT_MONOBLACK || \ |
|
| 596 |
+ (x)==PIX_FMT_MONOWHITE \ |
|
| 597 | 597 |
) |
| 598 |
-#define isBGRinInt(x) ( \ |
|
| 599 |
- (x)==PIX_FMT_BGR48BE \ |
|
| 600 |
- || (x)==PIX_FMT_BGR48LE \ |
|
| 601 |
- || (x)==PIX_FMT_BGRA64BE \ |
|
| 602 |
- || (x)==PIX_FMT_BGRA64LE \ |
|
| 603 |
- || (x)==PIX_FMT_BGR32 \ |
|
| 604 |
- || (x)==PIX_FMT_BGR32_1 \ |
|
| 605 |
- || (x)==PIX_FMT_BGR24 \ |
|
| 606 |
- || (x)==PIX_FMT_BGR565BE \ |
|
| 607 |
- || (x)==PIX_FMT_BGR565LE \ |
|
| 608 |
- || (x)==PIX_FMT_BGR555BE \ |
|
| 609 |
- || (x)==PIX_FMT_BGR555LE \ |
|
| 610 |
- || (x)==PIX_FMT_BGR444BE \ |
|
| 611 |
- || (x)==PIX_FMT_BGR444LE \ |
|
| 612 |
- || (x)==PIX_FMT_BGR8 \ |
|
| 613 |
- || (x)==PIX_FMT_BGR4 \ |
|
| 614 |
- || (x)==PIX_FMT_BGR4_BYTE \ |
|
| 615 |
- || (x)==PIX_FMT_MONOBLACK \ |
|
| 616 |
- || (x)==PIX_FMT_MONOWHITE \ |
|
| 598 |
+#define isBGRinInt(x) \ |
|
| 599 |
+ ( \ |
|
| 600 |
+ (x)==PIX_FMT_BGR48BE || \ |
|
| 601 |
+ (x)==PIX_FMT_BGR48LE || \ |
|
| 602 |
+ (x)==PIX_FMT_BGRA64BE || \ |
|
| 603 |
+ (x)==PIX_FMT_BGRA64LE || \ |
|
| 604 |
+ (x)==PIX_FMT_BGR32 || \ |
|
| 605 |
+ (x)==PIX_FMT_BGR32_1 || \ |
|
| 606 |
+ (x)==PIX_FMT_BGR24 || \ |
|
| 607 |
+ (x)==PIX_FMT_BGR565BE || \ |
|
| 608 |
+ (x)==PIX_FMT_BGR565LE || \ |
|
| 609 |
+ (x)==PIX_FMT_BGR555BE || \ |
|
| 610 |
+ (x)==PIX_FMT_BGR555LE || \ |
|
| 611 |
+ (x)==PIX_FMT_BGR444BE || \ |
|
| 612 |
+ (x)==PIX_FMT_BGR444LE || \ |
|
| 613 |
+ (x)==PIX_FMT_BGR8 || \ |
|
| 614 |
+ (x)==PIX_FMT_BGR4 || \ |
|
| 615 |
+ (x)==PIX_FMT_BGR4_BYTE|| \ |
|
| 616 |
+ (x)==PIX_FMT_MONOBLACK|| \ |
|
| 617 |
+ (x)==PIX_FMT_MONOWHITE \ |
|
| 617 | 618 |
) |
| 618 | 619 |
|
| 619 | 620 |
#define isRGBinBytes(x) ( \ |
| ... | ... |
@@ -635,10 +647,11 @@ const char *sws_format_name(enum PixelFormat format); |
| 635 | 635 |
|| (x)==PIX_FMT_BGR24 \ |
| 636 | 636 |
) |
| 637 | 637 |
|
| 638 |
-#define isAnyRGB(x) ( \ |
|
| 639 |
- isRGBinInt(x) \ |
|
| 640 |
- || isBGRinInt(x) \ |
|
| 641 |
- || (x)==PIX_FMT_GBR24P \ |
|
| 638 |
+#define isAnyRGB(x) \ |
|
| 639 |
+ ( \ |
|
| 640 |
+ isRGBinInt(x) || \ |
|
| 641 |
+ isBGRinInt(x) || \ |
|
| 642 |
+ (x)==PIX_FMT_GBR24P \ |
|
| 642 | 643 |
) |
| 643 | 644 |
|
| 644 | 645 |
#define isALPHA(x) \ |
| ... | ... |
@@ -655,15 +668,14 @@ const char *sws_format_name(enum PixelFormat format); |
| 655 | 655 |
|| isBGRinInt(x) \ |
| 656 | 656 |
) |
| 657 | 657 |
#else |
| 658 |
-#define isPacked(x) (\ |
|
| 659 |
- (av_pix_fmt_descriptors[x].nb_components >= 2 && \ |
|
| 660 |
- !(av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR)) || \ |
|
| 661 |
- (x) == PIX_FMT_PAL8\ |
|
| 662 |
- ) |
|
| 658 |
+#define isPacked(x) \ |
|
| 659 |
+ ((av_pix_fmt_descriptors[x].nb_components >= 2 && \ |
|
| 660 |
+ !(av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR)) || \ |
|
| 661 |
+ (x) == PIX_FMT_PAL8) |
|
| 663 | 662 |
|
| 664 | 663 |
#endif |
| 665 | 664 |
#define isPlanar(x) \ |
| 666 |
- (av_pix_fmt_descriptors[x].nb_components >= 2 && \ |
|
| 665 |
+ (av_pix_fmt_descriptors[x].nb_components >= 2 && \ |
|
| 667 | 666 |
(av_pix_fmt_descriptors[x].flags & PIX_FMT_PLANAR)) |
| 668 | 667 |
|
| 669 | 668 |
#define usePal(x) ((av_pix_fmt_descriptors[x].flags & PIX_FMT_PAL) || (x) == PIX_FMT_Y400A) |
| ... | ... |
@@ -129,10 +129,10 @@ const static FormatEntry format_entries[PIX_FMT_NB] = {
|
| 129 | 129 |
[PIX_FMT_YUV422P16BE] = { 1 , 1 },
|
| 130 | 130 |
[PIX_FMT_YUV444P16LE] = { 1 , 1 },
|
| 131 | 131 |
[PIX_FMT_YUV444P16BE] = { 1 , 1 },
|
| 132 |
- [PIX_FMT_RGB444LE] = { 0 , 1 },
|
|
| 133 |
- [PIX_FMT_RGB444BE] = { 0 , 1 },
|
|
| 134 |
- [PIX_FMT_BGR444LE] = { 0 , 1 },
|
|
| 135 |
- [PIX_FMT_BGR444BE] = { 0 , 1 },
|
|
| 132 |
+ [PIX_FMT_RGB444LE] = { 1 , 1 },
|
|
| 133 |
+ [PIX_FMT_RGB444BE] = { 1 , 1 },
|
|
| 134 |
+ [PIX_FMT_BGR444LE] = { 1 , 1 },
|
|
| 135 |
+ [PIX_FMT_BGR444BE] = { 1 , 1 },
|
|
| 136 | 136 |
[PIX_FMT_Y400A] = { 1 , 0 },
|
| 137 | 137 |
[PIX_FMT_BGR48BE] = { 1 , 1 },
|
| 138 | 138 |
[PIX_FMT_BGR48LE] = { 1 , 1 },
|
| 139 | 139 |
new file mode 100644 |
| ... | ... |
@@ -0,0 +1,242 @@ |
| 0 |
+;****************************************************************************** |
|
| 1 |
+;* x86-optimized input routines; does shuffling of packed |
|
| 2 |
+;* YUV formats into individual planes, and converts RGB |
|
| 3 |
+;* into YUV planes also. |
|
| 4 |
+;* Copyright (c) 2012 Ronald S. Bultje <rsbultje@gmail.com> |
|
| 5 |
+;* |
|
| 6 |
+;* This file is part of Libav. |
|
| 7 |
+;* |
|
| 8 |
+;* Libav is free software; you can redistribute it and/or |
|
| 9 |
+;* modify it under the terms of the GNU Lesser General Public |
|
| 10 |
+;* License as published by the Free Software Foundation; either |
|
| 11 |
+;* version 2.1 of the License, or (at your option) any later version. |
|
| 12 |
+;* |
|
| 13 |
+;* Libav is distributed in the hope that it will be useful, |
|
| 14 |
+;* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
| 15 |
+;* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
| 16 |
+;* Lesser General Public License for more details. |
|
| 17 |
+;* |
|
| 18 |
+;* You should have received a copy of the GNU Lesser General Public |
|
| 19 |
+;* License along with Libav; if not, write to the Free Software |
|
| 20 |
+;* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
|
| 21 |
+;****************************************************************************** |
|
| 22 |
+ |
|
| 23 |
+%include "x86inc.asm" |
|
| 24 |
+%include "x86util.asm" |
|
| 25 |
+ |
|
| 26 |
+SECTION_RODATA |
|
| 27 |
+ |
|
| 28 |
+SECTION .text |
|
| 29 |
+ |
|
| 30 |
+;----------------------------------------------------------------------------- |
|
| 31 |
+; YUYV/UYVY/NV12/NV21 packed pixel shuffling. |
|
| 32 |
+; |
|
| 33 |
+; void <fmt>ToY_<opt>(uint8_t *dst, const uint8_t *src, int w); |
|
| 34 |
+; and |
|
| 35 |
+; void <fmt>toUV_<opt>(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, |
|
| 36 |
+; const uint8_t *unused, int w); |
|
| 37 |
+;----------------------------------------------------------------------------- |
|
| 38 |
+ |
|
| 39 |
+; %1 = a (aligned) or u (unaligned) |
|
| 40 |
+; %2 = yuyv or uyvy |
|
| 41 |
+%macro LOOP_YUYV_TO_Y 2 |
|
| 42 |
+.loop_%1: |
|
| 43 |
+ mov%1 m0, [srcq+wq*2] ; (byte) { Y0, U0, Y1, V0, ... }
|
|
| 44 |
+ mov%1 m1, [srcq+wq*2+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }
|
|
| 45 |
+%ifidn %2, yuyv |
|
| 46 |
+ pand m0, m2 ; (word) { Y0, Y1, ..., Y7 }
|
|
| 47 |
+ pand m1, m2 ; (word) { Y8, Y9, ..., Y15 }
|
|
| 48 |
+%else ; uyvy |
|
| 49 |
+ psrlw m0, 8 ; (word) { Y0, Y1, ..., Y7 }
|
|
| 50 |
+ psrlw m1, 8 ; (word) { Y8, Y9, ..., Y15 }
|
|
| 51 |
+%endif ; yuyv/uyvy |
|
| 52 |
+ packuswb m0, m1 ; (byte) { Y0, ..., Y15 }
|
|
| 53 |
+ mova [dstq+wq], m0 |
|
| 54 |
+ add wq, mmsize |
|
| 55 |
+ jl .loop_%1 |
|
| 56 |
+ REP_RET |
|
| 57 |
+%endmacro |
|
| 58 |
+ |
|
| 59 |
+; %1 = nr. of XMM registers |
|
| 60 |
+; %2 = yuyv or uyvy |
|
| 61 |
+; %3 = if specified, it means that unaligned and aligned code in loop |
|
| 62 |
+; will be the same (i.e. YUYV+AVX), and thus we don't need to |
|
| 63 |
+; split the loop in an aligned and unaligned case |
|
| 64 |
+%macro YUYV_TO_Y_FN 2-3 |
|
| 65 |
+cglobal %2ToY, 5, 5, %1, dst, unused0, unused1, src, w |
|
| 66 |
+%ifdef ARCH_X86_64 |
|
| 67 |
+ movsxd wq, wd |
|
| 68 |
+%endif |
|
| 69 |
+ add dstq, wq |
|
| 70 |
+%if mmsize == 16 |
|
| 71 |
+ test srcq, 15 |
|
| 72 |
+%endif |
|
| 73 |
+ lea srcq, [srcq+wq*2] |
|
| 74 |
+%ifidn %2, yuyv |
|
| 75 |
+ pcmpeqb m2, m2 ; (byte) { 0xff } x 16
|
|
| 76 |
+ psrlw m2, 8 ; (word) { 0x00ff } x 8
|
|
| 77 |
+%endif ; yuyv |
|
| 78 |
+%if mmsize == 16 |
|
| 79 |
+ jnz .loop_u_start |
|
| 80 |
+ neg wq |
|
| 81 |
+ LOOP_YUYV_TO_Y a, %2 |
|
| 82 |
+.loop_u_start: |
|
| 83 |
+ neg wq |
|
| 84 |
+ LOOP_YUYV_TO_Y u, %2 |
|
| 85 |
+%else ; mmsize == 8 |
|
| 86 |
+ neg wq |
|
| 87 |
+ LOOP_YUYV_TO_Y a, %2 |
|
| 88 |
+%endif ; mmsize == 8/16 |
|
| 89 |
+%endmacro |
|
| 90 |
+ |
|
| 91 |
+; %1 = a (aligned) or u (unaligned) |
|
| 92 |
+; %2 = yuyv or uyvy |
|
| 93 |
+%macro LOOP_YUYV_TO_UV 2 |
|
| 94 |
+.loop_%1: |
|
| 95 |
+%ifidn %2, yuyv |
|
| 96 |
+ mov%1 m0, [srcq+wq*4] ; (byte) { Y0, U0, Y1, V0, ... }
|
|
| 97 |
+ mov%1 m1, [srcq+wq*4+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }
|
|
| 98 |
+ psrlw m0, 8 ; (word) { U0, V0, ..., U3, V3 }
|
|
| 99 |
+ psrlw m1, 8 ; (word) { U4, V4, ..., U7, V7 }
|
|
| 100 |
+%else ; uyvy |
|
| 101 |
+%if cpuflag(avx) |
|
| 102 |
+ vpand m0, m2, [srcq+wq*4] ; (word) { U0, V0, ..., U3, V3 }
|
|
| 103 |
+ vpand m1, m2, [srcq+wq*4+mmsize] ; (word) { U4, V4, ..., U7, V7 }
|
|
| 104 |
+%else |
|
| 105 |
+ mov%1 m0, [srcq+wq*4] ; (byte) { Y0, U0, Y1, V0, ... }
|
|
| 106 |
+ mov%1 m1, [srcq+wq*4+mmsize] ; (byte) { Y8, U4, Y9, V4, ... }
|
|
| 107 |
+ pand m0, m2 ; (word) { U0, V0, ..., U3, V3 }
|
|
| 108 |
+ pand m1, m2 ; (word) { U4, V4, ..., U7, V7 }
|
|
| 109 |
+%endif |
|
| 110 |
+%endif ; yuyv/uyvy |
|
| 111 |
+ packuswb m0, m1 ; (byte) { U0, V0, ..., U7, V7 }
|
|
| 112 |
+ pand m1, m0, m2 ; (word) { U0, U1, ..., U7 }
|
|
| 113 |
+ psrlw m0, 8 ; (word) { V0, V1, ..., V7 }
|
|
| 114 |
+%if mmsize == 16 |
|
| 115 |
+ packuswb m1, m0 ; (byte) { U0, ... U7, V1, ... V7 }
|
|
| 116 |
+ movh [dstUq+wq], m1 |
|
| 117 |
+ movhps [dstVq+wq], m1 |
|
| 118 |
+%else ; mmsize == 8 |
|
| 119 |
+ packuswb m1, m1 ; (byte) { U0, ... U3 }
|
|
| 120 |
+ packuswb m0, m0 ; (byte) { V0, ... V3 }
|
|
| 121 |
+ movh [dstUq+wq], m1 |
|
| 122 |
+ movh [dstVq+wq], m0 |
|
| 123 |
+%endif ; mmsize == 8/16 |
|
| 124 |
+ add wq, mmsize / 2 |
|
| 125 |
+ jl .loop_%1 |
|
| 126 |
+ REP_RET |
|
| 127 |
+%endmacro |
|
| 128 |
+ |
|
| 129 |
+; %1 = nr. of XMM registers |
|
| 130 |
+; %2 = yuyv or uyvy |
|
| 131 |
+; %3 = if specified, it means that unaligned and aligned code in loop |
|
| 132 |
+; will be the same (i.e. UYVY+AVX), and thus we don't need to |
|
| 133 |
+; split the loop in an aligned and unaligned case |
|
| 134 |
+%macro YUYV_TO_UV_FN 2-3 |
|
| 135 |
+cglobal %2ToUV, 4, 5, %1, dstU, dstV, unused, src, w |
|
| 136 |
+%ifdef ARCH_X86_64 |
|
| 137 |
+ movsxd wq, r5m |
|
| 138 |
+%else ; x86-32 |
|
| 139 |
+ mov wq, r5m |
|
| 140 |
+%endif |
|
| 141 |
+ add dstUq, wq |
|
| 142 |
+ add dstVq, wq |
|
| 143 |
+%if mmsize == 16 && %0 == 2 |
|
| 144 |
+ test srcq, 15 |
|
| 145 |
+%endif |
|
| 146 |
+ lea srcq, [srcq+wq*4] |
|
| 147 |
+ pcmpeqb m2, m2 ; (byte) { 0xff } x 16
|
|
| 148 |
+ psrlw m2, 8 ; (word) { 0x00ff } x 8
|
|
| 149 |
+ ; NOTE: if uyvy+avx, u/a are identical |
|
| 150 |
+%if mmsize == 16 && %0 == 2 |
|
| 151 |
+ jnz .loop_u_start |
|
| 152 |
+ neg wq |
|
| 153 |
+ LOOP_YUYV_TO_UV a, %2 |
|
| 154 |
+.loop_u_start: |
|
| 155 |
+ neg wq |
|
| 156 |
+ LOOP_YUYV_TO_UV u, %2 |
|
| 157 |
+%else ; mmsize == 8 |
|
| 158 |
+ neg wq |
|
| 159 |
+ LOOP_YUYV_TO_UV a, %2 |
|
| 160 |
+%endif ; mmsize == 8/16 |
|
| 161 |
+%endmacro |
|
| 162 |
+ |
|
| 163 |
+; %1 = a (aligned) or u (unaligned) |
|
| 164 |
+; %2 = nv12 or nv21 |
|
| 165 |
+%macro LOOP_NVXX_TO_UV 2 |
|
| 166 |
+.loop_%1: |
|
| 167 |
+ mov%1 m0, [srcq+wq*2] ; (byte) { U0, V0, U1, V1, ... }
|
|
| 168 |
+ mov%1 m1, [srcq+wq*2+mmsize] ; (byte) { U8, V8, U9, V9, ... }
|
|
| 169 |
+ pand m2, m0, m5 ; (word) { U0, U1, ..., U7 }
|
|
| 170 |
+ pand m3, m1, m5 ; (word) { U8, U9, ..., U15 }
|
|
| 171 |
+ psrlw m0, 8 ; (word) { V0, V1, ..., V7 }
|
|
| 172 |
+ psrlw m1, 8 ; (word) { V8, V9, ..., V15 }
|
|
| 173 |
+ packuswb m2, m3 ; (byte) { U0, ..., U15 }
|
|
| 174 |
+ packuswb m0, m1 ; (byte) { V0, ..., V15 }
|
|
| 175 |
+%ifidn %2, nv12 |
|
| 176 |
+ mova [dstUq+wq], m2 |
|
| 177 |
+ mova [dstVq+wq], m0 |
|
| 178 |
+%else ; nv21 |
|
| 179 |
+ mova [dstVq+wq], m2 |
|
| 180 |
+ mova [dstUq+wq], m0 |
|
| 181 |
+%endif ; nv12/21 |
|
| 182 |
+ add wq, mmsize |
|
| 183 |
+ jl .loop_%1 |
|
| 184 |
+ REP_RET |
|
| 185 |
+%endmacro |
|
| 186 |
+ |
|
| 187 |
+; %1 = nr. of XMM registers |
|
| 188 |
+; %2 = nv12 or nv21 |
|
| 189 |
+%macro NVXX_TO_UV_FN 2 |
|
| 190 |
+cglobal %2ToUV, 4, 5, %1, dstU, dstV, unused, src, w |
|
| 191 |
+%ifdef ARCH_X86_64 |
|
| 192 |
+ movsxd wq, r5m |
|
| 193 |
+%else ; x86-32 |
|
| 194 |
+ mov wq, r5m |
|
| 195 |
+%endif |
|
| 196 |
+ add dstUq, wq |
|
| 197 |
+ add dstVq, wq |
|
| 198 |
+%if mmsize == 16 |
|
| 199 |
+ test srcq, 15 |
|
| 200 |
+%endif |
|
| 201 |
+ lea srcq, [srcq+wq*2] |
|
| 202 |
+ pcmpeqb m5, m5 ; (byte) { 0xff } x 16
|
|
| 203 |
+ psrlw m5, 8 ; (word) { 0x00ff } x 8
|
|
| 204 |
+%if mmsize == 16 |
|
| 205 |
+ jnz .loop_u_start |
|
| 206 |
+ neg wq |
|
| 207 |
+ LOOP_NVXX_TO_UV a, %2 |
|
| 208 |
+.loop_u_start: |
|
| 209 |
+ neg wq |
|
| 210 |
+ LOOP_NVXX_TO_UV u, %2 |
|
| 211 |
+%else ; mmsize == 8 |
|
| 212 |
+ neg wq |
|
| 213 |
+ LOOP_NVXX_TO_UV a, %2 |
|
| 214 |
+%endif ; mmsize == 8/16 |
|
| 215 |
+%endmacro |
|
| 216 |
+ |
|
| 217 |
+%ifdef ARCH_X86_32 |
|
| 218 |
+INIT_MMX mmx |
|
| 219 |
+YUYV_TO_Y_FN 0, yuyv |
|
| 220 |
+YUYV_TO_Y_FN 0, uyvy |
|
| 221 |
+YUYV_TO_UV_FN 0, yuyv |
|
| 222 |
+YUYV_TO_UV_FN 0, uyvy |
|
| 223 |
+NVXX_TO_UV_FN 0, nv12 |
|
| 224 |
+NVXX_TO_UV_FN 0, nv21 |
|
| 225 |
+%endif |
|
| 226 |
+ |
|
| 227 |
+INIT_XMM sse2 |
|
| 228 |
+YUYV_TO_Y_FN 3, yuyv |
|
| 229 |
+YUYV_TO_Y_FN 2, uyvy |
|
| 230 |
+YUYV_TO_UV_FN 3, yuyv |
|
| 231 |
+YUYV_TO_UV_FN 3, uyvy |
|
| 232 |
+NVXX_TO_UV_FN 5, nv12 |
|
| 233 |
+NVXX_TO_UV_FN 5, nv21 |
|
| 234 |
+ |
|
| 235 |
+INIT_XMM avx |
|
| 236 |
+; in theory, we could write a yuy2-to-y using vpand (i.e. AVX), but |
|
| 237 |
+; that's not faster in practice |
|
| 238 |
+YUYV_TO_UV_FN 3, yuyv |
|
| 239 |
+YUYV_TO_UV_FN 3, uyvy, 1 |
|
| 240 |
+NVXX_TO_UV_FN 5, nv12 |
|
| 241 |
+NVXX_TO_UV_FN 5, nv21 |
| ... | ... |
@@ -307,6 +307,26 @@ VSCALE_FUNCS(sse2, sse2); |
| 307 | 307 |
VSCALE_FUNC(16, sse4); |
| 308 | 308 |
VSCALE_FUNCS(avx, avx); |
| 309 | 309 |
|
| 310 |
+#define INPUT_UV_FUNC(fmt, opt) \ |
|
| 311 |
+extern void ff_ ## fmt ## ToUV_ ## opt(uint8_t *dstU, uint8_t *dstV, \ |
|
| 312 |
+ const uint8_t *src, const uint8_t *unused1, \ |
|
| 313 |
+ int w, uint32_t *unused2) |
|
| 314 |
+#define INPUT_FUNC(fmt, opt) \ |
|
| 315 |
+extern void ff_ ## fmt ## ToY_ ## opt(uint8_t *dst, const uint8_t *src, \ |
|
| 316 |
+ int w, uint32_t *unused); \ |
|
| 317 |
+ INPUT_UV_FUNC(fmt, opt) |
|
| 318 |
+#define INPUT_FUNCS(opt) \ |
|
| 319 |
+ INPUT_FUNC(uyvy, opt); \ |
|
| 320 |
+ INPUT_FUNC(yuyv, opt); \ |
|
| 321 |
+ INPUT_UV_FUNC(nv12, opt); \ |
|
| 322 |
+ INPUT_UV_FUNC(nv21, opt) |
|
| 323 |
+ |
|
| 324 |
+#if ARCH_X86_32 |
|
| 325 |
+INPUT_FUNCS(mmx); |
|
| 326 |
+#endif |
|
| 327 |
+INPUT_FUNCS(sse2); |
|
| 328 |
+INPUT_FUNCS(avx); |
|
| 329 |
+ |
|
| 310 | 330 |
void ff_sws_init_swScale_mmx(SwsContext *c) |
| 311 | 331 |
{
|
| 312 | 332 |
int cpu_flags = av_get_cpu_flags(); |
| ... | ... |
@@ -366,6 +386,30 @@ switch(c->dstBpc){ \
|
| 366 | 366 |
ASSIGN_MMX_SCALE_FUNC(c->hyScale, c->hLumFilterSize, mmx, mmx); |
| 367 | 367 |
ASSIGN_MMX_SCALE_FUNC(c->hcScale, c->hChrFilterSize, mmx, mmx); |
| 368 | 368 |
ASSIGN_VSCALE_FUNC(c->yuv2plane1, mmx, mmx2, cpu_flags & AV_CPU_FLAG_MMX2); |
| 369 |
+ |
|
| 370 |
+ switch (c->srcFormat) {
|
|
| 371 |
+ case PIX_FMT_Y400A: |
|
| 372 |
+ c->lumToYV12 = ff_yuyvToY_mmx; |
|
| 373 |
+ if (c->alpPixBuf) |
|
| 374 |
+ c->alpToYV12 = ff_uyvyToY_mmx; |
|
| 375 |
+ break; |
|
| 376 |
+ case PIX_FMT_YUYV422: |
|
| 377 |
+ c->lumToYV12 = ff_yuyvToY_mmx; |
|
| 378 |
+ c->chrToYV12 = ff_yuyvToUV_mmx; |
|
| 379 |
+ break; |
|
| 380 |
+ case PIX_FMT_UYVY422: |
|
| 381 |
+ c->lumToYV12 = ff_uyvyToY_mmx; |
|
| 382 |
+ c->chrToYV12 = ff_uyvyToUV_mmx; |
|
| 383 |
+ break; |
|
| 384 |
+ case PIX_FMT_NV12: |
|
| 385 |
+ c->chrToYV12 = ff_nv12ToUV_mmx; |
|
| 386 |
+ break; |
|
| 387 |
+ case PIX_FMT_NV21: |
|
| 388 |
+ c->chrToYV12 = ff_nv21ToUV_mmx; |
|
| 389 |
+ break; |
|
| 390 |
+ default: |
|
| 391 |
+ break; |
|
| 392 |
+ } |
|
| 369 | 393 |
} |
| 370 | 394 |
if (cpu_flags & AV_CPU_FLAG_MMX2) {
|
| 371 | 395 |
ASSIGN_VSCALEX_FUNC(c->yuv2planeX, mmx2,); |
| ... | ... |
@@ -384,6 +428,28 @@ switch(c->dstBpc){ \
|
| 384 | 384 |
ASSIGN_SSE_SCALE_FUNC(c->hcScale, c->hChrFilterSize, sse2, sse2); |
| 385 | 385 |
ASSIGN_VSCALEX_FUNC(c->yuv2planeX, sse2,); |
| 386 | 386 |
ASSIGN_VSCALE_FUNC(c->yuv2plane1, sse2, sse2, 1); |
| 387 |
+ |
|
| 388 |
+ switch (c->srcFormat) {
|
|
| 389 |
+ case PIX_FMT_Y400A: |
|
| 390 |
+ c->lumToYV12 = ff_yuyvToY_sse2; |
|
| 391 |
+ if (c->alpPixBuf) |
|
| 392 |
+ c->alpToYV12 = ff_uyvyToY_sse2; |
|
| 393 |
+ break; |
|
| 394 |
+ case PIX_FMT_YUYV422: |
|
| 395 |
+ c->lumToYV12 = ff_yuyvToY_sse2; |
|
| 396 |
+ c->chrToYV12 = ff_yuyvToUV_sse2; |
|
| 397 |
+ break; |
|
| 398 |
+ case PIX_FMT_UYVY422: |
|
| 399 |
+ c->lumToYV12 = ff_uyvyToY_sse2; |
|
| 400 |
+ c->chrToYV12 = ff_uyvyToUV_sse2; |
|
| 401 |
+ break; |
|
| 402 |
+ case PIX_FMT_NV12: |
|
| 403 |
+ c->chrToYV12 = ff_nv12ToUV_sse2; |
|
| 404 |
+ break; |
|
| 405 |
+ case PIX_FMT_NV21: |
|
| 406 |
+ c->chrToYV12 = ff_nv21ToUV_sse2; |
|
| 407 |
+ break; |
|
| 408 |
+ } |
|
| 387 | 409 |
} |
| 388 | 410 |
if (cpu_flags & AV_CPU_FLAG_SSSE3) {
|
| 389 | 411 |
ASSIGN_SSE_SCALE_FUNC(c->hyScale, c->hLumFilterSize, ssse3, ssse3); |
| ... | ... |
@@ -402,6 +468,23 @@ switch(c->dstBpc){ \
|
| 402 | 402 |
if (cpu_flags & AV_CPU_FLAG_AVX) {
|
| 403 | 403 |
ASSIGN_VSCALEX_FUNC(c->yuv2planeX, avx,); |
| 404 | 404 |
ASSIGN_VSCALE_FUNC(c->yuv2plane1, avx, avx, 1); |
| 405 |
+ |
|
| 406 |
+ switch (c->srcFormat) {
|
|
| 407 |
+ case PIX_FMT_YUYV422: |
|
| 408 |
+ c->chrToYV12 = ff_yuyvToUV_avx; |
|
| 409 |
+ break; |
|
| 410 |
+ case PIX_FMT_UYVY422: |
|
| 411 |
+ c->chrToYV12 = ff_uyvyToUV_avx; |
|
| 412 |
+ break; |
|
| 413 |
+ case PIX_FMT_NV12: |
|
| 414 |
+ c->chrToYV12 = ff_nv12ToUV_avx; |
|
| 415 |
+ break; |
|
| 416 |
+ case PIX_FMT_NV21: |
|
| 417 |
+ c->chrToYV12 = ff_nv21ToUV_avx; |
|
| 418 |
+ break; |
|
| 419 |
+ default: |
|
| 420 |
+ break; |
|
| 421 |
+ } |
|
| 405 | 422 |
} |
| 406 | 423 |
#endif |
| 407 | 424 |
} |
| ... | ... |
@@ -1435,147 +1435,6 @@ static void RENAME(yuv2yuyv422_1)(SwsContext *c, const int16_t *buf0, |
| 1435 | 1435 |
} |
| 1436 | 1436 |
} |
| 1437 | 1437 |
|
| 1438 |
-#if !COMPILE_TEMPLATE_MMX2 |
|
| 1439 |
-//FIXME yuy2* can read up to 7 samples too much |
|
| 1440 |
- |
|
| 1441 |
-static void RENAME(yuy2ToY)(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, |
|
| 1442 |
- int width, uint32_t *unused) |
|
| 1443 |
-{
|
|
| 1444 |
- __asm__ volatile( |
|
| 1445 |
- "movq "MANGLE(bm01010101)", %%mm2 \n\t" |
|
| 1446 |
- "mov %0, %%"REG_a" \n\t" |
|
| 1447 |
- "1: \n\t" |
|
| 1448 |
- "movq (%1, %%"REG_a",2), %%mm0 \n\t" |
|
| 1449 |
- "movq 8(%1, %%"REG_a",2), %%mm1 \n\t" |
|
| 1450 |
- "pand %%mm2, %%mm0 \n\t" |
|
| 1451 |
- "pand %%mm2, %%mm1 \n\t" |
|
| 1452 |
- "packuswb %%mm1, %%mm0 \n\t" |
|
| 1453 |
- "movq %%mm0, (%2, %%"REG_a") \n\t" |
|
| 1454 |
- "add $8, %%"REG_a" \n\t" |
|
| 1455 |
- " js 1b \n\t" |
|
| 1456 |
- : : "g" ((x86_reg)-width), "r" (src+width*2), "r" (dst+width) |
|
| 1457 |
- : "%"REG_a |
|
| 1458 |
- ); |
|
| 1459 |
-} |
|
| 1460 |
- |
|
| 1461 |
-static void RENAME(yuy2ToUV)(uint8_t *dstU, uint8_t *dstV, |
|
| 1462 |
- const uint8_t *unused1, const uint8_t *src1, const uint8_t *src2, |
|
| 1463 |
- int width, uint32_t *unused) |
|
| 1464 |
-{
|
|
| 1465 |
- __asm__ volatile( |
|
| 1466 |
- "movq "MANGLE(bm01010101)", %%mm4 \n\t" |
|
| 1467 |
- "mov %0, %%"REG_a" \n\t" |
|
| 1468 |
- "1: \n\t" |
|
| 1469 |
- "movq (%1, %%"REG_a",4), %%mm0 \n\t" |
|
| 1470 |
- "movq 8(%1, %%"REG_a",4), %%mm1 \n\t" |
|
| 1471 |
- "psrlw $8, %%mm0 \n\t" |
|
| 1472 |
- "psrlw $8, %%mm1 \n\t" |
|
| 1473 |
- "packuswb %%mm1, %%mm0 \n\t" |
|
| 1474 |
- "movq %%mm0, %%mm1 \n\t" |
|
| 1475 |
- "psrlw $8, %%mm0 \n\t" |
|
| 1476 |
- "pand %%mm4, %%mm1 \n\t" |
|
| 1477 |
- "packuswb %%mm0, %%mm0 \n\t" |
|
| 1478 |
- "packuswb %%mm1, %%mm1 \n\t" |
|
| 1479 |
- "movd %%mm0, (%3, %%"REG_a") \n\t" |
|
| 1480 |
- "movd %%mm1, (%2, %%"REG_a") \n\t" |
|
| 1481 |
- "add $4, %%"REG_a" \n\t" |
|
| 1482 |
- " js 1b \n\t" |
|
| 1483 |
- : : "g" ((x86_reg)-width), "r" (src1+width*4), "r" (dstU+width), "r" (dstV+width) |
|
| 1484 |
- : "%"REG_a |
|
| 1485 |
- ); |
|
| 1486 |
- assert(src1 == src2); |
|
| 1487 |
-} |
|
| 1488 |
- |
|
| 1489 |
-/* This is almost identical to the previous, end exists only because |
|
| 1490 |
- * yuy2ToY/UV)(dst, src+1, ...) would have 100% unaligned accesses. */ |
|
| 1491 |
-static void RENAME(uyvyToY)(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, |
|
| 1492 |
- int width, uint32_t *unused) |
|
| 1493 |
-{
|
|
| 1494 |
- __asm__ volatile( |
|
| 1495 |
- "mov %0, %%"REG_a" \n\t" |
|
| 1496 |
- "1: \n\t" |
|
| 1497 |
- "movq (%1, %%"REG_a",2), %%mm0 \n\t" |
|
| 1498 |
- "movq 8(%1, %%"REG_a",2), %%mm1 \n\t" |
|
| 1499 |
- "psrlw $8, %%mm0 \n\t" |
|
| 1500 |
- "psrlw $8, %%mm1 \n\t" |
|
| 1501 |
- "packuswb %%mm1, %%mm0 \n\t" |
|
| 1502 |
- "movq %%mm0, (%2, %%"REG_a") \n\t" |
|
| 1503 |
- "add $8, %%"REG_a" \n\t" |
|
| 1504 |
- " js 1b \n\t" |
|
| 1505 |
- : : "g" ((x86_reg)-width), "r" (src+width*2), "r" (dst+width) |
|
| 1506 |
- : "%"REG_a |
|
| 1507 |
- ); |
|
| 1508 |
-} |
|
| 1509 |
- |
|
| 1510 |
-static void RENAME(uyvyToUV)(uint8_t *dstU, uint8_t *dstV, |
|
| 1511 |
- const uint8_t *unused1, const uint8_t *src1, const uint8_t *src2, |
|
| 1512 |
- int width, uint32_t *unused) |
|
| 1513 |
-{
|
|
| 1514 |
- __asm__ volatile( |
|
| 1515 |
- "movq "MANGLE(bm01010101)", %%mm4 \n\t" |
|
| 1516 |
- "mov %0, %%"REG_a" \n\t" |
|
| 1517 |
- "1: \n\t" |
|
| 1518 |
- "movq (%1, %%"REG_a",4), %%mm0 \n\t" |
|
| 1519 |
- "movq 8(%1, %%"REG_a",4), %%mm1 \n\t" |
|
| 1520 |
- "pand %%mm4, %%mm0 \n\t" |
|
| 1521 |
- "pand %%mm4, %%mm1 \n\t" |
|
| 1522 |
- "packuswb %%mm1, %%mm0 \n\t" |
|
| 1523 |
- "movq %%mm0, %%mm1 \n\t" |
|
| 1524 |
- "psrlw $8, %%mm0 \n\t" |
|
| 1525 |
- "pand %%mm4, %%mm1 \n\t" |
|
| 1526 |
- "packuswb %%mm0, %%mm0 \n\t" |
|
| 1527 |
- "packuswb %%mm1, %%mm1 \n\t" |
|
| 1528 |
- "movd %%mm0, (%3, %%"REG_a") \n\t" |
|
| 1529 |
- "movd %%mm1, (%2, %%"REG_a") \n\t" |
|
| 1530 |
- "add $4, %%"REG_a" \n\t" |
|
| 1531 |
- " js 1b \n\t" |
|
| 1532 |
- : : "g" ((x86_reg)-width), "r" (src1+width*4), "r" (dstU+width), "r" (dstV+width) |
|
| 1533 |
- : "%"REG_a |
|
| 1534 |
- ); |
|
| 1535 |
- assert(src1 == src2); |
|
| 1536 |
-} |
|
| 1537 |
- |
|
| 1538 |
-static av_always_inline void RENAME(nvXXtoUV)(uint8_t *dst1, uint8_t *dst2, |
|
| 1539 |
- const uint8_t *src, int width) |
|
| 1540 |
-{
|
|
| 1541 |
- __asm__ volatile( |
|
| 1542 |
- "movq "MANGLE(bm01010101)", %%mm4 \n\t" |
|
| 1543 |
- "mov %0, %%"REG_a" \n\t" |
|
| 1544 |
- "1: \n\t" |
|
| 1545 |
- "movq (%1, %%"REG_a",2), %%mm0 \n\t" |
|
| 1546 |
- "movq 8(%1, %%"REG_a",2), %%mm1 \n\t" |
|
| 1547 |
- "movq %%mm0, %%mm2 \n\t" |
|
| 1548 |
- "movq %%mm1, %%mm3 \n\t" |
|
| 1549 |
- "pand %%mm4, %%mm0 \n\t" |
|
| 1550 |
- "pand %%mm4, %%mm1 \n\t" |
|
| 1551 |
- "psrlw $8, %%mm2 \n\t" |
|
| 1552 |
- "psrlw $8, %%mm3 \n\t" |
|
| 1553 |
- "packuswb %%mm1, %%mm0 \n\t" |
|
| 1554 |
- "packuswb %%mm3, %%mm2 \n\t" |
|
| 1555 |
- "movq %%mm0, (%2, %%"REG_a") \n\t" |
|
| 1556 |
- "movq %%mm2, (%3, %%"REG_a") \n\t" |
|
| 1557 |
- "add $8, %%"REG_a" \n\t" |
|
| 1558 |
- " js 1b \n\t" |
|
| 1559 |
- : : "g" ((x86_reg)-width), "r" (src+width*2), "r" (dst1+width), "r" (dst2+width) |
|
| 1560 |
- : "%"REG_a |
|
| 1561 |
- ); |
|
| 1562 |
-} |
|
| 1563 |
- |
|
| 1564 |
-static void RENAME(nv12ToUV)(uint8_t *dstU, uint8_t *dstV, |
|
| 1565 |
- const uint8_t *unused1, const uint8_t *src1, const uint8_t *src2, |
|
| 1566 |
- int width, uint32_t *unused) |
|
| 1567 |
-{
|
|
| 1568 |
- RENAME(nvXXtoUV)(dstU, dstV, src1, width); |
|
| 1569 |
-} |
|
| 1570 |
- |
|
| 1571 |
-static void RENAME(nv21ToUV)(uint8_t *dstU, uint8_t *dstV, |
|
| 1572 |
- const uint8_t *unused1, const uint8_t *src1, const uint8_t *src2, |
|
| 1573 |
- int width, uint32_t *unused) |
|
| 1574 |
-{
|
|
| 1575 |
- RENAME(nvXXtoUV)(dstV, dstU, src1, width); |
|
| 1576 |
-} |
|
| 1577 |
-#endif /* !COMPILE_TEMPLATE_MMX2 */ |
|
| 1578 |
- |
|
| 1579 | 1438 |
static av_always_inline void RENAME(bgr24ToY_mmx)(int16_t *dst, const uint8_t *src, |
| 1580 | 1439 |
int width, enum PixelFormat srcFormat) |
| 1581 | 1440 |
{
|
| ... | ... |
@@ -1927,15 +1786,6 @@ static av_cold void RENAME(sws_init_swScale)(SwsContext *c) |
| 1927 | 1927 |
#endif /* COMPILE_TEMPLATE_MMX2 */ |
| 1928 | 1928 |
} |
| 1929 | 1929 |
|
| 1930 |
-#if !COMPILE_TEMPLATE_MMX2 |
|
| 1931 |
- switch(srcFormat) {
|
|
| 1932 |
- case PIX_FMT_YUYV422 : c->chrToYV12 = RENAME(yuy2ToUV); break; |
|
| 1933 |
- case PIX_FMT_UYVY422 : c->chrToYV12 = RENAME(uyvyToUV); break; |
|
| 1934 |
- case PIX_FMT_NV12 : c->chrToYV12 = RENAME(nv12ToUV); break; |
|
| 1935 |
- case PIX_FMT_NV21 : c->chrToYV12 = RENAME(nv21ToUV); break; |
|
| 1936 |
- default: break; |
|
| 1937 |
- } |
|
| 1938 |
-#endif /* !COMPILE_TEMPLATE_MMX2 */ |
|
| 1939 | 1930 |
if (!c->chrSrcHSubSample) {
|
| 1940 | 1931 |
switch(srcFormat) {
|
| 1941 | 1932 |
case PIX_FMT_BGR24 : c->chrToYV12 = RENAME(bgr24ToUV); break; |
| ... | ... |
@@ -1945,21 +1795,8 @@ static av_cold void RENAME(sws_init_swScale)(SwsContext *c) |
| 1945 | 1945 |
} |
| 1946 | 1946 |
|
| 1947 | 1947 |
switch (srcFormat) {
|
| 1948 |
-#if !COMPILE_TEMPLATE_MMX2 |
|
| 1949 |
- case PIX_FMT_YUYV422 : |
|
| 1950 |
- case PIX_FMT_Y400A : c->lumToYV12 = RENAME(yuy2ToY); break; |
|
| 1951 |
- case PIX_FMT_UYVY422 : c->lumToYV12 = RENAME(uyvyToY); break; |
|
| 1952 |
-#endif /* !COMPILE_TEMPLATE_MMX2 */ |
|
| 1953 | 1948 |
case PIX_FMT_BGR24 : c->lumToYV12 = RENAME(bgr24ToY); break; |
| 1954 | 1949 |
case PIX_FMT_RGB24 : c->lumToYV12 = RENAME(rgb24ToY); break; |
| 1955 | 1950 |
default: break; |
| 1956 | 1951 |
} |
| 1957 |
-#if !COMPILE_TEMPLATE_MMX2 |
|
| 1958 |
- if (c->alpPixBuf) {
|
|
| 1959 |
- switch (srcFormat) {
|
|
| 1960 |
- case PIX_FMT_Y400A : c->alpToYV12 = RENAME(yuy2ToY); break; |
|
| 1961 |
- default: break; |
|
| 1962 |
- } |
|
| 1963 |
- } |
|
| 1964 |
-#endif /* !COMPILE_TEMPLATE_MMX2 */ |
|
| 1965 | 1952 |
} |
| ... | ... |
@@ -14,18 +14,34 @@ FATE_AAC += fate-aac-al07_96 |
| 14 | 14 |
fate-aac-al07_96: CMD = pcm -i $(SAMPLES)/aac/al07_96.mp4 |
| 15 | 15 |
fate-aac-al07_96: REF = $(SAMPLES)/aac/al07_96.s16 |
| 16 | 16 |
|
| 17 |
+FATE_AAC += fate-aac-al15_44 |
|
| 18 |
+fate-aac-al15_44: CMD = pcm -i $(SAMPLES)/aac/al15_44.mp4 |
|
| 19 |
+fate-aac-al15_44: REF = $(SAMPLES)/aac/al15_44.s16 |
|
| 20 |
+ |
|
| 17 | 21 |
FATE_AAC += fate-aac-al17_44 |
| 18 | 22 |
fate-aac-al17_44: CMD = pcm -i $(SAMPLES)/aac/al17_44.mp4 |
| 19 | 23 |
fate-aac-al17_44: REF = $(SAMPLES)/aac/al17_44.s16 |
| 20 | 24 |
|
| 25 |
+FATE_AAC += fate-aac-al18_44 |
|
| 26 |
+fate-aac-al18_44: CMD = pcm -i $(SAMPLES)/aac/al18_44.mp4 |
|
| 27 |
+fate-aac-al18_44: REF = $(SAMPLES)/aac/al18_44.s16 |
|
| 28 |
+ |
|
| 21 | 29 |
FATE_AAC += fate-aac-am00_88 |
| 22 | 30 |
fate-aac-am00_88: CMD = pcm -i $(SAMPLES)/aac/am00_88.mp4 |
| 23 | 31 |
fate-aac-am00_88: REF = $(SAMPLES)/aac/am00_88.s16 |
| 24 | 32 |
|
| 33 |
+FATE_AAC += fate-aac-am05_44 |
|
| 34 |
+fate-aac-am05_44: CMD = pcm -i $(SAMPLES)/aac/am05_44.mp4 |
|
| 35 |
+fate-aac-am05_44: REF = $(SAMPLES)/aac/am05_44.s16 |
|
| 36 |
+ |
|
| 25 | 37 |
FATE_AAC += fate-aac-al_sbr_hq_cm_48_2 |
| 26 | 38 |
fate-aac-al_sbr_hq_cm_48_2: CMD = pcm -i $(SAMPLES)/aac/al_sbr_cm_48_2.mp4 |
| 27 | 39 |
fate-aac-al_sbr_hq_cm_48_2: REF = $(SAMPLES)/aac/al_sbr_hq_cm_48_2.s16 |
| 28 | 40 |
|
| 41 |
+FATE_AAC += fate-aac-al_sbr_hq_cm_48_5.1 |
|
| 42 |
+fate-aac-al_sbr_hq_cm_48_5.1: CMD = pcm -i $(SAMPLES)/aac/al_sbr_cm_48_5.1.mp4 |
|
| 43 |
+fate-aac-al_sbr_hq_cm_48_5.1: REF = $(SAMPLES)/aac/al_sbr_hq_cm_48_5.1.s16 |
|
| 44 |
+ |
|
| 29 | 45 |
FATE_AAC += fate-aac-al_sbr_ps_06_ur |
| 30 | 46 |
fate-aac-al_sbr_ps_06_ur: CMD = pcm -i $(SAMPLES)/aac/al_sbr_ps_06_new.mp4 |
| 31 | 47 |
fate-aac-al_sbr_ps_06_ur: REF = $(SAMPLES)/aac/al_sbr_ps_06_ur.s16 |
| ... | ... |
@@ -79,11 +79,20 @@ fate-sierra-vmd: CMD = framecrc -i $(SAMPLES)/vmd/12.vmd -vsync 0 -pix_fmt rgb24 |
| 79 | 79 |
FATE_DEMUX += fate-siff |
| 80 | 80 |
fate-siff: CMD = framecrc -i $(SAMPLES)/SIFF/INTRO_B.VB -t 3 -pix_fmt rgb24 |
| 81 | 81 |
|
| 82 |
+FATE_DEMUX += fate-smjpeg |
|
| 83 |
+fate-smjpeg: CMD = framecrc -i $(SAMPLES)/smjpeg/scenwin.mjpg -vcodec copy |
|
| 84 |
+ |
|
| 82 | 85 |
FATE_DEMUX += fate-westwood-aud |
| 83 | 86 |
fate-westwood-aud: CMD = md5 -i $(SAMPLES)/westwood-aud/excellent.aud -f s16le |
| 84 | 87 |
|
| 88 |
+FATE_DEMUX += fate-wtv-demux |
|
| 89 |
+fate-wtv-demux: CMD = framecrc -i $(SAMPLES)/wtv/law-and-order-partial.wtv -vcodec copy -acodec copy |
|
| 90 |
+ |
|
| 85 | 91 |
FATE_DEMUX += fate-xmv-demux |
| 86 | 92 |
fate-xmv-demux: CMD = framecrc -i $(SAMPLES)/xmv/logos1p.fmv -vcodec copy -acodec copy |
| 87 | 93 |
|
| 94 |
+FATE_DEMUX += fate-xwma-demux |
|
| 95 |
+fate-xwma-demux: CMD = crc -i $(SAMPLES)/xwma/ergon.xwma -acodec copy |
|
| 96 |
+ |
|
| 88 | 97 |
FATE_TESTS += $(FATE_DEMUX) |
| 89 | 98 |
fate-demux: $(FATE_DEMUX) |
| ... | ... |
@@ -29,5 +29,8 @@ fate-vc1_sa10091: CMD = framecrc -i $(SAMPLES)/vc1/SA10091.vc1 |
| 29 | 29 |
FATE_MICROSOFT += fate-vc1_sa20021 |
| 30 | 30 |
fate-vc1_sa20021: CMD = framecrc -i $(SAMPLES)/vc1/SA20021.vc1 |
| 31 | 31 |
|
| 32 |
+FATE_MICROSOFT += fate-vc1-ism |
|
| 33 |
+fate-vc1-ism: CMD = framecrc -i $(SAMPLES)/isom/vc1-wmapro.ism -an |
|
| 34 |
+ |
|
| 32 | 35 |
FATE_TESTS += $(FATE_MICROSOFT) |
| 33 | 36 |
fate-microsoft: $(FATE_MICROSOFT) |
| ... | ... |
@@ -49,6 +49,9 @@ fate-cvid: CMD = framecrc -i $(SAMPLES)/cvid/laracroft-cinepak-partial.avi -an |
| 49 | 49 |
FATE_VIDEO += fate-cvid-palette |
| 50 | 50 |
fate-cvid-palette: CMD = framecrc -i $(SAMPLES)/cvid/catfight-cvid-pal8-partial.mov -pix_fmt rgb24 -an |
| 51 | 51 |
|
| 52 |
+FATE_VIDEO += fate-cvid-grayscale |
|
| 53 |
+fate-cvid-grayscale: CMD = framecrc -i $(SAMPLES)/cvid/pcitva15.avi -an |
|
| 54 |
+ |
|
| 52 | 55 |
FATE_VIDEO += fate-cyberia-c93 |
| 53 | 56 |
fate-cyberia-c93: CMD = framecrc -i $(SAMPLES)/cyberia-c93/intro1.c93 -t 3 -pix_fmt rgb24 |
| 54 | 57 |
|
| ... | ... |
@@ -8,6 +8,11 @@ fate-wmapro-5.1: CMD = pcm -i $(SAMPLES)/wmapro/latin_192_mulitchannel_cut.wma |
| 8 | 8 |
fate-wmapro-5.1: CMP = oneoff |
| 9 | 9 |
fate-wmapro-5.1: REF = $(SAMPLES)/wmapro/latin_192_mulitchannel_cut.pcm |
| 10 | 10 |
|
| 11 |
+FATE_WMA += fate-wmapro-ism |
|
| 12 |
+fate-wmapro-ism: CMD = pcm -i $(SAMPLES)/isom/vc1-wmapro.ism -vn |
|
| 13 |
+fate-wmapro-ism: CMP = oneoff |
|
| 14 |
+fate-wmapro-ism: REF = $(SAMPLES)/isom/vc1-wmapro.pcm |
|
| 15 |
+ |
|
| 11 | 16 |
FATE_WMA += fate-wmavoice-7k |
| 12 | 17 |
fate-wmavoice-7k: CMD = pcm -i $(SAMPLES)/wmavoice/streaming_CBR-7K.wma |
| 13 | 18 |
fate-wmavoice-7k: CMP = stddev |
| 14 | 19 |
new file mode 100644 |
| ... | ... |
@@ -0,0 +1,152 @@ |
| 0 |
+0, 0, 11300, 0x46c78923 |
|
| 1 |
+0, 17921, 11300, 0x3f2a1175 |
|
| 2 |
+0, 35842, 11300, 0x722de221 |
|
| 3 |
+0, 53763, 11300, 0x01746b88 |
|
| 4 |
+0, 71684, 11300, 0x549587a7 |
|
| 5 |
+0, 89605, 11300, 0x843ab943 |
|
| 6 |
+0, 107526, 11300, 0x62fdee48 |
|
| 7 |
+0, 125447, 11300, 0x74a62867 |
|
| 8 |
+0, 143368, 11300, 0x35a20e2f |
|
| 9 |
+0, 161289, 11300, 0x4e9ef54d |
|
| 10 |
+0, 179210, 11300, 0xec7201f5 |
|
| 11 |
+0, 197131, 11300, 0x363bfe27 |
|
| 12 |
+0, 215052, 11300, 0x2aaab418 |
|
| 13 |
+0, 232973, 11300, 0x6a48ab3f |
|
| 14 |
+0, 250894, 11300, 0x3fecea34 |
|
| 15 |
+0, 268815, 11300, 0xa371f55e |
|
| 16 |
+0, 286736, 11300, 0xa86b147c |
|
| 17 |
+0, 304657, 11300, 0x49e9206e |
|
| 18 |
+0, 322578, 11300, 0x6c9a2155 |
|
| 19 |
+0, 340499, 11300, 0x2c8a4798 |
|
| 20 |
+0, 358420, 11300, 0x3485676c |
|
| 21 |
+0, 376341, 11300, 0xb0b293f2 |
|
| 22 |
+0, 394262, 11300, 0xe4a9b068 |
|
| 23 |
+0, 412183, 11300, 0xd68d0556 |
|
| 24 |
+0, 430104, 11300, 0xc28e5193 |
|
| 25 |
+0, 448025, 11300, 0xf6948483 |
|
| 26 |
+0, 465945, 11300, 0xf21fbf57 |
|
| 27 |
+0, 483866, 11300, 0x8345eb44 |
|
| 28 |
+0, 501787, 11300, 0x8124f045 |
|
| 29 |
+0, 519708, 11300, 0x18e31f10 |
|
| 30 |
+0, 537629, 11300, 0xdb1943fc |
|
| 31 |
+0, 555550, 11300, 0x8701699f |
|
| 32 |
+0, 573471, 11300, 0xd7b18550 |
|
| 33 |
+0, 591392, 11300, 0xa56faccc |
|
| 34 |
+0, 609313, 11300, 0xf8bcc17c |
|
| 35 |
+0, 627234, 11300, 0x446acab9 |
|
| 36 |
+0, 645155, 11300, 0x755fd295 |
|
| 37 |
+0, 663076, 11300, 0x92e3d100 |
|
| 38 |
+0, 680997, 11300, 0x54895bb3 |
|
| 39 |
+0, 698918, 11300, 0xd18bffda |
|
| 40 |
+0, 716839, 11300, 0x480dbe4f |
|
| 41 |
+0, 734760, 11300, 0x49ea9dbe |
|
| 42 |
+0, 752681, 11300, 0x00d3a003 |
|
| 43 |
+0, 770602, 11300, 0xda7bbfb2 |
|
| 44 |
+0, 788523, 11300, 0x9700d9c2 |
|
| 45 |
+0, 806444, 11300, 0xa0a9e490 |
|
| 46 |
+0, 824365, 11300, 0x00eb0979 |
|
| 47 |
+0, 842286, 11300, 0x32b04630 |
|
| 48 |
+0, 860207, 11300, 0xdfb73e51 |
|
| 49 |
+0, 878128, 11300, 0x3d8e4f96 |
|
| 50 |
+0, 896049, 11300, 0x2ca83271 |
|
| 51 |
+0, 913970, 11300, 0xb5b123c0 |
|
| 52 |
+0, 931891, 11300, 0x8a570e58 |
|
| 53 |
+0, 949812, 11300, 0xc6c805bc |
|
| 54 |
+0, 967733, 11300, 0x27caf7a5 |
|
| 55 |
+0, 985654, 11300, 0x5319ecb0 |
|
| 56 |
+0, 1003575, 11300, 0x5471e3fd |
|
| 57 |
+0, 1021496, 11300, 0x6d68a6f4 |
|
| 58 |
+0, 1039417, 11300, 0x872b7194 |
|
| 59 |
+0, 1057338, 11300, 0x007c36bd |
|
| 60 |
+0, 1075259, 11300, 0x2714f1b5 |
|
| 61 |
+0, 1093180, 11300, 0x6c8eb50f |
|
| 62 |
+0, 1111101, 11300, 0xf5d57be8 |
|
| 63 |
+0, 1129022, 11300, 0x981f412b |
|
| 64 |
+0, 1146943, 11300, 0x1a9804a1 |
|
| 65 |
+0, 1164864, 11300, 0xf0c1d24a |
|
| 66 |
+0, 1182785, 11300, 0xa70a9d9b |
|
| 67 |
+0, 1200706, 11300, 0x8c466876 |
|
| 68 |
+0, 1218627, 11300, 0xcf2e32df |
|
| 69 |
+0, 1236548, 11300, 0xcb8cfebf |
|
| 70 |
+0, 1254469, 11300, 0xb961ca99 |
|
| 71 |
+0, 1272390, 11300, 0x666d9619 |
|
| 72 |
+0, 1290311, 11300, 0x84bf5b55 |
|
| 73 |
+0, 1308232, 11300, 0xbfa22ccc |
|
| 74 |
+0, 1326153, 11300, 0xcde41849 |
|
| 75 |
+0, 1344074, 11300, 0x71372dcd |
|
| 76 |
+0, 1361994, 11300, 0x13402cfd |
|
| 77 |
+0, 1379915, 11300, 0xdebdd321 |
|
| 78 |
+0, 1397836, 11300, 0xdda66de1 |
|
| 79 |
+0, 1415757, 11300, 0x7f4bb682 |
|
| 80 |
+0, 1433678, 11300, 0xf67fd528 |
|
| 81 |
+0, 1451599, 11300, 0xe739ff8c |
|
| 82 |
+0, 1469520, 11300, 0x2e131774 |
|
| 83 |
+0, 1487441, 11300, 0xfa942811 |
|
| 84 |
+0, 1505362, 11300, 0x0cd93ac2 |
|
| 85 |
+0, 1523283, 11300, 0xd0445e0e |
|
| 86 |
+0, 1541204, 11300, 0x3f3497c7 |
|
| 87 |
+0, 1559125, 11300, 0x11b5bd2c |
|
| 88 |
+0, 1577046, 11300, 0xccd5e62a |
|
| 89 |
+0, 1594967, 11300, 0xa9d4fcb5 |
|
| 90 |
+0, 1612888, 11300, 0x34aa1a03 |
|
| 91 |
+0, 1630809, 11300, 0x1ce6299e |
|
| 92 |
+0, 1648730, 11300, 0x661c2745 |
|
| 93 |
+0, 1666651, 11300, 0x27d8a8b3 |
|
| 94 |
+0, 1684572, 11300, 0x9eb07467 |
|
| 95 |
+0, 1702493, 11300, 0x128374d2 |
|
| 96 |
+0, 1720414, 11300, 0x05c36ff5 |
|
| 97 |
+0, 1738335, 11300, 0x8a136bde |
|
| 98 |
+0, 1756256, 11300, 0x15c47c99 |
|
| 99 |
+0, 1774177, 11300, 0xcc4a93f4 |
|
| 100 |
+0, 1792098, 11300, 0x19529b2b |
|
| 101 |
+0, 1810019, 11300, 0x9943c076 |
|
| 102 |
+0, 1827940, 11300, 0xf898e583 |
|
| 103 |
+0, 1845861, 11300, 0x40f71f94 |
|
| 104 |
+0, 1863782, 11300, 0x5b604afb |
|
| 105 |
+0, 1881703, 11300, 0x8c176af4 |
|
| 106 |
+0, 1899624, 11300, 0x0f1a6216 |
|
| 107 |
+0, 1917545, 11300, 0x38bbd13d |
|
| 108 |
+0, 1935466, 11300, 0x90c8d1fc |
|
| 109 |
+0, 1953387, 11300, 0x253000d7 |
|
| 110 |
+0, 1971308, 11300, 0xb94b03b1 |
|
| 111 |
+0, 1989229, 11300, 0xbc872268 |
|
| 112 |
+0, 2007150, 11300, 0xe77adb8c |
|
| 113 |
+0, 2025071, 11300, 0xa38936b7 |
|
| 114 |
+0, 2042992, 11300, 0xd6153632 |
|
| 115 |
+0, 2060913, 11300, 0x1ae633cc |
|
| 116 |
+0, 2078834, 11300, 0xb90c286e |
|
| 117 |
+0, 2096755, 11300, 0xbc7e333d |
|
| 118 |
+0, 2114676, 11300, 0x1b5421f8 |
|
| 119 |
+0, 2132597, 11300, 0xdde6506d |
|
| 120 |
+0, 2150518, 11300, 0xd3eb757e |
|
| 121 |
+0, 2168439, 11300, 0x5ad1929c |
|
| 122 |
+0, 2186360, 11300, 0x4f6aa47d |
|
| 123 |
+0, 2204281, 11300, 0xab3caf55 |
|
| 124 |
+0, 2222202, 11300, 0x5ff9b39a |
|
| 125 |
+0, 2240123, 11300, 0x1454e12e |
|
| 126 |
+0, 2258043, 11300, 0xf18216e8 |
|
| 127 |
+0, 2275964, 11300, 0x62144880 |
|
| 128 |
+0, 2293885, 11300, 0x54284241 |
|
| 129 |
+0, 2311806, 11300, 0x8e8c7228 |
|
| 130 |
+0, 2329727, 11300, 0xb498d06e |
|
| 131 |
+0, 2347648, 11300, 0x7b1e6be1 |
|
| 132 |
+0, 2365569, 11300, 0x5e5ea1f4 |
|
| 133 |
+0, 2383490, 11300, 0x41eda28e |
|
| 134 |
+0, 2401411, 11300, 0x7ba6aa92 |
|
| 135 |
+0, 2419332, 11300, 0xa8a8b1c7 |
|
| 136 |
+0, 2437253, 11300, 0x0d30bd08 |
|
| 137 |
+0, 2455174, 11300, 0xc610bf16 |
|
| 138 |
+0, 2473095, 11300, 0xed57c075 |
|
| 139 |
+0, 2491016, 11300, 0xb86dbfea |
|
| 140 |
+0, 2508937, 11300, 0x0970c03d |
|
| 141 |
+0, 2526858, 11300, 0x743ac2ac |
|
| 142 |
+0, 2544779, 11300, 0x0a44c816 |
|
| 143 |
+0, 2562700, 11300, 0xe32acd6b |
|
| 144 |
+0, 2580621, 11300, 0x209bcdab |
|
| 145 |
+0, 2598542, 11300, 0x3cd0d105 |
|
| 146 |
+0, 2616463, 11300, 0xc0bcd330 |
|
| 147 |
+0, 2634384, 11300, 0x4785d6dc |
|
| 148 |
+0, 2652305, 11300, 0xe85f9c90 |
|
| 149 |
+0, 2670226, 11300, 0xd4a72850 |
|
| 150 |
+0, 2688147, 11300, 0x04766e41 |
|
| 151 |
+0, 2706068, 11300, 0x04766e41 |
| 0 | 152 |
new file mode 100644 |
| ... | ... |
@@ -0,0 +1,423 @@ |
| 0 |
+0, 0, 734, 0x5a042c2c |
|
| 1 |
+1, 0, 1024, 0x00000000 |
|
| 2 |
+1, 2090, 1024, 0x00000000 |
|
| 3 |
+1, 4180, 1024, 0xd89a448e |
|
| 4 |
+1, 6269, 1024, 0x695b369c |
|
| 5 |
+1, 8359, 1024, 0xc8ba5707 |
|
| 6 |
+0, 9990, 763, 0xb5893f2f |
|
| 7 |
+1, 10449, 1024, 0xdf241fc6 |
|
| 8 |
+1, 12539, 1024, 0x61cf4166 |
|
| 9 |
+1, 14629, 1024, 0x97cbc386 |
|
| 10 |
+1, 16718, 1024, 0x44899d04 |
|
| 11 |
+1, 18808, 1024, 0xa7cbaa62 |
|
| 12 |
+0, 19980, 3023, 0x0f3907d3 |
|
| 13 |
+1, 20898, 1024, 0xa7aea60c |
|
| 14 |
+1, 22988, 1024, 0xd7b18a89 |
|
| 15 |
+1, 25078, 1024, 0x268e81f6 |
|
| 16 |
+1, 27167, 1024, 0x9cf83a2f |
|
| 17 |
+1, 29257, 1024, 0x5559b508 |
|
| 18 |
+0, 29970, 4800, 0x22e6e18a |
|
| 19 |
+1, 31347, 1024, 0xe1b9e71c |
|
| 20 |
+1, 33437, 1024, 0xdcee733e |
|
| 21 |
+1, 35527, 1024, 0xe5918f60 |
|
| 22 |
+1, 37616, 1024, 0x29dbd209 |
|
| 23 |
+1, 39706, 1024, 0x9bcbcf16 |
|
| 24 |
+0, 39960, 6417, 0x427adde5 |
|
| 25 |
+1, 41796, 1024, 0x86f5f458 |
|
| 26 |
+1, 43886, 1024, 0xabcbda86 |
|
| 27 |
+1, 45976, 1024, 0xc51f77b9 |
|
| 28 |
+1, 48065, 1024, 0xf6b3a504 |
|
| 29 |
+0, 49950, 6776, 0x7a74c6ad |
|
| 30 |
+1, 50155, 1024, 0x1af3e40e |
|
| 31 |
+1, 52245, 1024, 0x3866b03b |
|
| 32 |
+1, 54335, 1024, 0xbc005403 |
|
| 33 |
+1, 56424, 1024, 0xe9dfcc51 |
|
| 34 |
+1, 58514, 1024, 0x83c837cb |
|
| 35 |
+0, 59940, 6808, 0x1f6eb7c3 |
|
| 36 |
+1, 60604, 1024, 0xfa649580 |
|
| 37 |
+1, 62694, 1024, 0x519452ea |
|
| 38 |
+1, 64784, 1024, 0xd4978774 |
|
| 39 |
+1, 66873, 1024, 0xe2a3b1cd |
|
| 40 |
+1, 68963, 1024, 0x9a9472ad |
|
| 41 |
+0, 69930, 6726, 0x452087e6 |
|
| 42 |
+1, 71053, 1024, 0xa12d4060 |
|
| 43 |
+1, 73143, 1024, 0x31fb0646 |
|
| 44 |
+1, 75233, 1024, 0xfc44343f |
|
| 45 |
+1, 77322, 1024, 0x0847751a |
|
| 46 |
+1, 79412, 1024, 0x227968a2 |
|
| 47 |
+0, 79920, 6829, 0xee82b109 |
|
| 48 |
+1, 81502, 1024, 0x7cce9f1c |
|
| 49 |
+1, 83592, 1024, 0xb8356713 |
|
| 50 |
+1, 85682, 1024, 0xb29f6e6f |
|
| 51 |
+1, 87771, 1024, 0x9e1430ab |
|
| 52 |
+1, 89861, 1024, 0x26d85423 |
|
| 53 |
+0, 89910, 7055, 0xf41f1108 |
|
| 54 |
+1, 91951, 1024, 0x6496547d |
|
| 55 |
+1, 94041, 1024, 0x316b1a86 |
|
| 56 |
+1, 96131, 1024, 0x3cd83afc |
|
| 57 |
+1, 98220, 1024, 0x993ff633 |
|
| 58 |
+0, 99990, 6977, 0xf8fe1ede |
|
| 59 |
+1, 100310, 1024, 0x0708d1a2 |
|
| 60 |
+1, 102400, 1024, 0xd7230db9 |
|
| 61 |
+1, 104490, 1024, 0xbb0779ca |
|
| 62 |
+1, 106580, 1024, 0xc6094e1b |
|
| 63 |
+1, 108669, 1024, 0x15a8b039 |
|
| 64 |
+0, 109980, 6942, 0x9ad105c6 |
|
| 65 |
+1, 110759, 1024, 0xd6dbe88c |
|
| 66 |
+1, 112849, 1024, 0x7e8d1140 |
|
| 67 |
+1, 114939, 1024, 0xef88e525 |
|
| 68 |
+1, 117029, 1024, 0x44e21149 |
|
| 69 |
+1, 119118, 1024, 0x65b0f5f4 |
|
| 70 |
+0, 119970, 6926, 0xe239dad6 |
|
| 71 |
+1, 121208, 1024, 0xb955f687 |
|
| 72 |
+1, 123298, 1024, 0xc85fba9c |
|
| 73 |
+1, 125388, 1024, 0xf59655ad |
|
| 74 |
+1, 127478, 1024, 0x6de80bf1 |
|
| 75 |
+1, 129567, 1024, 0x2dcf6e41 |
|
| 76 |
+0, 129960, 6966, 0x81dcfab1 |
|
| 77 |
+1, 131657, 1024, 0xd0ddcf8a |
|
| 78 |
+1, 133747, 1024, 0x00135c2d |
|
| 79 |
+1, 135837, 1024, 0x697f8efd |
|
| 80 |
+1, 137927, 1024, 0x7a9bada5 |
|
| 81 |
+0, 139950, 6896, 0x31e6cc02 |
|
| 82 |
+1, 140016, 1024, 0x0d22783c |
|
| 83 |
+1, 142106, 1024, 0x7726d07d |
|
| 84 |
+1, 144196, 1024, 0xa2f14f67 |
|
| 85 |
+1, 146286, 1024, 0x7f51060d |
|
| 86 |
+1, 148376, 1024, 0xc4ec6aea |
|
| 87 |
+0, 149940, 6889, 0x1cc1006e |
|
| 88 |
+1, 150465, 1024, 0x9bb37ca4 |
|
| 89 |
+1, 152555, 1024, 0x9b085577 |
|
| 90 |
+1, 154645, 1024, 0x8812f8af |
|
| 91 |
+1, 156735, 1024, 0x788f5221 |
|
| 92 |
+1, 158824, 1024, 0x3a2ce642 |
|
| 93 |
+0, 159930, 6933, 0xc303f87f |
|
| 94 |
+1, 160914, 1024, 0x72415692 |
|
| 95 |
+1, 163004, 1024, 0xe3dcc105 |
|
| 96 |
+1, 165094, 1024, 0xb26c0599 |
|
| 97 |
+1, 167184, 1024, 0x5c9e55eb |
|
| 98 |
+1, 169273, 1024, 0x8fe88707 |
|
| 99 |
+0, 169920, 7034, 0xb4970a20 |
|
| 100 |
+1, 171363, 1024, 0xc5d7beb6 |
|
| 101 |
+1, 173453, 1024, 0xe1d3a3b4 |
|
| 102 |
+1, 175543, 1024, 0x012da0c6 |
|
| 103 |
+1, 177633, 1024, 0x8d010922 |
|
| 104 |
+1, 179722, 1024, 0x3366eb0d |
|
| 105 |
+0, 179910, 6961, 0xf064095d |
|
| 106 |
+1, 181812, 1024, 0xc9381a27 |
|
| 107 |
+1, 183902, 1024, 0x0774f685 |
|
| 108 |
+1, 185992, 1024, 0xc5cae0a5 |
|
| 109 |
+1, 188082, 1024, 0xa6f4737c |
|
| 110 |
+0, 189990, 7089, 0x5ba350f9 |
|
| 111 |
+1, 190171, 1024, 0x8fb6d0d1 |
|
| 112 |
+1, 192261, 1024, 0x05f579c2 |
|
| 113 |
+1, 194351, 1024, 0x56905d99 |
|
| 114 |
+1, 196441, 1024, 0x002ee18d |
|
| 115 |
+1, 198531, 1024, 0xeb37ef51 |
|
| 116 |
+0, 199980, 7078, 0xa83f3e88 |
|
| 117 |
+1, 200620, 1024, 0x38025635 |
|
| 118 |
+1, 202710, 1024, 0x4fe643c8 |
|
| 119 |
+1, 204800, 1024, 0x11d66ab1 |
|
| 120 |
+1, 206890, 1024, 0xcc3051e9 |
|
| 121 |
+1, 208980, 1024, 0xcd93e854 |
|
| 122 |
+0, 209970, 7147, 0xcda66cfc |
|
| 123 |
+1, 211069, 1024, 0x38f1196d |
|
| 124 |
+1, 213159, 1024, 0x657a15fc |
|
| 125 |
+1, 215249, 1024, 0x669ce2a9 |
|
| 126 |
+1, 217339, 1024, 0x95862dda |
|
| 127 |
+1, 219429, 1024, 0x1726a7b2 |
|
| 128 |
+0, 219960, 7173, 0xb7455859 |
|
| 129 |
+1, 221518, 1024, 0xd6ece2a1 |
|
| 130 |
+1, 223608, 1024, 0x33ab9553 |
|
| 131 |
+1, 225698, 1024, 0xd50c73a6 |
|
| 132 |
+1, 227788, 1024, 0xfe25b63a |
|
| 133 |
+1, 229878, 1024, 0x7e2959e3 |
|
| 134 |
+0, 229950, 7213, 0x97b89994 |
|
| 135 |
+1, 231967, 1024, 0xa4c07b34 |
|
| 136 |
+1, 234057, 1024, 0xd6d8f15c |
|
| 137 |
+1, 236147, 1024, 0x1eccddd7 |
|
| 138 |
+1, 238237, 1024, 0x2b69f9cb |
|
| 139 |
+0, 239940, 7170, 0xca8b2948 |
|
| 140 |
+1, 240327, 1024, 0x667b775f |
|
| 141 |
+1, 242416, 1024, 0xad3b84e9 |
|
| 142 |
+1, 244506, 1024, 0x4f29fc67 |
|
| 143 |
+1, 246596, 1024, 0x8d611ab7 |
|
| 144 |
+1, 248686, 1024, 0x278966ea |
|
| 145 |
+0, 249930, 7174, 0xc7cc6bbb |
|
| 146 |
+1, 250776, 1024, 0xaf33812b |
|
| 147 |
+1, 252865, 1024, 0xa55f4265 |
|
| 148 |
+1, 254955, 1024, 0x023cb51c |
|
| 149 |
+1, 257045, 1024, 0x1d1f1005 |
|
| 150 |
+1, 259135, 1024, 0x874cccf7 |
|
| 151 |
+0, 259920, 7235, 0xc2e68d2b |
|
| 152 |
+1, 261224, 1024, 0xda705428 |
|
| 153 |
+1, 263314, 1024, 0x48d9b440 |
|
| 154 |
+1, 265404, 1024, 0xa14e0712 |
|
| 155 |
+1, 267494, 1024, 0x7efbad1f |
|
| 156 |
+1, 269584, 1024, 0xdb82c17f |
|
| 157 |
+0, 270000, 7261, 0x8204a423 |
|
| 158 |
+1, 271673, 1024, 0xcbe87613 |
|
| 159 |
+1, 273763, 1024, 0x3a63df1d |
|
| 160 |
+1, 275853, 1024, 0xd5636bba |
|
| 161 |
+1, 277943, 1024, 0x9397af23 |
|
| 162 |
+0, 279990, 7353, 0xacc7e7c0 |
|
| 163 |
+1, 280033, 1024, 0x32a07c98 |
|
| 164 |
+1, 282122, 1024, 0x202ca667 |
|
| 165 |
+1, 284212, 1024, 0xdf969011 |
|
| 166 |
+1, 286302, 1024, 0xc434d238 |
|
| 167 |
+1, 288392, 1024, 0xe9ad7562 |
|
| 168 |
+0, 289980, 7065, 0x45035c5c |
|
| 169 |
+1, 290482, 1024, 0xb51b6b50 |
|
| 170 |
+1, 292571, 1024, 0xe70aecd3 |
|
| 171 |
+1, 294661, 1024, 0x03c816b2 |
|
| 172 |
+1, 296751, 1024, 0x869fdf25 |
|
| 173 |
+1, 298841, 1024, 0xd40a0a62 |
|
| 174 |
+0, 299970, 7269, 0x72edbb76 |
|
| 175 |
+1, 300931, 1024, 0x5af7dd35 |
|
| 176 |
+1, 303020, 1024, 0x891ffc72 |
|
| 177 |
+1, 305110, 1024, 0x1ff68a08 |
|
| 178 |
+1, 307200, 1024, 0x5a7517a9 |
|
| 179 |
+1, 309290, 1024, 0x0f959f74 |
|
| 180 |
+0, 309960, 7220, 0xb926772f |
|
| 181 |
+1, 311380, 1024, 0xe92a12a2 |
|
| 182 |
+1, 313469, 1024, 0x38000e55 |
|
| 183 |
+1, 315559, 1024, 0x39fbdd70 |
|
| 184 |
+1, 317649, 1024, 0xca3d9184 |
|
| 185 |
+1, 319739, 1024, 0x66c8995b |
|
| 186 |
+0, 319950, 7326, 0x0a66c632 |
|
| 187 |
+1, 321829, 1024, 0xac25acea |
|
| 188 |
+1, 323918, 1024, 0x3cd1046c |
|
| 189 |
+1, 326008, 1024, 0x6a1df31c |
|
| 190 |
+1, 328098, 1024, 0x21ca10a1 |
|
| 191 |
+0, 329940, 7225, 0xe39076ab |
|
| 192 |
+1, 330188, 1024, 0x1aeccedc |
|
| 193 |
+1, 332278, 1024, 0xddea1335 |
|
| 194 |
+1, 334367, 1024, 0x19f5ca9f |
|
| 195 |
+1, 336457, 1024, 0x88e95e43 |
|
| 196 |
+1, 338547, 1024, 0x726284fe |
|
| 197 |
+0, 339930, 7265, 0xe0209036 |
|
| 198 |
+1, 340637, 1024, 0x6b85b40e |
|
| 199 |
+1, 342727, 1024, 0x111fee2a |
|
| 200 |
+1, 344816, 1024, 0x3656b588 |
|
| 201 |
+1, 346906, 1024, 0xa5a2b552 |
|
| 202 |
+1, 348996, 1024, 0x38fb2467 |
|
| 203 |
+0, 349920, 7337, 0x7a5dc093 |
|
| 204 |
+1, 351086, 1024, 0xaa919ccc |
|
| 205 |
+1, 353176, 1024, 0x15993dbc |
|
| 206 |
+1, 355265, 1024, 0xbe01a7b9 |
|
| 207 |
+1, 357355, 1024, 0xefe93c09 |
|
| 208 |
+1, 359445, 1024, 0x1bb566e5 |
|
| 209 |
+0, 360000, 7246, 0x519a7a3c |
|
| 210 |
+1, 361535, 1024, 0x15ce6237 |
|
| 211 |
+1, 363624, 1024, 0xa8552e66 |
|
| 212 |
+1, 365714, 1024, 0x9d80187e |
|
| 213 |
+1, 367804, 1024, 0x5df3fc30 |
|
| 214 |
+1, 369894, 1024, 0x1a312aa5 |
|
| 215 |
+0, 369990, 7266, 0x352c8078 |
|
| 216 |
+1, 371984, 1024, 0x6bb8e302 |
|
| 217 |
+1, 374073, 1024, 0xbd9684bb |
|
| 218 |
+1, 376163, 1024, 0x78b0b166 |
|
| 219 |
+1, 378253, 1024, 0xd9af5eae |
|
| 220 |
+0, 379980, 7323, 0xcaf69d7c |
|
| 221 |
+1, 380343, 1024, 0xdb90fe82 |
|
| 222 |
+1, 382433, 1024, 0x327614e9 |
|
| 223 |
+1, 384522, 1024, 0x1f19b7fe |
|
| 224 |
+1, 386612, 1024, 0x46c53f96 |
|
| 225 |
+1, 388702, 1024, 0x921b2189 |
|
| 226 |
+0, 389970, 7309, 0x98c1e6f7 |
|
| 227 |
+1, 390792, 1024, 0xa8fbc85a |
|
| 228 |
+1, 392882, 1024, 0xabfdaaae |
|
| 229 |
+1, 394971, 1024, 0x6acc7387 |
|
| 230 |
+1, 397061, 1024, 0x0d9c27b5 |
|
| 231 |
+1, 399151, 1024, 0xba4dd809 |
|
| 232 |
+0, 399960, 7121, 0x913d5bd6 |
|
| 233 |
+1, 401241, 1024, 0x2a2ad521 |
|
| 234 |
+1, 403331, 1024, 0x892de38a |
|
| 235 |
+1, 405420, 1024, 0xdc97a2eb |
|
| 236 |
+1, 407510, 1024, 0x4f614ca4 |
|
| 237 |
+1, 409600, 1024, 0x9c8a77ea |
|
| 238 |
+0, 409950, 7088, 0x56302362 |
|
| 239 |
+1, 411690, 1024, 0x2d30e646 |
|
| 240 |
+1, 413780, 1024, 0x74e800a7 |
|
| 241 |
+1, 415869, 1024, 0x1e01fb02 |
|
| 242 |
+1, 417959, 1024, 0x4ed2c1d8 |
|
| 243 |
+0, 419940, 7104, 0xc0d14f78 |
|
| 244 |
+1, 420049, 1024, 0xf2fdbe63 |
|
| 245 |
+1, 422139, 1024, 0x8d6f63a1 |
|
| 246 |
+1, 424229, 1024, 0xded468d9 |
|
| 247 |
+1, 426318, 1024, 0xccad839e |
|
| 248 |
+1, 428408, 1024, 0xdde7c082 |
|
| 249 |
+0, 429930, 7169, 0xd03c825b |
|
| 250 |
+1, 430498, 1024, 0x548613c5 |
|
| 251 |
+1, 432588, 1024, 0x383909bd |
|
| 252 |
+1, 434678, 1024, 0xfd37627b |
|
| 253 |
+1, 436767, 1024, 0x6d95a481 |
|
| 254 |
+1, 438857, 1024, 0x56aa87fa |
|
| 255 |
+0, 439920, 7038, 0x1ecc201d |
|
| 256 |
+1, 440947, 1024, 0x7b67258c |
|
| 257 |
+1, 443037, 1024, 0x7dd99a92 |
|
| 258 |
+1, 445127, 1024, 0x4a66d102 |
|
| 259 |
+1, 447216, 1024, 0x7b3fce51 |
|
| 260 |
+1, 449306, 1024, 0xbbd968aa |
|
| 261 |
+0, 450000, 7015, 0x83c94454 |
|
| 262 |
+1, 451396, 1024, 0x8283ec36 |
|
| 263 |
+1, 453486, 1024, 0x3c96493d |
|
| 264 |
+1, 455576, 1024, 0xfa4f8cf8 |
|
| 265 |
+1, 457665, 1024, 0xe2cf872d |
|
| 266 |
+1, 459755, 1024, 0x0a9e7aa6 |
|
| 267 |
+0, 459990, 6983, 0x9e51f54d |
|
| 268 |
+1, 461845, 1024, 0x6e7a0550 |
|
| 269 |
+1, 463935, 1024, 0x3acfea2f |
|
| 270 |
+1, 466024, 1024, 0x7111d0fa |
|
| 271 |
+1, 468114, 1024, 0xe9a1eca9 |
|
| 272 |
+0, 469980, 7088, 0x70d33de1 |
|
| 273 |
+1, 470204, 1024, 0x24da6c46 |
|
| 274 |
+1, 472294, 1024, 0x117cff37 |
|
| 275 |
+1, 474384, 1024, 0x0f27cab6 |
|
| 276 |
+1, 476473, 1024, 0x69b6b4e6 |
|
| 277 |
+1, 478563, 1024, 0x1e6cc841 |
|
| 278 |
+0, 479970, 7096, 0x4d0f81b5 |
|
| 279 |
+1, 480653, 1024, 0xb01e2365 |
|
| 280 |
+1, 482743, 1024, 0x14e200d3 |
|
| 281 |
+1, 484833, 1024, 0xd1184c98 |
|
| 282 |
+1, 486922, 1024, 0xef9140e9 |
|
| 283 |
+1, 489012, 1024, 0x4cbb645e |
|
| 284 |
+0, 489960, 7106, 0xd1a83ddc |
|
| 285 |
+1, 491102, 1024, 0xe7fe2f06 |
|
| 286 |
+1, 493192, 1024, 0xf8c45028 |
|
| 287 |
+1, 495282, 1024, 0x561358f4 |
|
| 288 |
+1, 497371, 1024, 0xd0129b77 |
|
| 289 |
+1, 499461, 1024, 0xcc636e88 |
|
| 290 |
+0, 499950, 7219, 0x20f47fe4 |
|
| 291 |
+1, 501551, 1024, 0xe9406321 |
|
| 292 |
+1, 503641, 1024, 0x9f16a041 |
|
| 293 |
+1, 505731, 1024, 0x468bf409 |
|
| 294 |
+1, 507820, 1024, 0x3df70f7b |
|
| 295 |
+1, 509910, 1024, 0xa880b11b |
|
| 296 |
+0, 509940, 7184, 0x45dc6a0e |
|
| 297 |
+1, 512000, 1024, 0x3286c489 |
|
| 298 |
+1, 514090, 1024, 0x39fe9ebc |
|
| 299 |
+1, 516180, 1024, 0xc533d83b |
|
| 300 |
+1, 518269, 1024, 0x153b195d |
|
| 301 |
+0, 519930, 7222, 0x488c6499 |
|
| 302 |
+1, 520359, 1024, 0xd84786a1 |
|
| 303 |
+1, 522449, 1024, 0xdc295aaa |
|
| 304 |
+1, 524539, 1024, 0xfb764d8c |
|
| 305 |
+1, 526629, 1024, 0xeebc9db9 |
|
| 306 |
+1, 528718, 1024, 0x7ba9403e |
|
| 307 |
+0, 529920, 7254, 0xbd097ba7 |
|
| 308 |
+1, 530808, 1024, 0x4e5571ec |
|
| 309 |
+1, 532898, 1024, 0xd965fad4 |
|
| 310 |
+1, 534988, 1024, 0x87e259f2 |
|
| 311 |
+1, 537078, 1024, 0xae7e533b |
|
| 312 |
+1, 539167, 1024, 0x313cf4d6 |
|
| 313 |
+0, 540000, 7189, 0x46e06d43 |
|
| 314 |
+1, 541257, 1024, 0xe1844c90 |
|
| 315 |
+1, 543347, 1024, 0xbb057b44 |
|
| 316 |
+1, 545437, 1024, 0xa5099687 |
|
| 317 |
+1, 547527, 1024, 0xbff10707 |
|
| 318 |
+1, 549616, 1024, 0x37c4ffc0 |
|
| 319 |
+0, 549990, 7283, 0x19dd7319 |
|
| 320 |
+1, 551706, 1024, 0xf9fb6caa |
|
| 321 |
+1, 553796, 1024, 0x3b6a3a1f |
|
| 322 |
+1, 555886, 1024, 0x83431edb |
|
| 323 |
+1, 557976, 1024, 0x1eb713cf |
|
| 324 |
+0, 559980, 7161, 0x23171d02 |
|
| 325 |
+1, 560065, 1024, 0xd7b07a6d |
|
| 326 |
+1, 562155, 1024, 0x81ae3391 |
|
| 327 |
+1, 564245, 1024, 0xf150130a |
|
| 328 |
+1, 566335, 1024, 0x09678eaa |
|
| 329 |
+1, 568424, 1024, 0xb94e06f1 |
|
| 330 |
+0, 569970, 6976, 0xcc610c26 |
|
| 331 |
+1, 570514, 1024, 0x67b1dbc9 |
|
| 332 |
+1, 572604, 1024, 0xd6edc235 |
|
| 333 |
+1, 574694, 1024, 0x34e4c499 |
|
| 334 |
+1, 576784, 1024, 0xeefd89c0 |
|
| 335 |
+1, 578873, 1024, 0x38afdaf1 |
|
| 336 |
+0, 579960, 7056, 0x6cd917b0 |
|
| 337 |
+1, 580963, 1024, 0x29a60d76 |
|
| 338 |
+1, 583053, 1024, 0xe28a4372 |
|
| 339 |
+1, 585143, 1024, 0x7089454d |
|
| 340 |
+1, 587233, 1024, 0x0c01bb7b |
|
| 341 |
+1, 589322, 1024, 0xbd776a72 |
|
| 342 |
+0, 589950, 6736, 0x02b78951 |
|
| 343 |
+1, 591412, 1024, 0x86776fd0 |
|
| 344 |
+1, 593502, 1024, 0xb37c88f7 |
|
| 345 |
+1, 595592, 1024, 0x5f90aaf8 |
|
| 346 |
+1, 597682, 1024, 0x203d4222 |
|
| 347 |
+1, 599771, 1024, 0x382692a6 |
|
| 348 |
+0, 599940, 6540, 0x767e0854 |
|
| 349 |
+1, 601861, 1024, 0xf37c95fd |
|
| 350 |
+1, 603951, 1024, 0x6c0b8877 |
|
| 351 |
+1, 606041, 1024, 0x2e54a8b6 |
|
| 352 |
+1, 608131, 1024, 0x7f266488 |
|
| 353 |
+0, 609930, 6170, 0xc84962fb |
|
| 354 |
+1, 610220, 1024, 0xfbf20f9a |
|
| 355 |
+1, 612310, 1024, 0xf2985cc0 |
|
| 356 |
+1, 614400, 1024, 0xc7075340 |
|
| 357 |
+1, 616490, 1024, 0xe4585695 |
|
| 358 |
+1, 618580, 1024, 0xbdffa380 |
|
| 359 |
+0, 619920, 6169, 0x27e06c03 |
|
| 360 |
+1, 620669, 1024, 0x2422a8a9 |
|
| 361 |
+1, 622759, 1024, 0x59cbd75f |
|
| 362 |
+1, 624849, 1024, 0x04ad1a8c |
|
| 363 |
+1, 626939, 1024, 0x33c09191 |
|
| 364 |
+1, 629029, 1024, 0x55efa6fd |
|
| 365 |
+0, 630000, 5864, 0xd14db83f |
|
| 366 |
+1, 631118, 1024, 0xf73d0e5d |
|
| 367 |
+1, 633208, 1024, 0x6141ebae |
|
| 368 |
+1, 635298, 1024, 0x7db17a68 |
|
| 369 |
+1, 637388, 1024, 0xa6c690b6 |
|
| 370 |
+1, 639478, 1024, 0xa6fd6725 |
|
| 371 |
+0, 639990, 5375, 0x4a21055d |
|
| 372 |
+1, 641567, 1024, 0x50a90b9b |
|
| 373 |
+1, 643657, 1024, 0xef990dc8 |
|
| 374 |
+1, 645747, 1024, 0x75adf6b5 |
|
| 375 |
+1, 647837, 1024, 0x61eac43e |
|
| 376 |
+1, 649927, 1024, 0x67797a19 |
|
| 377 |
+0, 649980, 5206, 0x95ead3cb |
|
| 378 |
+1, 652016, 1024, 0xf325277a |
|
| 379 |
+1, 654106, 1024, 0x18bf254a |
|
| 380 |
+1, 656196, 1024, 0x2ce6bee3 |
|
| 381 |
+1, 658286, 1024, 0x8d320860 |
|
| 382 |
+0, 659970, 5220, 0xcfdcc37e |
|
| 383 |
+1, 660376, 1024, 0xc979b6e8 |
|
| 384 |
+1, 662465, 1024, 0xdb644b41 |
|
| 385 |
+1, 664555, 1024, 0xe1b368ba |
|
| 386 |
+1, 666645, 1024, 0xacc53d15 |
|
| 387 |
+1, 668735, 1024, 0x42ea8c18 |
|
| 388 |
+0, 669960, 4946, 0x2d864a77 |
|
| 389 |
+1, 670824, 1024, 0xe52c99a4 |
|
| 390 |
+1, 672914, 1024, 0xd7db54a6 |
|
| 391 |
+1, 675004, 1024, 0x7f27a7e3 |
|
| 392 |
+1, 677094, 1024, 0xf7ffeaa9 |
|
| 393 |
+1, 679184, 1024, 0x792b6088 |
|
| 394 |
+0, 679950, 4390, 0x2ab9f462 |
|
| 395 |
+1, 681273, 1024, 0x61d99724 |
|
| 396 |
+1, 683363, 1024, 0x5213720e |
|
| 397 |
+1, 685453, 1024, 0xac09dd30 |
|
| 398 |
+1, 687543, 1024, 0x960bf6bb |
|
| 399 |
+1, 689633, 1024, 0xc90168e1 |
|
| 400 |
+0, 689940, 4051, 0x1d09592e |
|
| 401 |
+1, 691722, 1024, 0x43b45768 |
|
| 402 |
+1, 693812, 1024, 0x935d60a1 |
|
| 403 |
+1, 695902, 1024, 0x9a342ef2 |
|
| 404 |
+1, 697992, 1024, 0xc894709f |
|
| 405 |
+0, 699930, 3680, 0x39bd6a12 |
|
| 406 |
+1, 700082, 1024, 0x59b43b07 |
|
| 407 |
+1, 702171, 1024, 0x36a1a98d |
|
| 408 |
+1, 704261, 1024, 0x9e1a121c |
|
| 409 |
+1, 706351, 1024, 0x02208b78 |
|
| 410 |
+1, 708441, 1024, 0xd1d7b274 |
|
| 411 |
+0, 709920, 2910, 0x6337ece9 |
|
| 412 |
+1, 710531, 1024, 0xdacd5096 |
|
| 413 |
+1, 712620, 1024, 0x51b71ead |
|
| 414 |
+1, 714710, 1024, 0xd009a7ca |
|
| 415 |
+1, 716800, 1024, 0xb6d5a938 |
|
| 416 |
+1, 718890, 1024, 0xf3d45e47 |
|
| 417 |
+0, 720000, 2153, 0xf4e3bc17 |
|
| 418 |
+1, 720980, 1024, 0xea8e04fc |
|
| 419 |
+1, 723069, 1024, 0x0b928bd8 |
|
| 420 |
+1, 725159, 1024, 0x0f02caec |
|
| 421 |
+1, 727249, 1024, 0xe2b137a8 |
|
| 422 |
+1, 729339, 1024, 0xd5f94892 |
| 0 | 423 |
new file mode 100644 |
| ... | ... |
@@ -0,0 +1,120 @@ |
| 0 |
+0, 0, 37440, 0xd1bc5235 |
|
| 1 |
+0, 3750, 37440, 0x158e6167 |
|
| 2 |
+0, 7500, 37440, 0x0faa4481 |
|
| 3 |
+0, 11250, 37440, 0x427158c5 |
|
| 4 |
+0, 15000, 37440, 0x4eb53ac6 |
|
| 5 |
+0, 18750, 37440, 0x99304eea |
|
| 6 |
+0, 22500, 37440, 0xcc554a6f |
|
| 7 |
+0, 26250, 37440, 0xabeb6c35 |
|
| 8 |
+0, 30000, 37440, 0xddfc7e18 |
|
| 9 |
+0, 33750, 37440, 0xaa79b504 |
|
| 10 |
+0, 37500, 37440, 0x5cb1c839 |
|
| 11 |
+0, 41250, 37440, 0x7e36ecca |
|
| 12 |
+0, 45000, 37440, 0xf486f425 |
|
| 13 |
+0, 48750, 37440, 0xf1b4138f |
|
| 14 |
+0, 52500, 37440, 0x966f1a49 |
|
| 15 |
+0, 56250, 37440, 0x5eff21da |
|
| 16 |
+0, 60000, 37440, 0x333f39b1 |
|
| 17 |
+0, 63750, 37440, 0x62e5963e |
|
| 18 |
+0, 67500, 37440, 0x26930671 |
|
| 19 |
+0, 71250, 37440, 0x27b4bb6c |
|
| 20 |
+0, 75000, 37440, 0xdbd07766 |
|
| 21 |
+0, 78750, 37440, 0x04260104 |
|
| 22 |
+0, 82500, 37440, 0x9b1e078b |
|
| 23 |
+0, 86250, 37440, 0xdf4e2474 |
|
| 24 |
+0, 90000, 37440, 0x57d44986 |
|
| 25 |
+0, 93750, 37440, 0x8780e34c |
|
| 26 |
+0, 97500, 37440, 0xf80c8bc0 |
|
| 27 |
+0, 101250, 37440, 0x630a7583 |
|
| 28 |
+0, 105000, 37440, 0x235ae089 |
|
| 29 |
+0, 108750, 37440, 0x984b8f0e |
|
| 30 |
+0, 112500, 37440, 0x865cf592 |
|
| 31 |
+0, 116250, 37440, 0x70f376f2 |
|
| 32 |
+0, 120000, 37440, 0x8b30c035 |
|
| 33 |
+0, 123750, 37440, 0xde772d79 |
|
| 34 |
+0, 127500, 37440, 0x8e076be5 |
|
| 35 |
+0, 131250, 37440, 0x3dc2bd9f |
|
| 36 |
+0, 135000, 37440, 0xb782eb67 |
|
| 37 |
+0, 138750, 37440, 0x02025d73 |
|
| 38 |
+0, 142500, 37440, 0x86bbbce8 |
|
| 39 |
+0, 146250, 37440, 0xd6554f62 |
|
| 40 |
+0, 150000, 37440, 0xb831b917 |
|
| 41 |
+0, 153750, 37440, 0x80643560 |
|
| 42 |
+0, 157500, 37440, 0x4ecf9afd |
|
| 43 |
+0, 161250, 37440, 0x9ce51e0b |
|
| 44 |
+0, 165000, 37440, 0x179466cd |
|
| 45 |
+0, 168750, 37440, 0x145fc900 |
|
| 46 |
+0, 172500, 37440, 0xb1b50402 |
|
| 47 |
+0, 176250, 37440, 0x0a87552a |
|
| 48 |
+0, 180000, 37440, 0x8f53821d |
|
| 49 |
+0, 183750, 37440, 0x1c07c825 |
|
| 50 |
+0, 187500, 37440, 0x49dde82f |
|
| 51 |
+0, 191250, 37440, 0xb1a32605 |
|
| 52 |
+0, 195000, 37440, 0x410f3cd5 |
|
| 53 |
+0, 198750, 37440, 0xff5e6696 |
|
| 54 |
+0, 202500, 37440, 0x96f678c9 |
|
| 55 |
+0, 206250, 37440, 0x6c9e9e68 |
|
| 56 |
+0, 210000, 37440, 0x79a2a655 |
|
| 57 |
+0, 213750, 37440, 0xf237bd6c |
|
| 58 |
+0, 217500, 37440, 0x4051b611 |
|
| 59 |
+0, 221250, 37440, 0xc7ccc918 |
|
| 60 |
+0, 225000, 37440, 0xbd02c122 |
|
| 61 |
+0, 228750, 37440, 0xacb3c881 |
|
| 62 |
+0, 232500, 37440, 0x2abdb940 |
|
| 63 |
+0, 236250, 37440, 0x19d5be85 |
|
| 64 |
+0, 240000, 37440, 0xfa5fb1ba |
|
| 65 |
+0, 243750, 37440, 0xdae7a7aa |
|
| 66 |
+0, 247500, 37440, 0x6b0f9f69 |
|
| 67 |
+0, 251250, 37440, 0x353e8201 |
|
| 68 |
+0, 255000, 37440, 0xa21443aa |
|
| 69 |
+0, 258750, 37440, 0x66c8d7e0 |
|
| 70 |
+0, 262500, 37440, 0xc332068e |
|
| 71 |
+0, 266250, 37440, 0x71431b9b |
|
| 72 |
+0, 270000, 37440, 0x392f15cb |
|
| 73 |
+0, 273750, 37440, 0x95a146bb |
|
| 74 |
+0, 277500, 37440, 0x7c51740a |
|
| 75 |
+0, 281250, 37440, 0xa3bdd43c |
|
| 76 |
+0, 285000, 37440, 0xa079f965 |
|
| 77 |
+0, 288750, 37440, 0xa95423ea |
|
| 78 |
+0, 292500, 37440, 0xd1bd2c67 |
|
| 79 |
+0, 296250, 37440, 0x6cf82844 |
|
| 80 |
+0, 300000, 37440, 0xd401e128 |
|
| 81 |
+0, 303750, 37440, 0x1f7db118 |
|
| 82 |
+0, 307500, 37440, 0x2e0a65a9 |
|
| 83 |
+0, 311250, 37440, 0x321c1c40 |
|
| 84 |
+0, 315000, 37440, 0x95b2a127 |
|
| 85 |
+0, 318750, 37440, 0xa1471f4b |
|
| 86 |
+0, 322500, 37440, 0x29d148c0 |
|
| 87 |
+0, 326250, 37440, 0x24c07107 |
|
| 88 |
+0, 330000, 37440, 0x0ead678d |
|
| 89 |
+0, 333750, 37440, 0xd0ca6495 |
|
| 90 |
+0, 337500, 37440, 0x08f935ef |
|
| 91 |
+0, 341250, 37440, 0xb5ec3c38 |
|
| 92 |
+0, 345000, 37440, 0xce371628 |
|
| 93 |
+0, 348750, 37440, 0x68170812 |
|
| 94 |
+0, 352500, 37440, 0xe222699e |
|
| 95 |
+0, 356250, 37440, 0xd688706c |
|
| 96 |
+0, 360000, 37440, 0x81a033f9 |
|
| 97 |
+0, 363750, 37440, 0x28bd0fbf |
|
| 98 |
+0, 367500, 37440, 0xe36db7b2 |
|
| 99 |
+0, 371250, 37440, 0x30559121 |
|
| 100 |
+0, 375000, 37440, 0xbf2b5fc8 |
|
| 101 |
+0, 378750, 37440, 0x4b427672 |
|
| 102 |
+0, 382500, 37440, 0x0544b0b4 |
|
| 103 |
+0, 386250, 37440, 0x38a70b06 |
|
| 104 |
+0, 390000, 37440, 0x4ed62607 |
|
| 105 |
+0, 393750, 37440, 0x6efe8ea6 |
|
| 106 |
+0, 397500, 37440, 0x81197e11 |
|
| 107 |
+0, 401250, 37440, 0xf4060050 |
|
| 108 |
+0, 405000, 37440, 0xaf205f13 |
|
| 109 |
+0, 408750, 37440, 0x5fa21382 |
|
| 110 |
+0, 412500, 37440, 0x8627ad05 |
|
| 111 |
+0, 416250, 37440, 0xf7130133 |
|
| 112 |
+0, 420000, 37440, 0x76dea7ba |
|
| 113 |
+0, 423750, 37440, 0x1dbae1be |
|
| 114 |
+0, 427500, 37440, 0x74a933f7 |
|
| 115 |
+0, 431250, 37440, 0xbdcd41a3 |
|
| 116 |
+0, 435000, 37440, 0xf0fe8c1c |
|
| 117 |
+0, 438750, 37440, 0xc0036222 |
|
| 118 |
+0, 442500, 37440, 0x3058385c |
|
| 119 |
+0, 446250, 37440, 0x68141016 |
| 0 | 120 |
new file mode 100644 |
| ... | ... |
@@ -0,0 +1,139 @@ |
| 0 |
+1, 0, 576, 0x9b6e1638 |
|
| 1 |
+1, 1620, 576, 0x0ca91183 |
|
| 2 |
+1, 3780, 576, 0xec6a180f |
|
| 3 |
+1, 5940, 576, 0x478a2b9b |
|
| 4 |
+1, 8100, 576, 0x00fa15b3 |
|
| 5 |
+1, 10260, 576, 0xfb551816 |
|
| 6 |
+1, 12960, 576, 0x422e12bd |
|
| 7 |
+1, 15120, 576, 0xa7581b29 |
|
| 8 |
+1, 17280, 576, 0xd4b31a74 |
|
| 9 |
+1, 19440, 576, 0x11521b10 |
|
| 10 |
+1, 21600, 576, 0x3dcc1474 |
|
| 11 |
+1, 23760, 576, 0x66c31aab |
|
| 12 |
+1, 25920, 576, 0x97f318a8 |
|
| 13 |
+1, 28080, 576, 0xd3fb1a30 |
|
| 14 |
+1, 30240, 576, 0xd2bd16af |
|
| 15 |
+1, 32400, 576, 0x6c10146a |
|
| 16 |
+1, 34560, 576, 0x10d81468 |
|
| 17 |
+1, 36720, 576, 0x3813162d |
|
| 18 |
+1, 38880, 576, 0x89e71d95 |
|
| 19 |
+1, 41040, 576, 0xd1c717f9 |
|
| 20 |
+1, 43200, 576, 0x1a311e5f |
|
| 21 |
+1, 45360, 576, 0x0ea80e05 |
|
| 22 |
+1, 47520, 576, 0x2f1718f2 |
|
| 23 |
+1, 49680, 576, 0xffe01e13 |
|
| 24 |
+1, 51840, 576, 0xa7b02296 |
|
| 25 |
+1, 54000, 576, 0x199f1597 |
|
| 26 |
+1, 56160, 576, 0xdea217ba |
|
| 27 |
+1, 58320, 576, 0x8a790f01 |
|
| 28 |
+1, 60480, 576, 0x23e80038 |
|
| 29 |
+1, 62640, 576, 0x75dc048a |
|
| 30 |
+1, 64800, 576, 0xeb4b0d93 |
|
| 31 |
+1, 66960, 576, 0xde1322f5 |
|
| 32 |
+1, 69120, 576, 0xc3131f35 |
|
| 33 |
+1, 71280, 576, 0x708f1381 |
|
| 34 |
+1, 73440, 576, 0x1f00137e |
|
| 35 |
+0, 74578, 41980, 0xd4920915 |
|
| 36 |
+1, 75600, 576, 0x05131eb0 |
|
| 37 |
+1, 77760, 576, 0x78151c22 |
|
| 38 |
+0, 78178, 7228, 0x1b141fa3 |
|
| 39 |
+1, 79920, 576, 0x31771239 |
|
| 40 |
+0, 81777, 7492, 0x1a47f3e4 |
|
| 41 |
+1, 82080, 576, 0x3ce4097c |
|
| 42 |
+1, 84240, 576, 0x180e15f4 |
|
| 43 |
+0, 85378, 25068, 0xcb70a744 |
|
| 44 |
+1, 86400, 576, 0x30db0604 |
|
| 45 |
+1, 88560, 576, 0x9b290284 |
|
| 46 |
+0, 88978, 7212, 0x0ab9f558 |
|
| 47 |
+1, 90720, 576, 0xcf340753 |
|
| 48 |
+0, 92578, 7612, 0xa93054f0 |
|
| 49 |
+1, 92880, 576, 0xdaa41457 |
|
| 50 |
+1, 95040, 576, 0x34d310a2 |
|
| 51 |
+0, 96177, 22868, 0xa77db64a |
|
| 52 |
+1, 97200, 576, 0x58b31010 |
|
| 53 |
+1, 99360, 576, 0x19610f54 |
|
| 54 |
+0, 99778, 6260, 0x6cf76411 |
|
| 55 |
+1, 101520, 576, 0x17762352 |
|
| 56 |
+0, 103377, 6156, 0xe168394b |
|
| 57 |
+1, 103680, 576, 0x1fea1448 |
|
| 58 |
+1, 105840, 576, 0x55840a01 |
|
| 59 |
+0, 106977, 23364, 0x53164f1e |
|
| 60 |
+1, 108000, 576, 0x6c9c24ce |
|
| 61 |
+1, 110160, 576, 0x955f1e97 |
|
| 62 |
+0, 110578, 6708, 0x89877269 |
|
| 63 |
+1, 112320, 576, 0x2827134f |
|
| 64 |
+0, 114178, 6908, 0x8d62a249 |
|
| 65 |
+1, 114480, 576, 0x34a01c29 |
|
| 66 |
+1, 116640, 576, 0x7d351e52 |
|
| 67 |
+0, 117778, 38156, 0xec41f682 |
|
| 68 |
+1, 118800, 576, 0x00c91d9e |
|
| 69 |
+1, 120960, 576, 0x57ea1a97 |
|
| 70 |
+0, 121377, 5764, 0xcc04534b |
|
| 71 |
+1, 123120, 576, 0xef3a1c74 |
|
| 72 |
+0, 124977, 5388, 0xb8a1c3c5 |
|
| 73 |
+1, 125280, 576, 0x11fc217d |
|
| 74 |
+1, 127440, 576, 0x59ce20e5 |
|
| 75 |
+0, 128578, 16764, 0x59460d96 |
|
| 76 |
+1, 129600, 576, 0xaafc1dbf |
|
| 77 |
+1, 131760, 576, 0xdd941609 |
|
| 78 |
+0, 132177, 5548, 0x5c91e93d |
|
| 79 |
+1, 133920, 576, 0x900420b0 |
|
| 80 |
+0, 135777, 5652, 0x5e321aed |
|
| 81 |
+1, 136080, 576, 0x5f4f1aa1 |
|
| 82 |
+1, 138240, 576, 0x7d7e18de |
|
| 83 |
+0, 139377, 15564, 0xefdf5080 |
|
| 84 |
+1, 140400, 576, 0x986c0d9d |
|
| 85 |
+1, 142560, 576, 0xcb4c21c0 |
|
| 86 |
+0, 142977, 6492, 0xd1d5c5f8 |
|
| 87 |
+1, 144720, 576, 0xbcfb1e8b |
|
| 88 |
+0, 146577, 5604, 0xf9472b44 |
|
| 89 |
+1, 146880, 576, 0xcb541b4c |
|
| 90 |
+1, 149040, 576, 0x980426e9 |
|
| 91 |
+0, 150177, 17924, 0x45815b7b |
|
| 92 |
+1, 151200, 576, 0x09d00aa0 |
|
| 93 |
+1, 153360, 576, 0xad591374 |
|
| 94 |
+0, 153778, 5020, 0x3cc5e554 |
|
| 95 |
+1, 155520, 576, 0x97bf1461 |
|
| 96 |
+0, 157378, 5276, 0xa0554c12 |
|
| 97 |
+1, 157680, 576, 0xdc871cc4 |
|
| 98 |
+1, 159840, 576, 0x56781896 |
|
| 99 |
+0, 160977, 31460, 0x5765eb5f |
|
| 100 |
+1, 162000, 576, 0xc77714e3 |
|
| 101 |
+1, 164160, 576, 0x280e18d4 |
|
| 102 |
+0, 164577, 4972, 0x91adbab7 |
|
| 103 |
+1, 166320, 576, 0xbc0d2302 |
|
| 104 |
+0, 168178, 5580, 0xfea707cb |
|
| 105 |
+1, 168480, 576, 0x79191384 |
|
| 106 |
+1, 170640, 576, 0x65481c97 |
|
| 107 |
+0, 171778, 17412, 0x0afe4d27 |
|
| 108 |
+1, 172800, 576, 0xc94d227d |
|
| 109 |
+1, 174960, 576, 0xa68a1f14 |
|
| 110 |
+0, 175378, 5236, 0x03f55309 |
|
| 111 |
+1, 177120, 576, 0x6af11a5c |
|
| 112 |
+0, 178977, 4924, 0x558e753c |
|
| 113 |
+1, 179280, 576, 0x4d1019ef |
|
| 114 |
+1, 181440, 576, 0x3b1b17b5 |
|
| 115 |
+0, 182577, 15396, 0xf145d121 |
|
| 116 |
+1, 183600, 576, 0xcdd8159f |
|
| 117 |
+1, 185760, 576, 0x97cd1d06 |
|
| 118 |
+0, 186177, 4708, 0x43066a92 |
|
| 119 |
+1, 187920, 576, 0x5d1b1123 |
|
| 120 |
+0, 189778, 4332, 0x9e22bcba |
|
| 121 |
+1, 190080, 576, 0x888d0cb0 |
|
| 122 |
+1, 192240, 576, 0x556e1dad |
|
| 123 |
+0, 193377, 12876, 0x46ff9ef4 |
|
| 124 |
+1, 194400, 576, 0xf7af0bce |
|
| 125 |
+1, 196560, 576, 0xb5da160a |
|
| 126 |
+0, 196978, 5940, 0x27cba62e |
|
| 127 |
+1, 198720, 576, 0x4a8d0e98 |
|
| 128 |
+0, 200578, 6124, 0x6bab0a6d |
|
| 129 |
+1, 200880, 576, 0x183b1c7e |
|
| 130 |
+1, 203040, 576, 0xc47120e6 |
|
| 131 |
+0, 204178, 36428, 0x942f9648 |
|
| 132 |
+1, 205200, 576, 0xb1f31346 |
|
| 133 |
+0, 207777, 6660, 0x545a0db7 |
|
| 134 |
+0, 211377, 6780, 0x2d1d4189 |
|
| 135 |
+0, 214978, 16460, 0x7c3b3ca4 |
|
| 136 |
+0, 218578, 6724, 0x8538cc6f |
|
| 137 |
+0, 222178, 7068, 0x69574fd0 |
|
| 138 |
+0, 225777, 19552, 0xf230e854 |
| ... | ... |
@@ -4,6 +4,8 @@ abgr 037bf9df6a765520ad6d490066bf4b89 |
| 4 | 4 |
argb c442a8261c2265a07212ef0f72e35f5a |
| 5 | 5 |
bgr0 0ef8ffe42bfe53be74973a0c118b775e |
| 6 | 6 |
bgr24 0d0cb38ab3fa0b2ec0865c14f78b217b |
| 7 |
+bgr444be d9ea9307d21b162225b8b2c524cf9477 |
|
| 8 |
+bgr444le 88035350e9da3a8f67387890b956f0bc |
|
| 7 | 9 |
bgr48be 00624e6c7ec7ab19897ba2f0a3257fe8 |
| 8 | 10 |
bgr48le d02c235ebba7167881ca2d576497ff84 |
| 9 | 11 |
bgr4_byte 50d23cc82d9dcef2fd12adb81fb9b806 |
| ... | ... |
@@ -22,6 +24,8 @@ nv12 e0af357888584d36eec5aa0f673793ef |
| 22 | 22 |
nv21 9a3297f3b34baa038b1f37cb202b512f |
| 23 | 23 |
rgb0 7c03f81f5e5346bf8ea42c4187f20605 |
| 24 | 24 |
rgb24 b41eba9651e1b5fe386289b506188105 |
| 25 |
+rgb444be 9e89db334568c6b2e3d5d0540f4ba960 |
|
| 26 |
+rgb444le 0a68cb6de8bf530aa30c5c1205c25155 |
|
| 25 | 27 |
rgb48be cc139ec1dd9451f0e049c0cb3a0c8aa2 |
| 26 | 28 |
rgb48le 86c5608904f75360d492dbc5c9589969 |
| 27 | 29 |
rgb4_byte c93ba89b74c504e7f5ae9d9ab1546c73 |
| ... | ... |
@@ -4,6 +4,8 @@ abgr 037bf9df6a765520ad6d490066bf4b89 |
| 4 | 4 |
argb c442a8261c2265a07212ef0f72e35f5a |
| 5 | 5 |
bgr0 328a76e72c55508cdf04dc93a5b056fc |
| 6 | 6 |
bgr24 0d0cb38ab3fa0b2ec0865c14f78b217b |
| 7 |
+bgr444be d9ea9307d21b162225b8b2c524cf9477 |
|
| 8 |
+bgr444le 88035350e9da3a8f67387890b956f0bc |
|
| 7 | 9 |
bgr48be 00624e6c7ec7ab19897ba2f0a3257fe8 |
| 8 | 10 |
bgr48le d02c235ebba7167881ca2d576497ff84 |
| 9 | 11 |
bgr4_byte 50d23cc82d9dcef2fd12adb81fb9b806 |
| ... | ... |
@@ -23,6 +25,8 @@ nv21 9a3297f3b34baa038b1f37cb202b512f |
| 23 | 23 |
pal8 dec8ed2258ec89b8a796f21cad4df867 |
| 24 | 24 |
rgb0 ff1a9f355d43f9d25f07a191b5aa906c |
| 25 | 25 |
rgb24 b41eba9651e1b5fe386289b506188105 |
| 26 |
+rgb444be 9e89db334568c6b2e3d5d0540f4ba960 |
|
| 27 |
+rgb444le 0a68cb6de8bf530aa30c5c1205c25155 |
|
| 26 | 28 |
rgb48be cc139ec1dd9451f0e049c0cb3a0c8aa2 |
| 27 | 29 |
rgb48le 86c5608904f75360d492dbc5c9589969 |
| 28 | 30 |
rgb4_byte c93ba89b74c504e7f5ae9d9ab1546c73 |
| ... | ... |
@@ -4,6 +4,8 @@ abgr 037bf9df6a765520ad6d490066bf4b89 |
| 4 | 4 |
argb c442a8261c2265a07212ef0f72e35f5a |
| 5 | 5 |
bgr0 328a76e72c55508cdf04dc93a5b056fc |
| 6 | 6 |
bgr24 0d0cb38ab3fa0b2ec0865c14f78b217b |
| 7 |
+bgr444be d9ea9307d21b162225b8b2c524cf9477 |
|
| 8 |
+bgr444le 88035350e9da3a8f67387890b956f0bc |
|
| 7 | 9 |
bgr48be 00624e6c7ec7ab19897ba2f0a3257fe8 |
| 8 | 10 |
bgr48le d02c235ebba7167881ca2d576497ff84 |
| 9 | 11 |
bgr4_byte 50d23cc82d9dcef2fd12adb81fb9b806 |
| ... | ... |
@@ -23,6 +25,8 @@ nv21 9a3297f3b34baa038b1f37cb202b512f |
| 23 | 23 |
pal8 dec8ed2258ec89b8a796f21cad4df867 |
| 24 | 24 |
rgb0 ff1a9f355d43f9d25f07a191b5aa906c |
| 25 | 25 |
rgb24 b41eba9651e1b5fe386289b506188105 |
| 26 |
+rgb444be 9e89db334568c6b2e3d5d0540f4ba960 |
|
| 27 |
+rgb444le 0a68cb6de8bf530aa30c5c1205c25155 |
|
| 26 | 28 |
rgb48be cc139ec1dd9451f0e049c0cb3a0c8aa2 |
| 27 | 29 |
rgb48le 86c5608904f75360d492dbc5c9589969 |
| 28 | 30 |
rgb4_byte c93ba89b74c504e7f5ae9d9ab1546c73 |
| ... | ... |
@@ -4,6 +4,8 @@ abgr cff82561a074874027ac1cc896fd2730 |
| 4 | 4 |
argb 756dd1eaa5baca2238ce23dbdc452684 |
| 5 | 5 |
bgr0 ff6e1dfa26d4c2ada3a59e8b0b600d1f |
| 6 | 6 |
bgr24 e44192347a45586c6c157e3059610cd1 |
| 7 |
+bgr444be c23768338d76693f0da76e8a9b6fd8df |
|
| 8 |
+bgr444le 846c431a47bfb745437941bde768469c |
|
| 7 | 9 |
bgr48be 390d3058a12a99c2b153ed7922508bea |
| 8 | 10 |
bgr48le 39fe06feb4ec1d9730dccc04a0cfac4c |
| 9 | 11 |
bgr4_byte ee1d35a7baf8e9016891929a2f565c0b |
| ... | ... |
@@ -23,6 +25,8 @@ nv21 69c699510ff1fb777b118ebee1002f14 |
| 23 | 23 |
pal8 6324fa058e1bc157ed7132bfe4022317 |
| 24 | 24 |
rgb0 1bd6f54ad067503ac9783a70062c8f87 |
| 25 | 25 |
rgb24 13ff53ebeab74dc05492836f1cfbd2c1 |
| 26 |
+rgb444be 46e466b2709f62b2fffc63708063eaaf |
|
| 27 |
+rgb444le f0c57a48be671428e2e53c9b54a6c4e2 |
|
| 26 | 28 |
rgb48be 8fac63787a711886030f8e056872b488 |
| 27 | 29 |
rgb48le ab92f2763a2eb264c3870cc758f97149 |
| 28 | 30 |
rgb4_byte d81ffd3add95842a618eec81024f0b5c |
| ... | ... |
@@ -4,6 +4,8 @@ abgr 25e72e9dbd01ab00727c976d577f7be5 |
| 4 | 4 |
argb 19869bf1a5ac0b6af4d8bbe2c104533c |
| 5 | 5 |
bgr0 e03d3ee0b977f6d86e5116b20494bef5 |
| 6 | 6 |
bgr24 89108a4ba00201f79b75b9305c42352d |
| 7 |
+bgr444be 9ef12c42fb791948ca4423c452dc6b9a |
|
| 8 |
+bgr444le 3650ecfc163abd1596c0cd29d130c4b0 |
|
| 7 | 9 |
bgr48be 2f23931844f57641f3737348182d118c |
| 8 | 10 |
bgr48le 4242a026012b6c135a6aa138a6d67031 |
| 9 | 11 |
bgr4_byte 407fcf564ed764c38e1d748f700ab921 |
| ... | ... |
@@ -23,6 +25,8 @@ nv21 01ea369dd2d0d3ed7451dc5c8d61497f |
| 23 | 23 |
pal8 47ed19a7e128b0e33c25d2a463b0611a |
| 24 | 24 |
rgb0 330bd6168e46c0d5eb4acbdbb50afa2e |
| 25 | 25 |
rgb24 eaefabc168d0b14576bab45bc1e56e1e |
| 26 |
+rgb444be 06722e03f8404e7d2226665ed2444a32 |
|
| 27 |
+rgb444le 185c9a5d9c2877484310d4196ef4cd6f |
|
| 26 | 28 |
rgb48be 62dd185862ed142283bd300eb6dbd216 |
| 27 | 29 |
rgb48le dcb76353268bc5862194d131762220da |
| 28 | 30 |
rgb4_byte 8c6ff02df0b06dd2d574836c3741b2a2 |