Mercurial > libavcodec.hg
comparison vc1.c @ 3378:d7dda9fd99c8 libavcodec
Adjust AC prediction if (some) predictors are not available.
author | kostya |
---|---|
date | Sat, 01 Jul 2006 07:22:29 +0000 |
parents | dc4813852345 |
children | 3f43459705a5 |
comparison
equal
deleted
inserted
replaced
3377:dc4813852345 | 3378:d7dda9fd99c8 |
---|---|
1890 { | 1890 { |
1891 int last = 0, skip, value; | 1891 int last = 0, skip, value; |
1892 const int8_t *zz_table; | 1892 const int8_t *zz_table; |
1893 int scale; | 1893 int scale; |
1894 int k; | 1894 int k; |
1895 int use_pred = s->ac_pred; | |
1895 | 1896 |
1896 scale = mquant * 2; | 1897 scale = mquant * 2; |
1897 | 1898 |
1898 zz_table = vc1_simple_progressive_8x8_zz; | 1899 zz_table = vc1_simple_progressive_8x8_zz; |
1899 | 1900 |
1900 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; | 1901 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
1901 ac_val2 = ac_val; | 1902 ac_val2 = ac_val; |
1903 if(!a_avail) dc_pred_dir = 1; | |
1904 if(!c_avail) dc_pred_dir = 0; | |
1905 if(!a_avail && !c_avail) use_pred = 0; | |
1906 | |
1902 if(dc_pred_dir) //left | 1907 if(dc_pred_dir) //left |
1903 ac_val -= 16; | 1908 ac_val -= 16; |
1904 else //top | 1909 else //top |
1905 ac_val -= 16 * s->block_wrap[n]; | 1910 ac_val -= 16 * s->block_wrap[n]; |
1906 | 1911 |
1911 break; | 1916 break; |
1912 block[zz_table[i++]] = value; | 1917 block[zz_table[i++]] = value; |
1913 } | 1918 } |
1914 | 1919 |
1915 /* apply AC prediction if needed */ | 1920 /* apply AC prediction if needed */ |
1916 if(s->ac_pred && (v->a_avail || v->c_avail)) { | 1921 if(use_pred) { |
1917 /* scale predictors if needed*/ | 1922 /* scale predictors if needed*/ |
1918 int mb_pos2, q1, q2; | 1923 int mb_pos2, q1, q2; |
1919 | 1924 |
1920 mb_pos2 = mb_pos - dc_pred_dir - (1 - dc_pred_dir) * s->mb_stride; | 1925 mb_pos2 = mb_pos - dc_pred_dir - (1 - dc_pred_dir) * s->mb_stride; |
1921 q1 = s->current_picture.qscale_table[mb_pos]; | 1926 q1 = s->current_picture.qscale_table[mb_pos]; |
1922 q2 = s->current_picture.qscale_table[mb_pos2]; | 1927 q2 = s->current_picture.qscale_table[mb_pos2]; |
1923 | 1928 |
1924 if(!c_avail) { | |
1925 memset(ac_val, 0, 8 * sizeof(ac_val[0])); | |
1926 dc_pred_dir = 0; | |
1927 } | |
1928 if(!a_avail) { | |
1929 memset(ac_val + 8, 0, 8 * sizeof(ac_val[0])); | |
1930 dc_pred_dir = 1; | |
1931 } | |
1932 if(q2 && q1 != q2) { | 1929 if(q2 && q1 != q2) { |
1933 q1 = q1 * 2 - 1; | 1930 q1 = q1 * 2 - 1; |
1934 q2 = q2 * 2 - 1; | 1931 q2 = q2 * 2 - 1; |
1935 | 1932 |
1936 if(dc_pred_dir) { //left | 1933 if(dc_pred_dir) { //left |
1962 block[k] *= scale; | 1959 block[k] *= scale; |
1963 if(!v->pquantizer) | 1960 if(!v->pquantizer) |
1964 block[k] += (block[k] < 0) ? -mquant : mquant; | 1961 block[k] += (block[k] < 0) ? -mquant : mquant; |
1965 } | 1962 } |
1966 | 1963 |
1967 if(s->ac_pred) i = 63; | 1964 if(use_pred) i = 63; |
1968 } | 1965 } |
1969 | 1966 |
1970 not_coded: | 1967 not_coded: |
1971 if(!coded) { | 1968 if(!coded) { |
1972 int k, scale; | 1969 int k, scale; |
1970 int use_pred = s->ac_pred; | |
1971 | |
1973 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; | 1972 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; |
1974 ac_val2 = ac_val; | 1973 ac_val2 = ac_val; |
1975 | 1974 |
1976 if(!c_avail) { | 1975 if(!c_avail) { |
1977 memset(ac_val, 0, 8 * sizeof(ac_val[0])); | 1976 memset(ac_val, 0, 8 * sizeof(ac_val[0])); |
1979 } | 1978 } |
1980 if(!a_avail) { | 1979 if(!a_avail) { |
1981 memset(ac_val + 8, 0, 8 * sizeof(ac_val[0])); | 1980 memset(ac_val + 8, 0, 8 * sizeof(ac_val[0])); |
1982 dc_pred_dir = 1; | 1981 dc_pred_dir = 1; |
1983 } | 1982 } |
1983 | |
1984 if(!a_avail && !c_avail) use_pred = 0; | |
1984 | 1985 |
1985 scale = mquant * 2; | 1986 scale = mquant * 2; |
1986 memset(ac_val2, 0, 16 * 2); | 1987 memset(ac_val2, 0, 16 * 2); |
1987 if(dc_pred_dir) {//left | 1988 if(dc_pred_dir) {//left |
1988 ac_val -= 16; | 1989 ac_val -= 16; |
1989 if(s->ac_pred && (v->a_avail || v->c_avail)) | 1990 if(use_pred) |
1990 memcpy(ac_val2, ac_val, 8 * 2); | 1991 memcpy(ac_val2, ac_val, 8 * 2); |
1991 } else {//top | 1992 } else {//top |
1992 ac_val -= 16 * s->block_wrap[n]; | 1993 ac_val -= 16 * s->block_wrap[n]; |
1993 if(s->ac_pred && (v->a_avail || v->c_avail)) | 1994 if(use_pred) |
1994 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2); | 1995 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2); |
1995 } | 1996 } |
1996 | 1997 |
1997 /* apply AC prediction if needed */ | 1998 /* apply AC prediction if needed */ |
1998 if(s->ac_pred && (v->a_avail || v->c_avail)) { | 1999 if(use_pred) { |
1999 if(dc_pred_dir) { //left | 2000 if(dc_pred_dir) { //left |
2000 for(k = 1; k < 8; k++) { | 2001 for(k = 1; k < 8; k++) { |
2001 block[k << 3] = ac_val[k] * scale; | 2002 block[k << 3] = ac_val[k] * scale; |
2002 if(!v->pquantizer) | 2003 if(!v->pquantizer) |
2003 block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant; | 2004 block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant; |