Mercurial > libavcodec.hg

comparison vc1.c @ 3378:d7dda9fd99c8 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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;