RepoMirrors
/
ffmpeg
mirror of https://git.ffmpeg.org/ffmpeg.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

intrax8: K&R formatting cosmetics

This commit is contained in:
Vittorio Giovara 2016-02-24 17:45:11 -05:00
parent 6f5ff559db
commit 2ade1cdafb
5 changed files with 1797 additions and 1658 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

322
libavcodec/intrax8.c
View File

@ -30,7 +30,8 @@
#include "intrax8.h" #include "intrax8.h"
#include "intrax8dsp.h" #include "intrax8dsp.h"
#define MAX_TABLE_DEPTH(table_bits, max_bits) ((max_bits+table_bits-1)/table_bits) #define MAX_TABLE_DEPTH(table_bits, max_bits) \
((max_bits + table_bits - 1) / table_bits)
#define DC_VLC_BITS 9 #define DC_VLC_BITS 9
#define AC_VLC_BITS 9 #define AC_VLC_BITS 9
@ -44,7 +45,8 @@ static VLC j_ac_vlc[2][2][8]; //[quant<13],[intra/inter],[select]
static VLC j_dc_vlc[2][8]; // [quant], [select] static VLC j_dc_vlc[2][8]; // [quant], [select]
static VLC j_orient_vlc[2][4]; // [quant], [select] static VLC j_orient_vlc[2][4]; // [quant], [select]
static av_cold void x8_vlc_init(void){ static av_cold void x8_vlc_init(void)
{
int i; int i;
int offset = 0; int offset = 0;
int sizeidx = 0; int sizeidx = 0;
@ -57,21 +59,21 @@ static av_cold void x8_vlc_init(void){
528, 528, 526, 528, 536, 528, 526, 544, 528, 528, 526, 528, 536, 528, 526, 544,
544, 512, 512, 528, 528, 544, 512, 544, 544, 512, 512, 528, 528, 544, 512, 544,
128, 128, 128, 128, 128, 128}; 128, 128, 128, 128, 128, 128,
};
static VLC_TYPE table[28150][2]; static VLC_TYPE table[28150][2];
#define init_ac_vlc(dst,src) do { \ // set ac tables
#define init_ac_vlc(dst, src) \
do { \
dst.table = &table[offset]; \ dst.table = &table[offset]; \
dst.table_allocated = sizes[sizeidx]; \ dst.table_allocated = sizes[sizeidx]; \
offset += sizes[sizeidx++]; \ offset += sizes[sizeidx++]; \
init_vlc(&dst, \ init_vlc(&dst, AC_VLC_BITS, 77, &src[1], 4, 2, &src[0], 4, 2, \
AC_VLC_BITS,77, \
&src[1],4,2, \
&src[0],4,2, \
INIT_VLC_USE_NEW_STATIC); \ INIT_VLC_USE_NEW_STATIC); \
} while(0) } while(0)
//set ac tables
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
init_ac_vlc(j_ac_vlc[0][0][i], x8_ac0_highquant_table[i][0]); init_ac_vlc(j_ac_vlc[0][0][i], x8_ac0_highquant_table[i][0]);
init_ac_vlc(j_ac_vlc[0][1][i], x8_ac1_highquant_table[i][0]); init_ac_vlc(j_ac_vlc[0][1][i], x8_ac1_highquant_table[i][0]);
@ -81,16 +83,15 @@ static av_cold void x8_vlc_init(void){
#undef init_ac_vlc #undef init_ac_vlc
// set dc tables // set dc tables
#define init_dc_vlc(dst,src) do { \ #define init_dc_vlc(dst, src) \
do { \
dst.table = &table[offset]; \ dst.table = &table[offset]; \
dst.table_allocated = sizes[sizeidx]; \ dst.table_allocated = sizes[sizeidx]; \
offset += sizes[sizeidx++]; \ offset += sizes[sizeidx++]; \
init_vlc(&dst, \ init_vlc(&dst, DC_VLC_BITS, 34, &src[1], 4, 2, &src[0], 4, 2, \
DC_VLC_BITS,34, \
&src[1],4,2, \
&src[0],4,2, \
INIT_VLC_USE_NEW_STATIC); \ INIT_VLC_USE_NEW_STATIC); \
} while(0) } while(0)
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
init_dc_vlc(j_dc_vlc[0][i], x8_dc_highquant_table[i][0]); init_dc_vlc(j_dc_vlc[0][i], x8_dc_highquant_table[i][0]);
init_dc_vlc(j_dc_vlc[1][i], x8_dc_lowquant_table[i][0]); init_dc_vlc(j_dc_vlc[1][i], x8_dc_lowquant_table[i][0]);
@ -98,53 +99,56 @@ static av_cold void x8_vlc_init(void){
#undef init_dc_vlc #undef init_dc_vlc
// set orient tables // set orient tables
#define init_or_vlc(dst,src) do { \ #define init_or_vlc(dst, src) \
do { \
dst.table = &table[offset]; \ dst.table = &table[offset]; \
dst.table_allocated = sizes[sizeidx]; \ dst.table_allocated = sizes[sizeidx]; \
offset += sizes[sizeidx++]; \ offset += sizes[sizeidx++]; \
init_vlc(&dst, \ init_vlc(&dst, OR_VLC_BITS, 12, &src[1], 4, 2, &src[0], 4, 2, \
OR_VLC_BITS,12, \
&src[1],4,2, \
&src[0],4,2, \
INIT_VLC_USE_NEW_STATIC); \ INIT_VLC_USE_NEW_STATIC); \
} while(0) } while(0)
for(i=0;i<2;i++){
for (i = 0; i < 2; i++)
init_or_vlc(j_orient_vlc[0][i], x8_orient_highquant_table[i][0]); init_or_vlc(j_orient_vlc[0][i], x8_orient_highquant_table[i][0]);
} for (i = 0; i < 4; i++)
for(i=0;i<4;i++){
init_or_vlc(j_orient_vlc[1][i], x8_orient_lowquant_table[i][0]); init_or_vlc(j_orient_vlc[1][i], x8_orient_lowquant_table[i][0]);
} #undef init_or_vlc
if (offset != sizeof(table)/sizeof(VLC_TYPE)/2) if (offset != sizeof(table)/sizeof(VLC_TYPE)/2)
av_log(NULL, AV_LOG_ERROR, "table size %zd does not match needed %i\n", av_log(NULL, AV_LOG_ERROR, "table size %zd does not match needed %i\n",
sizeof(table) / sizeof(VLC_TYPE) / 2, offset); sizeof(table) / sizeof(VLC_TYPE) / 2, offset);
} }
#undef init_or_vlc
static void x8_reset_vlc_tables(IntraX8Context * w){ static void x8_reset_vlc_tables(IntraX8Context *w)
{
memset(w->j_dc_vlc, 0, sizeof(w->j_dc_vlc)); memset(w->j_dc_vlc, 0, sizeof(w->j_dc_vlc));
memset(w->j_ac_vlc, 0, sizeof(w->j_ac_vlc)); memset(w->j_ac_vlc, 0, sizeof(w->j_ac_vlc));
w->j_orient_vlc = NULL; w->j_orient_vlc = NULL;
} }
static inline void x8_select_ac_table(IntraX8Context * const w , int mode){ static inline void x8_select_ac_table(IntraX8Context *const w, int mode)
{
MpegEncContext *const s = w->s; MpegEncContext *const s = w->s;
int table_index; int table_index;
assert(mode < 4); assert(mode < 4);
if( w->j_ac_vlc[mode] ) return; if (w->j_ac_vlc[mode])
return;
table_index = get_bits(&s->gb, 3); table_index = get_bits(&s->gb, 3);
w->j_ac_vlc[mode] = &j_ac_vlc[w->quant<13][mode>>1][table_index];//2 modes use same tables // 2 modes use same tables
w->j_ac_vlc[mode] = &j_ac_vlc[w->quant < 13][mode >> 1][table_index];
assert(w->j_ac_vlc[mode]); assert(w->j_ac_vlc[mode]);
} }
static inline int x8_get_orient_vlc(IntraX8Context * w){ static inline int x8_get_orient_vlc(IntraX8Context *w)
{
MpegEncContext *const s = w->s; MpegEncContext *const s = w->s;
int table_index;
if (!w->j_orient_vlc) { if (!w->j_orient_vlc) {
table_index = get_bits(&s->gb, 1+(w->quant<13) ); int table_index = get_bits(&s->gb, 1 + (w->quant < 13));
w->j_orient_vlc = &j_orient_vlc[w->quant < 13][table_index]; w->j_orient_vlc = &j_orient_vlc[w->quant < 13][table_index];
} }
assert(w->j_orient_vlc); assert(w->j_orient_vlc);
@ -201,7 +205,8 @@ static const uint32_t ac_decode_table[]={
#undef level_offset #undef level_offset
static void x8_get_ac_rlf(IntraX8Context *const w, const int mode, static void x8_get_ac_rlf(IntraX8Context *const w, const int mode,
int * const run, int * const level, int * const final){ int *const run, int *const level, int *const final)
{
MpegEncContext *const s = w->s; MpegEncContext *const s = w->s;
int i, e; int i, e;
@ -211,21 +216,29 @@ static void x8_get_ac_rlf(IntraX8Context * const w, const int mode,
if (i < 46) { // [0-45] if (i < 46) { // [0-45]
int t, l; int t, l;
if (i < 0) { if (i < 0) {
(*level)=(*final)=//prevent 'may be used unilitialized' (*level) =
(*final) = // prevent 'may be used unilitialized'
(*run) = 64; // this would cause error exit in the ac loop (*run) = 64; // this would cause error exit in the ac loop
return; return;
} }
(*final) = t = (i>22);
i-=23*t;
/* /*
i== 0-15 r=0-15 l=0 ;r=i& %01111 * i == 0-15 r = 0-15 l = 0; r = i & %01111
i==16-19 r=0-3 l=1 ;r=i& %00011 * i == 16-19 r = 0-3 l = 1; r = i & %00011
i==20-21 r=0-1 l=2 ;r=i& %00001 * i == 20-21 r = 0-1 l = 2; r = i & %00001
i==22 r=0 l=3 ;r=i& %00000 * i == 22 r = 0 l = 3; r = i & %00000
l=lut_l[i/2]={0,0,0,0,0,0,0,0,1,1,2,3}[i>>1];// 11 10'01 01'00 00'00 00'00 00'00 00 => 0xE50000 */
t=lut_mask[l]={0x0f,0x03,0x01,0x00}[l]; as i<256 the higher bits do not matter */
l=(0xE50000>>(i&(0x1E)))&3;/*0x1E or (~1) or ((i>>1)<<1)*/ (*final) =
t = (i > 22);
i -= 23 * t;
/* l = lut_l[i / 2] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3 }[i >> 1];
* 11 10'01 01'00 00'00 00'00 00'00 00 => 0xE50000 */
l = (0xE50000 >> (i & (0x1E))) & 3; // 0x1E or (~1) or ((i >> 1) << 1)
/* t = lut_mask[l] = { 0x0f, 0x03, 0x01, 0x00 }[l];
* as i < 256 the higher bits do not matter */
t = (0x01030F >> (l << 3)); t = (0x01030F >> (l << 3));
(*run) = i & t; (*run) = i & t;
@ -237,8 +250,10 @@ t=lut_mask[l]={0x0f,0x03,0x01,0x00}[l]; as i<256 the higher bits do not matter *
i -= 46; i -= 46;
sm = ac_decode_table[i]; sm = ac_decode_table[i];
e=get_bits(&s->gb,sm&0xF);sm>>=8;//3bits e = get_bits(&s->gb, sm & 0xF);
mask=sm&0xff;sm>>=8; //1bit sm >>= 8; // 3bits
mask = sm & 0xff;
sm >>= 8; // 1bit
(*run) = (sm & 0xff) + (e & (mask)); // 6bits (*run) = (sm & 0xff) + (e & (mask)); // 6bits
(*level) = (sm >> 8) + (e & (~mask)); // 5bits (*level) = (sm >> 8) + (e & (~mask)); // 5bits
@ -248,7 +263,8 @@ t=lut_mask[l]={0x0f,0x03,0x01,0x00}[l]; as i<256 the higher bits do not matter *
0x22, 0x32, 0x33, 0x53, 0x23, 0x42, 0x43, 0x63, 0x22, 0x32, 0x33, 0x53, 0x23, 0x42, 0x43, 0x63,
0x24, 0x52, 0x34, 0x73, 0x25, 0x62, 0x44, 0x83, 0x24, 0x52, 0x34, 0x73, 0x25, 0x62, 0x44, 0x83,
0x26, 0x72, 0x35, 0x54, 0x27, 0x82, 0x45, 0x64, 0x26, 0x72, 0x35, 0x54, 0x27, 0x82, 0x45, 0x64,
0x28,0x92,0x36,0x74,0x29,0xa2,0x46,0x84}; 0x28, 0x92, 0x36, 0x74, 0x29, 0xa2, 0x46, 0x84,
};
(*final) = !(i & 1); (*final) = !(i & 1);
e = get_bits(&s->gb, 5); // get the extra bits e = get_bits(&s->gb, 5); // get the extra bits
@ -262,17 +278,22 @@ t=lut_mask[l]={0x0f,0x03,0x01,0x00}[l]; as i<256 the higher bits do not matter *
return; return;
} }
//static const uint8_t dc_extra_sbits[] ={0, 1,1, 1,1, 2,2, 3,3, 4,4, 5,5, 6,6, 7,7 }; /* static const uint8_t dc_extra_sbits[] = {
static const uint8_t dc_index_offset[] ={ 0, 1,2, 3,4, 5,7, 9,13, 17,25, 33,49, 65,97, 129,193}; * 0, 1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7,
* }; */
static const uint8_t dc_index_offset[] = {
0, 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
};
static int x8_get_dc_rlf(IntraX8Context * const w,int const mode, int * const level, int * const final){ static int x8_get_dc_rlf(IntraX8Context *const w,
int const mode, int *const level, int *const final)
{
MpegEncContext *const s = w->s; MpegEncContext *const s = w->s;
int i, e, c; int i, e, c;
assert(mode < 3); assert(mode < 3);
if (!w->j_dc_vlc[mode]) { if (!w->j_dc_vlc[mode]) {
int table_index; int table_index = get_bits(&s->gb, 3);
table_index = get_bits(&s->gb, 3);
// 4 modes, same table // 4 modes, same table
w->j_dc_vlc[mode] = &j_dc_vlc[w->quant < 13][table_index]; w->j_dc_vlc[mode] = &j_dc_vlc[w->quant < 13][table_index];
} }
@ -300,9 +321,11 @@ static int x8_get_dc_rlf(IntraX8Context * const w,int const mode, int * const le
(*level) = (i ^ e) - e; // (i ^ 0) -0 , (i ^ 0xff) - (-1) (*level) = (i ^ e) - e; // (i ^ 0) -0 , (i ^ 0xff) - (-1)
return 0; return 0;
} }
// end of huffman // end of huffman
static int x8_setup_spatial_predictor(IntraX8Context * const w, const int chroma){ static int x8_setup_spatial_predictor(IntraX8Context *const w, const int chroma)
{
MpegEncContext *const s = w->s; MpegEncContext *const s = w->s;
int range; int range;
int sum; int sum;
@ -321,10 +344,13 @@ static int x8_setup_spatial_predictor(IntraX8Context * const w, const int chroma
w->flat_dc = 0; w->flat_dc = 0;
if (range < quant || range < 3) { if (range < quant || range < 3) {
w->orient = 0; w->orient = 0;
if(range < 3){//yep you read right, a +-1 idct error may break decoding!
// yep you read right, a +-1 idct error may break decoding!
if (range < 3) {
w->flat_dc = 1; w->flat_dc = 1;
sum += 9; sum += 9;
w->predicted_dc = (sum*6899)>>17;//((1<<17)+9)/(8+8+1+2)=6899 // ((1 << 17) + 9) / (8 + 8 + 1 + 2) = 6899
w->predicted_dc = (sum * 6899) >> 17;
} }
} }
if (chroma) if (chroma)
@ -333,8 +359,10 @@ static int x8_setup_spatial_predictor(IntraX8Context * const w, const int chroma
assert(w->orient < 3); assert(w->orient < 3);
if (range < 2 * w->quant) { if (range < 2 * w->quant) {
if ((w->edges & 3) == 0) { if ((w->edges & 3) == 0) {
if(w->orient==1) w->orient=11; if (w->orient == 1)
if(w->orient==2) w->orient=10; w->orient = 11;
if (w->orient == 2)
w->orient = 10;
} else { } else {
w->orient = 0; w->orient = 0;
} }
@ -343,10 +371,11 @@ static int x8_setup_spatial_predictor(IntraX8Context * const w, const int chroma
static const uint8_t prediction_table[3][12] = { static const uint8_t prediction_table[3][12] = {
{ 0, 8, 4, 10, 11, 2, 6, 9, 1, 3, 5, 7 }, { 0, 8, 4, 10, 11, 2, 6, 9, 1, 3, 5, 7 },
{ 4, 0, 8, 11, 10, 3, 5, 2, 6, 9, 1, 7 }, { 4, 0, 8, 11, 10, 3, 5, 2, 6, 9, 1, 7 },
{8,0,4, 10,11, 1,7,2,6,9,3,5} { 8, 0, 4, 10, 11, 1, 7, 2, 6, 9, 3, 5 },
}; };
w->raw_orient = x8_get_orient_vlc(w); w->raw_orient = x8_get_orient_vlc(w);
if(w->raw_orient<0) return -1; if (w->raw_orient < 0)
return -1;
assert(w->raw_orient < 12); assert(w->raw_orient < 12);
assert(w->orient < 3); assert(w->orient < 3);
w->orient = prediction_table[w->orient][w->raw_orient]; w->orient = prediction_table[w->orient][w->raw_orient];
@ -354,16 +383,20 @@ static int x8_setup_spatial_predictor(IntraX8Context * const w, const int chroma
return 0; return 0;
} }
static void x8_update_predictions(IntraX8Context * const w, const int orient, const int est_run ){ static void x8_update_predictions(IntraX8Context *const w, const int orient,
const int est_run)
{
MpegEncContext *const s = w->s; MpegEncContext *const s = w->s;
w->prediction_table[s->mb_x * 2 + (s->mb_y & 1)] = (est_run << 2) + 1 * (orient == 4) + 2 * (orient == 8); w->prediction_table[s->mb_x * 2 + (s->mb_y & 1)] = (est_run << 2) + 1 * (orient == 4) + 2 * (orient == 8);
/* /*
y=2n+0 ->//0 2 4 * y = 2n + 0 -> // 0 2 4
y=2n+1 ->//1 3 5 * y = 2n + 1 -> // 1 3 5
*/ */
} }
static void x8_get_prediction_chroma(IntraX8Context * const w){
static void x8_get_prediction_chroma(IntraX8Context *const w)
{
MpegEncContext *const s = w->s; MpegEncContext *const s = w->s;
w->edges = 1 * (!(s->mb_x >> 1)); w->edges = 1 * (!(s->mb_x >> 1));
@ -371,14 +404,17 @@ static void x8_get_prediction_chroma(IntraX8Context * const w){
w->edges |= 4 * (s->mb_x >= (2 * s->mb_width - 1)); // mb_x for chroma would always be odd w->edges |= 4 * (s->mb_x >= (2 * s->mb_width - 1)); // mb_x for chroma would always be odd
w->raw_orient = 0; w->raw_orient = 0;
if(w->edges&3){//lut_co[8]={inv,4,8,8, inv,4,8,8}<- =>{1,1,0,0;1,1,0,0} => 0xCC // lut_co[8] = {inv,4,8,8, inv,4,8,8} <- => {1,1,0,0;1,1,0,0} => 0xCC
if (w->edges & 3) {
w->chroma_orient = 4 << ((0xCC >> w->edges) & 1); w->chroma_orient = 4 << ((0xCC >> w->edges) & 1);
return; return;
} }
w->chroma_orient = (w->prediction_table[2*s->mb_x-2] & 0x03)<<2;//block[x-1][y|1-1)] // block[x - 1][y | 1 - 1)]
w->chroma_orient = (w->prediction_table[2 * s->mb_x - 2] & 0x03) << 2;
} }
static void x8_get_prediction(IntraX8Context * const w){ static void x8_get_prediction(IntraX8Context *const w)
{
MpegEncContext *const s = w->s; MpegEncContext *const s = w->s;
int a, b, c, i; int a, b, c, i;
@ -411,9 +447,10 @@ static void x8_get_prediction(IntraX8Context * const w){
w->est_run = FFMIN(b, a); w->est_run = FFMIN(b, a);
/* This condition has nothing to do with w->edges, even if it looks /* This condition has nothing to do with w->edges, even if it looks
similar it would trigger if e.g. x=3;y=2; * similar it would trigger if e.g. x = 3; y = 2;
I guess somebody wrote something wrong and it became standard. */ * I guess somebody wrote something wrong and it became standard. */
if( (s->mb_x & s->mb_y) != 0 ) w->est_run=FFMIN(c,w->est_run); if ((s->mb_x & s->mb_y) != 0)
w->est_run = FFMIN(c, w->est_run);
w->est_run >>= 2; w->est_run >>= 2;
a &= 3; a &= 3;
@ -421,26 +458,34 @@ static void x8_get_prediction(IntraX8Context * const w){
c &= 3; c &= 3;
i = (0xFFEAF4C4 >> (2 * b + 8 * a)) & 3; i = (0xFFEAF4C4 >> (2 * b + 8 * a)) & 3;
if(i!=3) w->orient=i; if (i != 3)
else w->orient=( 0xFFEAD8>>(2*c+8*(w->quant>12)) )&3; w->orient = i;
else
w->orient = (0xFFEAD8 >> (2 * c + 8 * (w->quant > 12))) & 3;
/* /*
lut1[b][a]={ * lut1[b][a] = {
->{0, 1, 0, pad}, * ->{ 0, 1, 0, pad },
{0, 1, X, pad}, * { 0, 1, X, pad },
{2, 2, 2, pad}} * { 2, 2, 2, pad }
pad 2 2 2; pad X 1 0; pad 0 1 0 <- * }
-> 11 10 '10 10 '11 11'01 00 '11 00'01 00=>0xEAF4C4 * pad 2 2 2;
* pad X 1 0;
lut2[q>12][c]={ * pad 0 1 0 <-
->{0,2,1,pad}, * -> 11 10 '10 10 '11 11'01 00 '11 00'01 00 => 0xEAF4C4
{2,2,2,pad}} *
pad 2 2 2; pad 1 2 0 <- * lut2[q>12][c] = {
-> 11 10'10 10 '11 01'10 00=>0xEAD8 * ->{ 0, 2, 1, pad},
* { 2, 2, 2, pad}
* }
* pad 2 2 2;
* pad 1 2 0 <-
* -> 11 10'10 10 '11 01'10 00 => 0xEAD8
*/ */
} }
static void x8_ac_compensation(IntraX8Context *const w, int const direction,
static void x8_ac_compensation(IntraX8Context * const w, int const direction, int const dc_level){ int const dc_level)
{
MpegEncContext *const s = w->s; MpegEncContext *const s = w->s;
int t; int t;
#define B(x, y) s->block[0][s->idsp.idct_permutation[(x) + (y) * 8]] #define B(x, y) s->block[0][s->idsp.idct_permutation[(x) + (y) * 8]]
@ -510,7 +555,9 @@ static void x8_ac_compensation(IntraX8Context * const w, int const direction, in
#undef T #undef T
} }
static void dsp_x8_put_solidcolor(uint8_t const pix, uint8_t * dst, int const linesize){ static void dsp_x8_put_solidcolor(uint8_t const pix, uint8_t *dst,
int const linesize)
{
int k; int k;
for (k = 0; k < 8; k++) { for (k = 0; k < 8; k++) {
memset(dst, pix, 8); memset(dst, pix, 8);
@ -526,10 +573,11 @@ static const int16_t quant_table[64] = {
353, 358, 362, 366, 371, 375, 379, 384, 353, 358, 362, 366, 371, 375, 379, 384,
389, 393, 398, 403, 408, 413, 417, 422, 389, 393, 398, 403, 408, 413, 417, 422,
428, 433, 438, 443, 448, 454, 459, 465, 428, 433, 438, 443, 448, 454, 459, 465,
470, 476, 482, 488, 493, 499, 505, 511 470, 476, 482, 488, 493, 499, 505, 511,
}; };
static int x8_decode_intra_mb(IntraX8Context* const w, const int chroma){ static int x8_decode_intra_mb(IntraX8Context *const w, const int chroma)
{
MpegEncContext *const s = w->s; MpegEncContext *const s = w->s;
uint8_t *scantable; uint8_t *scantable;
@ -543,13 +591,13 @@ static int x8_decode_intra_mb(IntraX8Context* const w, const int chroma){
assert(w->orient < 12); assert(w->orient < 12);
s->bdsp.clear_block(s->block[0]); s->bdsp.clear_block(s->block[0]);
if(chroma){ if (chroma)
dc_mode = 2; dc_mode = 2;
}else{ else
dc_mode = !!w->est_run; // 0, 1 dc_mode = !!w->est_run; // 0, 1
}
if(x8_get_dc_rlf(w, dc_mode, &dc_level, &final)) return -1; if (x8_get_dc_rlf(w, dc_mode, &dc_level, &final))
return -1;
n = 0; n = 0;
zeros_only = 0; zeros_only = 0;
if (!final) { // decode ac if (!final) { // decode ac
@ -558,9 +606,9 @@ static int x8_decode_intra_mb(IntraX8Context* const w, const int chroma){
ac_mode = 1; ac_mode = 1;
est_run = 64; // not used est_run = 64; // not used
} else { } else {
if (w->raw_orient < 3){ if (w->raw_orient < 3)
use_quant_matrix = 0; use_quant_matrix = 0;
}
if (w->raw_orient > 4) { if (w->raw_orient > 4) {
ac_mode = 0; ac_mode = 0;
est_run = 64; est_run = 64;
@ -576,7 +624,7 @@ static int x8_decode_intra_mb(IntraX8Context* const w, const int chroma){
} }
x8_select_ac_table(w, ac_mode); x8_select_ac_table(w, ac_mode);
/* scantable_selector[12] = { 0, 2, 0, 1, 1, 1, 0, 2, 2, 0, 1, 2 }; <- /* scantable_selector[12] = { 0, 2, 0, 1, 1, 1, 0, 2, 2, 0, 1, 2 }; <-
-> 10'01' 00'10' 10'00' 01'01' 01'00' 10'00 =>0x928548 */ * -> 10'01' 00'10' 10'00' 01'01' 01'00' 10'00 => 0x928548 */
scantable = w->scantable[(0x928548 >> (2 * w->orient)) & 3].permutated; scantable = w->scantable[(0x928548 >> (2 * w->orient)) & 3].permutated;
pos = 0; pos = 0;
do { do {
@ -599,9 +647,9 @@ static int x8_decode_intra_mb(IntraX8Context* const w, const int chroma){
sign = -get_bits1(&s->gb); sign = -get_bits1(&s->gb);
level = (level ^ sign) - sign; level = (level ^ sign) - sign;
if(use_quant_matrix){ if (use_quant_matrix)
level = (level * quant_table[pos]) >> 8; level = (level * quant_table[pos]) >> 8;
}
s->block[0][scantable[pos]] = level; s->block[0][scantable[pos]] = level;
} while (!final); } while (!final);
@ -609,40 +657,43 @@ static int x8_decode_intra_mb(IntraX8Context* const w, const int chroma){
} else { // DC only } else { // DC only
s->block_last_index[0] = 0; s->block_last_index[0] = 0;
if (w->flat_dc && ((unsigned) (dc_level + 1)) < 3) { // [-1; 1] if (w->flat_dc && ((unsigned) (dc_level + 1)) < 3) { // [-1; 1]
int32_t divide_quant= !chroma ? w->divide_quant_dc_luma: int32_t divide_quant = !chroma ? w->divide_quant_dc_luma
w->divide_quant_dc_chroma; : w->divide_quant_dc_chroma;
int32_t dc_quant = !chroma ? w->quant: int32_t dc_quant = !chroma ? w->quant
w->quant_dc_chroma; : w->quant_dc_chroma;
//original intent dc_level+=predicted_dc/quant; but it got lost somewhere in the rounding // original intent dc_level += predicted_dc/quant;
// but it got lost somewhere in the rounding
dc_level += (w->predicted_dc * divide_quant + (1 << 12)) >> 13; dc_level += (w->predicted_dc * divide_quant + (1 << 12)) >> 13;
dsp_x8_put_solidcolor(av_clip_uint8((dc_level * dc_quant + 4) >> 3), dsp_x8_put_solidcolor(av_clip_uint8((dc_level * dc_quant + 4) >> 3),
s->dest[chroma], s->current_picture.f->linesize[!!chroma]); s->dest[chroma],
s->current_picture.f->linesize[!!chroma]);
goto block_placed; goto block_placed;
} }
zeros_only = (dc_level == 0); zeros_only = (dc_level == 0);
} }
if(!chroma){ if (!chroma)
s->block[0][0] = dc_level * w->quant; s->block[0][0] = dc_level * w->quant;
}else{ else
s->block[0][0] = dc_level * w->quant_dc_chroma; s->block[0][0] = dc_level * w->quant_dc_chroma;
}
// there is !zero_only check in the original, but dc_level check is enough // there is !zero_only check in the original, but dc_level check is enough
if ((unsigned int) (dc_level + 1) >= 3 && (w->edges & 3) != 3) { if ((unsigned int) (dc_level + 1) >= 3 && (w->edges & 3) != 3) {
int direction; int direction;
/* ac_comp_direction[orient] = { 0, 3, 3, 1, 1, 0, 0, 0, 2, 2, 2, 1 }; <- /* ac_comp_direction[orient] = { 0, 3, 3, 1, 1, 0, 0, 0, 2, 2, 2, 1 }; <-
-> 01'10' 10'10' 00'00' 00'01' 01'11' 11'00 =>0x6A017C */ * -> 01'10' 10'10' 00'00' 00'01' 01'11' 11'00 => 0x6A017C */
direction = (0x6A017C >> (w->orient * 2)) & 3; direction = (0x6A017C >> (w->orient * 2)) & 3;
if (direction != 3) { if (direction != 3) {
x8_ac_compensation(w, direction, s->block[0][0]);//modify block_last[] // modify block_last[]
x8_ac_compensation(w, direction, s->block[0][0]);
} }
} }
if (w->flat_dc) { if (w->flat_dc) {
dsp_x8_put_solidcolor(w->predicted_dc, s->dest[chroma], s->current_picture.f->linesize[!!chroma]); dsp_x8_put_solidcolor(w->predicted_dc, s->dest[chroma],
s->current_picture.f->linesize[!!chroma]);
} else { } else {
w->dsp.spatial_compensation[w->orient](s->sc.edge_emu_buffer, w->dsp.spatial_compensation[w->orient](s->sc.edge_emu_buffer,
s->dest[chroma], s->dest[chroma],
@ -654,26 +705,25 @@ static int x8_decode_intra_mb(IntraX8Context* const w, const int chroma){
s->block[0]); s->block[0]);
block_placed: block_placed:
if (!chroma)
if(!chroma){
x8_update_predictions(w, w->orient, n); x8_update_predictions(w, w->orient, n);
}
if (s->loop_filter) { if (s->loop_filter) {
uint8_t *ptr = s->dest[chroma]; uint8_t *ptr = s->dest[chroma];
int linesize = s->current_picture.f->linesize[!!chroma]; int linesize = s->current_picture.f->linesize[!!chroma];
if(!( (w->edges&2) || ( zeros_only && (w->orient|4)==4 ) )){ if (!((w->edges & 2) || (zeros_only && (w->orient | 4) == 4)))
w->dsp.h_loop_filter(ptr, linesize, w->quant); w->dsp.h_loop_filter(ptr, linesize, w->quant);
}
if(!( (w->edges&1) || ( zeros_only && (w->orient|8)==8 ) )){ if (!((w->edges & 1) || (zeros_only && (w->orient | 8) == 8)))
w->dsp.v_loop_filter(ptr, linesize, w->quant); w->dsp.v_loop_filter(ptr, linesize, w->quant);
} }
}
return 0; return 0;
} }
static void x8_init_block_index(MpegEncContext *s){ //FIXME maybe merge with ff_* // FIXME maybe merge with ff_*
static void x8_init_block_index(MpegEncContext *s)
{
// not s->linesize as this would be wrong for field pics // not s->linesize as this would be wrong for field pics
// not that IntraX8 has interlacing support ;) // not that IntraX8 has interlacing support ;)
const int linesize = s->current_picture.f->linesize[0]; const int linesize = s->current_picture.f->linesize[0];
@ -684,7 +734,8 @@ static void x8_init_block_index(MpegEncContext *s){ //FIXME maybe merge with ff_
s->dest[2] = s->current_picture.f->data[2]; s->dest[2] = s->current_picture.f->data[2];
s->dest[0] += s->mb_y * linesize << 3; s->dest[0] += s->mb_y * linesize << 3;
s->dest[1] += ( s->mb_y&(~1) ) * uvlinesize << 2;//chroma blocks are on add rows // chroma blocks are on add rows
s->dest[1] += (s->mb_y & (~1)) * uvlinesize << 2;
s->dest[2] += (s->mb_y & (~1)) * uvlinesize << 2; s->dest[2] += (s->mb_y & (~1)) * uvlinesize << 2;
} }
@ -694,16 +745,21 @@ static void x8_init_block_index(MpegEncContext *s){ //FIXME maybe merge with ff_
* @param w pointer to IntraX8Context * @param w pointer to IntraX8Context
* @param s pointer to MpegEncContext of the parent codec * @param s pointer to MpegEncContext of the parent codec
*/ */
av_cold void ff_intrax8_common_init(IntraX8Context * w, MpegEncContext * const s){ av_cold void ff_intrax8_common_init(IntraX8Context *w, MpegEncContext *const s)
{
w->s = s; w->s = s;
x8_vlc_init(); x8_vlc_init();
assert(s->mb_width > 0); assert(s->mb_width > 0);
w->prediction_table=av_mallocz(s->mb_width*2*2);//two rows, 2 blocks per cannon mb
ff_init_scantable(s->idsp.idct_permutation, &w->scantable[0], ff_wmv1_scantable[0]); // two rows, 2 blocks per cannon mb
ff_init_scantable(s->idsp.idct_permutation, &w->scantable[1], ff_wmv1_scantable[2]); w->prediction_table = av_mallocz(s->mb_width * 2 * 2);
ff_init_scantable(s->idsp.idct_permutation, &w->scantable[2], ff_wmv1_scantable[3]);
ff_init_scantable(s->idsp.idct_permutation, &w->scantable[0],
ff_wmv1_scantable[0]);
ff_init_scantable(s->idsp.idct_permutation, &w->scantable[1],
ff_wmv1_scantable[2]);
ff_init_scantable(s->idsp.idct_permutation, &w->scantable[2],
ff_wmv1_scantable[3]);
ff_intrax8dsp_init(&w->dsp); ff_intrax8dsp_init(&w->dsp);
} }
@ -727,7 +783,9 @@ av_cold void ff_intrax8_common_end(IntraX8Context * w)
* @param dquant doubled quantizer, it would be odd in case of VC-1 halfpq==1. * @param dquant doubled quantizer, it would be odd in case of VC-1 halfpq==1.
* @param quant_offset offset away from zero * @param quant_offset offset away from zero
*/ */
int ff_intrax8_decode_picture(IntraX8Context * const w, int dquant, int quant_offset){ int ff_intrax8_decode_picture(IntraX8Context *const w, int dquant,
int quant_offset)
{
MpegEncContext *const s = w->s; MpegEncContext *const s = w->s;
int mb_xy; int mb_xy;
assert(s); assert(s);
@ -747,26 +805,29 @@ int ff_intrax8_decode_picture(IntraX8Context * const w, int dquant, int quant_of
} }
x8_reset_vlc_tables(w); x8_reset_vlc_tables(w);
for (s->mb_y = 0; s->mb_y < s->mb_height * 2; s->mb_y++) { for (s->mb_y = 0; s->mb_y < s->mb_height * 2; s->mb_y++) {
x8_init_block_index(s); x8_init_block_index(s);
mb_xy = (s->mb_y >> 1) * s->mb_stride; mb_xy = (s->mb_y >> 1) * s->mb_stride;
for (s->mb_x = 0; s->mb_x < s->mb_width * 2; s->mb_x++) { for (s->mb_x = 0; s->mb_x < s->mb_width * 2; s->mb_x++) {
x8_get_prediction(w); x8_get_prediction(w);
if(x8_setup_spatial_predictor(w,0)) goto error; if (x8_setup_spatial_predictor(w, 0))
if(x8_decode_intra_mb(w,0)) goto error; goto error;
if (x8_decode_intra_mb(w, 0))
goto error;
if (s->mb_x & s->mb_y & 1) { if (s->mb_x & s->mb_y & 1) {
x8_get_prediction_chroma(w); x8_get_prediction_chroma(w);
/* when setting up chroma, no vlc is read, /* when setting up chroma, no vlc is read,
so no error condition can be reached*/ * so no error condition can be reached */
x8_setup_spatial_predictor(w, 1); x8_setup_spatial_predictor(w, 1);
if(x8_decode_intra_mb(w,1)) goto error; if (x8_decode_intra_mb(w, 1))
goto error;
x8_setup_spatial_predictor(w, 2); x8_setup_spatial_predictor(w, 2);
if(x8_decode_intra_mb(w,2)) goto error; if (x8_decode_intra_mb(w, 2))
goto error;
s->dest[1] += 8; s->dest[1] += 8;
s->dest[2] += 8; s->dest[2] += 8;
@ -779,10 +840,9 @@ int ff_intrax8_decode_picture(IntraX8Context * const w, int dquant, int quant_of
} }
s->dest[0] += 8; s->dest[0] += 8;
} }
if(s->mb_y&1){ if (s->mb_y & 1)
ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 8, 16); ff_mpeg_draw_horiz_band(s, (s->mb_y - 1) * 8, 16);
} }
}
error: error:
return 0; return 0;

4
libavcodec/intrax8.h
View File

@ -29,19 +29,23 @@ typedef struct IntraX8Context {
VLC *j_dc_vlc[3]; VLC *j_dc_vlc[3];
int use_quant_matrix; int use_quant_matrix;
// set by ff_intrax8_common_init // set by ff_intrax8_common_init
uint8_t *prediction_table; // 2 * (mb_w * 2) uint8_t *prediction_table; // 2 * (mb_w * 2)
ScanTable scantable[3]; ScanTable scantable[3];
// set by the caller codec // set by the caller codec
MpegEncContext *s; MpegEncContext *s;
IntraX8DSPContext dsp; IntraX8DSPContext dsp;
int quant; int quant;
int dquant; int dquant;
int qsum; int qsum;
// calculated per frame // calculated per frame
int quant_dc_chroma; int quant_dc_chroma;
int divide_quant_dc_luma; int divide_quant_dc_luma;
int divide_quant_dc_chroma; int divide_quant_dc_chroma;
// changed per block // changed per block
int edges; int edges;
int flat_dc; int flat_dc;

216
libavcodec/intrax8dsp.c
View File

@ -25,19 +25,19 @@
#include "libavutil/common.h" #include "libavutil/common.h"
/* /*
area positions, #3 is 1 pixel only, other are 8 pixels * area positions, #3 is 1 pixel only, other are 8 pixels
|66666666| * |66666666|
3|44444444|55555555| * 3|44444444|55555555|
- -+--------+--------+ * - -+--------+--------+
1 2|XXXXXXXX| * 1 2|XXXXXXXX|
1 2|XXXXXXXX| * 1 2|XXXXXXXX|
1 2|XXXXXXXX| * 1 2|XXXXXXXX|
1 2|XXXXXXXX| * 1 2|XXXXXXXX|
1 2|XXXXXXXX| * 1 2|XXXXXXXX|
1 2|XXXXXXXX| * 1 2|XXXXXXXX|
1 2|XXXXXXXX| * 1 2|XXXXXXXX|
1 2|XXXXXXXX| * 1 2|XXXXXXXX|
^-start * ^-start
*/ */
#define area1 (0) #define area1 (0)
@ -61,9 +61,11 @@ area positions, #3 is 1 pixel only, other are 8 pixels
2 - mb_y==0 - first row, interpolate area #3,#4,#5,#6; 2 - mb_y==0 - first row, interpolate area #3,#4,#5,#6;
note: 1|2 - mb_x==mb_y==0 - first block, use 0x80 value for all areas; note: 1|2 - mb_x==mb_y==0 - first block, use 0x80 value for all areas;
4 - mb_x>= (mb_width-1) last block in the row, interpolate area #5; 4 - mb_x>= (mb_width-1) last block in the row, interpolate area #5;
*/ -*/
static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst, int linesize, static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst,
int * range, int * psum, int edges){ int linesize, int *range, int *psum,
int edges)
{
uint8_t *ptr; uint8_t *ptr;
int sum; int sum;
int i; int i;
@ -74,8 +76,8 @@ static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst, int linesi
*psum = 0x80 * (8 + 1 + 8 + 2); *psum = 0x80 * (8 + 1 + 8 + 2);
*range = 0; *range = 0;
memset(dst, 0x80, 16 + 1 + 16 + 8); memset(dst, 0x80, 16 + 1 + 16 + 8);
//this triggers flat_dc for sure. /* this triggers flat_dc for sure. flat_dc avoids all (other)
//flat_dc avoids all (other) prediction modes, but requires dc_level decoding. * prediction modes, but requires dc_level decoding. */
return; return;
} }
@ -114,19 +116,22 @@ static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst, int linesi
} else { } else {
memcpy(dst + area4, ptr, 16); // both area4 and 5 memcpy(dst + area4, ptr, 16); // both area4 and 5
} }
memcpy(dst+area6, ptr-linesize, 8);//area6 always present in the above block // area6 always present in the above block
memcpy(dst + area6, ptr - linesize, 8);
} }
// now calculate the stuff we need // now calculate the stuff we need
if (edges & 3) { // mb_x ==0 || mb_y == 0) { if (edges & 3) { // mb_x ==0 || mb_y == 0) {
int avg = (sum + 4) >> 3; int avg = (sum + 4) >> 3;
if(edges&1){ //(mb_x==0) {//implies mb_y!=0
memset(dst+area1,avg,8+8+1);//areas 1,2 and 3 are averaged if (edges & 1) // (mb_x == 0) { // implies mb_y !=0
}else{//implies y==0 x!=0 memset(dst + area1, avg, 8 + 8 + 1); // areas 1, 2, 3 are averaged
else // implies y == 0 x != 0
memset(dst + area3, avg, 1 + 16 + 8); // areas 3, 4, 5, 6 memset(dst + area3, avg, 1 + 16 + 8); // areas 3, 4, 5, 6
}
sum += avg * 9; sum += avg * 9;
} else { } else {
uint8_t c=*(src-1-linesize);//the edge pixel, in the top line and left column // the edge pixel, in the top line and left column
uint8_t c = *(src - 1 - linesize);
dst[area3] = c; dst[area3] = c;
sum += c; sum += c;
// edge pixel is not part of min/max // edge pixel is not part of min/max
@ -136,19 +141,27 @@ static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst, int linesi
*psum = sum; *psum = sum;
} }
static const uint16_t zero_prediction_weights[64 * 2] = { static const uint16_t zero_prediction_weights[64 * 2] = {
640, 640, 669, 480, 708, 354, 748, 257, 792, 198, 760, 143, 808, 101, 772, 72, 640, 640, 669, 480, 708, 354, 748, 257,
480, 669, 537, 537, 598, 416, 661, 316, 719, 250, 707, 185, 768, 134, 745, 97, 792, 198, 760, 143, 808, 101, 772, 72,
354, 708, 416, 598, 488, 488, 564, 388, 634, 317, 642, 241, 716, 179, 706, 132, 480, 669, 537, 537, 598, 416, 661, 316,
257, 748, 316, 661, 388, 564, 469, 469, 543, 395, 571, 311, 655, 238, 660, 180, 719, 250, 707, 185, 768, 134, 745, 97,
198, 792, 250, 719, 317, 634, 395, 543, 469, 469, 507, 380, 597, 299, 616, 231, 354, 708, 416, 598, 488, 488, 564, 388,
161, 855, 206, 788, 266, 710, 340, 623, 411, 548, 455, 455, 548, 366, 576, 288, 634, 317, 642, 241, 716, 179, 706, 132,
122, 972, 159, 914, 211, 842, 276, 758, 341, 682, 389, 584, 483, 483, 520, 390, 257, 748, 316, 661, 388, 564, 469, 469,
110, 1172, 144, 1107, 193, 1028, 254, 932, 317, 846, 366, 731, 458, 611, 499, 499 543, 395, 571, 311, 655, 238, 660, 180,
198, 792, 250, 719, 317, 634, 395, 543,
469, 469, 507, 380, 597, 299, 616, 231,
161, 855, 206, 788, 266, 710, 340, 623,
411, 548, 455, 455, 548, 366, 576, 288,
122, 972, 159, 914, 211, 842, 276, 758,
341, 682, 389, 584, 483, 483, 520, 390,
110, 1172, 144, 1107, 193, 1028, 254, 932,
317, 846, 366, 731, 458, 611, 499, 499,
}; };
static void spatial_compensation_0(uint8_t *src , uint8_t *dst, int linesize){ static void spatial_compensation_0(uint8_t *src, uint8_t *dst, int linesize)
{
int i, j; int i, j;
int x, y; int x, y;
unsigned int p; // power divided by 2 unsigned int p; // power divided by 2
@ -191,136 +204,145 @@ static void spatial_compensation_0(uint8_t *src , uint8_t *dst, int linesize){
left_sum[0][i] += (left_sum[1][i] * 181 + 128) >> 8; left_sum[0][i] += (left_sum[1][i] * 181 + 128) >> 8;
} }
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for(x=0;x<8;x++){ for (x = 0; x < 8; x++)
dst[x] = ( dst[x] = ((uint32_t) top_sum[0][x] * zero_prediction_weights[y * 16 + x * 2 + 0] +
(uint32_t)top_sum [0][x]*zero_prediction_weights[y*16+x*2+0] +
(uint32_t) left_sum[0][y] * zero_prediction_weights[y * 16 + x * 2 + 1] + (uint32_t) left_sum[0][y] * zero_prediction_weights[y * 16 + x * 2 + 1] +
0x8000 0x8000) >> 16;
)>>16;
}
dst += linesize; dst += linesize;
} }
} }
static void spatial_compensation_1(uint8_t *src , uint8_t *dst, int linesize){
static void spatial_compensation_1(uint8_t *src, uint8_t *dst, int linesize)
{
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for(x=0;x<8;x++){ for (x = 0; x < 8; x++)
dst[x] = src[area4 + FFMIN(2 * y + x + 2, 15)]; dst[x] = src[area4 + FFMIN(2 * y + x + 2, 15)];
}
dst += linesize; dst += linesize;
} }
} }
static void spatial_compensation_2(uint8_t *src , uint8_t *dst, int linesize){
static void spatial_compensation_2(uint8_t *src, uint8_t *dst, int linesize)
{
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for(x=0;x<8;x++){ for (x = 0; x < 8; x++)
dst[x] = src[area4 + 1 + y + x]; dst[x] = src[area4 + 1 + y + x];
}
dst += linesize; dst += linesize;
} }
} }
static void spatial_compensation_3(uint8_t *src , uint8_t *dst, int linesize){
static void spatial_compensation_3(uint8_t *src, uint8_t *dst, int linesize)
{
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for(x=0;x<8;x++){ for (x = 0; x < 8; x++)
dst[x] = src[area4 + ((y + 1) >> 1) + x]; dst[x] = src[area4 + ((y + 1) >> 1) + x];
}
dst += linesize; dst += linesize;
} }
} }
static void spatial_compensation_4(uint8_t *src , uint8_t *dst, int linesize){
static void spatial_compensation_4(uint8_t *src, uint8_t *dst, int linesize)
{
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for(x=0;x<8;x++){ for (x = 0; x < 8; x++)
dst[x] = (src[area4 + x] + src[area6 + x] + 1) >> 1; dst[x] = (src[area4 + x] + src[area6 + x] + 1) >> 1;
}
dst += linesize; dst += linesize;
} }
} }
static void spatial_compensation_5(uint8_t *src , uint8_t *dst, int linesize){
static void spatial_compensation_5(uint8_t *src, uint8_t *dst, int linesize)
{
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) { for (x = 0; x < 8; x++) {
if(2*x-y<0){ if (2 * x - y < 0)
dst[x] = src[area2 + 9 + 2 * x - y]; dst[x] = src[area2 + 9 + 2 * x - y];
}else{ else
dst[x] = src[area4 + x - ((y + 1) >> 1)]; dst[x] = src[area4 + x - ((y + 1) >> 1)];
} }
}
dst += linesize; dst += linesize;
} }
} }
static void spatial_compensation_6(uint8_t *src , uint8_t *dst, int linesize){
static void spatial_compensation_6(uint8_t *src, uint8_t *dst, int linesize)
{
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for(x=0;x<8;x++){ for (x = 0; x < 8; x++)
dst[x] = src[area3 + x - y]; dst[x] = src[area3 + x - y];
}
dst += linesize; dst += linesize;
} }
} }
static void spatial_compensation_7(uint8_t *src , uint8_t *dst, int linesize){
static void spatial_compensation_7(uint8_t *src, uint8_t *dst, int linesize)
{
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) { for (x = 0; x < 8; x++) {
if(x-2*y>0){ if (x - 2 * y > 0)
dst[x] = (src[area3 - 1 + x - 2 * y] + src[area3 + x - 2 * y] + 1) >> 1; dst[x] = (src[area3 - 1 + x - 2 * y] + src[area3 + x - 2 * y] + 1) >> 1;
}else{ else
dst[x] = src[area2 + 8 - y + (x >> 1)]; dst[x] = src[area2 + 8 - y + (x >> 1)];
} }
}
dst += linesize; dst += linesize;
} }
} }
static void spatial_compensation_8(uint8_t *src , uint8_t *dst, int linesize){
static void spatial_compensation_8(uint8_t *src, uint8_t *dst, int linesize)
{
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for(x=0;x<8;x++){ for (x = 0; x < 8; x++)
dst[x] = (src[area1 + 7 - y] + src[area2 + 7 - y] + 1) >> 1; dst[x] = (src[area1 + 7 - y] + src[area2 + 7 - y] + 1) >> 1;
}
dst += linesize; dst += linesize;
} }
} }
static void spatial_compensation_9(uint8_t *src , uint8_t *dst, int linesize){
static void spatial_compensation_9(uint8_t *src, uint8_t *dst, int linesize)
{
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for(x=0;x<8;x++){ for (x = 0; x < 8; x++)
dst[x] = src[area2 + 6 - FFMIN(x + y, 6)]; dst[x] = src[area2 + 6 - FFMIN(x + y, 6)];
}
dst += linesize; dst += linesize;
} }
} }
static void spatial_compensation_10(uint8_t *src , uint8_t *dst, int linesize){
static void spatial_compensation_10(uint8_t *src, uint8_t *dst, int linesize)
{
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for(x=0;x<8;x++){ for (x = 0; x < 8; x++)
dst[x] = (src[area2 + 7 - y] * (8 - x) + src[area4 + x] * x + 4) >> 3; dst[x] = (src[area2 + 7 - y] * (8 - x) + src[area4 + x] * x + 4) >> 3;
}
dst += linesize; dst += linesize;
} }
} }
static void spatial_compensation_11(uint8_t *src , uint8_t *dst, int linesize){
static void spatial_compensation_11(uint8_t *src, uint8_t *dst, int linesize)
{
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for(x=0;x<8;x++){ for (x = 0; x < 8; x++)
dst[x] = (src[area2 + 7 - y] * y + src[area4 + x] * (8 - y) + 4) >> 3; dst[x] = (src[area2 + 7 - y] * y + src[area4 + x] * (8 - y) + 4) >> 3;
}
dst += linesize; dst += linesize;
} }
} }
static void x8_loop_filter(uint8_t * ptr, const int a_stride, const int b_stride, int quant){ static void x8_loop_filter(uint8_t *ptr, const int a_stride, const int b_stride, int quant)
{
int i, t; int i, t;
int p0, p1, p2, p3, p4, p5, p6, p7, p8, p9; int p0, p1, p2, p3, p4, p5, p6, p7, p8, p9;
int ql = (quant + 10) >> 3; int ql = (quant + 10) >> 3;
@ -337,14 +359,14 @@ static void x8_loop_filter(uint8_t * ptr, const int a_stride, const int b_stride
p8 = ptr[3 * a_stride]; p8 = ptr[3 * a_stride];
p9 = ptr[4 * a_stride]; p9 = ptr[4 * a_stride];
t= t = (FFABS(p1 - p2) <= ql) +
(FFABS(p1-p2) <= ql) +
(FFABS(p2 - p3) <= ql) + (FFABS(p2 - p3) <= ql) +
(FFABS(p3 - p4) <= ql) + (FFABS(p3 - p4) <= ql) +
(FFABS(p4 - p5) <= ql); (FFABS(p4 - p5) <= ql);
if(t>0){//You need at least 1 to be able to reach a total score of 6.
t+= // You need at least 1 to be able to reach a total score of 6.
(FFABS(p5-p6) <= ql) + if (t > 0) {
t += (FFABS(p5 - p6) <= ql) +
(FFABS(p6 - p7) <= ql) + (FFABS(p6 - p7) <= ql) +
(FFABS(p7 - p8) <= ql) + (FFABS(p7 - p8) <= ql) +
(FFABS(p8 - p9) <= ql) + (FFABS(p8 - p9) <= ql) +
@ -353,21 +375,28 @@ static void x8_loop_filter(uint8_t * ptr, const int a_stride, const int b_stride
int min, max; int min, max;
min = max = p1; min = max = p1;
min=FFMIN(min,p3); max=FFMAX(max,p3); min = FFMIN(min, p3);
min=FFMIN(min,p5); max=FFMAX(max,p5); max = FFMAX(max, p3);
min=FFMIN(min,p8); max=FFMAX(max,p8); min = FFMIN(min, p5);
max = FFMAX(max, p5);
min = FFMIN(min, p8);
max = FFMAX(max, p8);
if (max - min < 2 * quant) { // early stop if (max - min < 2 * quant) { // early stop
min=FFMIN(min,p2); max=FFMAX(max,p2); min = FFMIN(min, p2);
min=FFMIN(min,p4); max=FFMAX(max,p4); max = FFMAX(max, p2);
min=FFMIN(min,p6); max=FFMAX(max,p6); min = FFMIN(min, p4);
min=FFMIN(min,p7); max=FFMAX(max,p7); max = FFMAX(max, p4);
min = FFMIN(min, p6);
max = FFMAX(max, p6);
min = FFMIN(min, p7);
max = FFMAX(max, p7);
if (max - min < 2 * quant) { if (max - min < 2 * quant) {
ptr[-2 * a_stride] = (4 * p2 + 3 * p3 + 1 * p7 + 4) >> 3; ptr[-2 * a_stride] = (4 * p2 + 3 * p3 + 1 * p7 + 4) >> 3;
ptr[-1 * a_stride] = (3 * p2 + 3 * p4 + 2 * p7 + 4) >> 3; ptr[-1 * a_stride] = (3 * p2 + 3 * p4 + 2 * p7 + 4) >> 3;
ptr[0] = (2 * p2 + 3 * p5 + 3 * p7 + 4) >> 3; ptr[0] = (2 * p2 + 3 * p5 + 3 * p7 + 4) >> 3;
ptr[1 * a_stride] = (1 * p2 + 3 * p6 + 4 * p7 + 4) >> 3; ptr[1 * a_stride] = (1 * p2 + 3 * p6 + 4 * p7 + 4) >> 3;
continue; continue;
}; }
} }
} }
} }
@ -392,7 +421,8 @@ static void x8_loop_filter(uint8_t * ptr, const int a_stride, const int b_stride
x = (5 * x) >> 3; x = (5 * x) >> 3;
if(x>m) x=m; if (x > m)
x = m;
x = (x ^ sign) - sign; x = (x ^ sign) - sign;
@ -404,11 +434,13 @@ static void x8_loop_filter(uint8_t * ptr, const int a_stride, const int b_stride
} }
} }
static void x8_h_loop_filter(uint8_t *src, int stride, int qscale){ static void x8_h_loop_filter(uint8_t *src, int stride, int qscale)
{
x8_loop_filter(src, stride, 1, qscale); x8_loop_filter(src, stride, 1, qscale);
} }
static void x8_v_loop_filter(uint8_t *src, int stride, int qscale){ static void x8_v_loop_filter(uint8_t *src, int stride, int qscale)
{
x8_loop_filter(src, 1, stride, qscale); x8_loop_filter(src, 1, stride, qscale);
} }

157
libavcodec/intrax8huf.h
View File

@ -21,25 +21,27 @@
#include <inttypes.h> #include <inttypes.h>
static const uint16_t x8_orient_lowquant_table[4][12][2] = { static const uint16_t x8_orient_lowquant_table[4][12][2] = {
{ // 0 { // 0
{ 0x0000, 1 }, { 0x0004, 3 }, { 0x0005, 3 }, { 0x000C, 4 }, { 0x0000, 1 }, { 0x0004, 3 }, { 0x0005, 3 }, { 0x000C, 4 },
{ 0x000D, 4 }, { 0x0038, 6 }, { 0x001D, 5 }, { 0x0039, 6 }, { 0x000D, 4 }, { 0x0038, 6 }, { 0x001D, 5 }, { 0x0039, 6 },
{ 0x003C, 6 }, { 0x003D, 6 }, { 0x003E, 6 }, { 0x003F, 6 }, { 0x003C, 6 }, { 0x003D, 6 }, { 0x003E, 6 }, { 0x003F, 6 },
},{//1 },
{ // 1
{ 0x0000, 5 }, { 0x0001, 5 }, { 0x0002, 5 }, { 0x0001, 2 }, { 0x0000, 5 }, { 0x0001, 5 }, { 0x0002, 5 }, { 0x0001, 2 },
{ 0x0002, 2 }, { 0x0002, 4 }, { 0x0003, 5 }, { 0x0006, 3 }, { 0x0002, 2 }, { 0x0002, 4 }, { 0x0003, 5 }, { 0x0006, 3 },
{ 0x0003, 4 }, { 0x000E, 4 }, { 0x001E, 5 }, { 0x001F, 5 }, { 0x0003, 4 }, { 0x000E, 4 }, { 0x001E, 5 }, { 0x001F, 5 },
},{//2 },
{ // 2
{ 0x0000, 2 }, { 0x0001, 2 }, { 0x0004, 3 }, { 0x0005, 3 }, { 0x0000, 2 }, { 0x0001, 2 }, { 0x0004, 3 }, { 0x0005, 3 },
{ 0x0006, 3 }, { 0x0038, 6 }, { 0x0039, 6 }, { 0x001D, 5 }, { 0x0006, 3 }, { 0x0038, 6 }, { 0x0039, 6 }, { 0x001D, 5 },
{ 0x003C, 6 }, { 0x003D, 6 }, { 0x003E, 6 }, { 0x003F, 6 }, { 0x003C, 6 }, { 0x003D, 6 }, { 0x003E, 6 }, { 0x003F, 6 },
},{//3 },
{ // 3
{ 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0001, 2 }, { 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0001, 2 },
{ 0x0002, 2 }, { 0x0018, 5 }, { 0x0019, 5 }, { 0x000D, 4 }, { 0x0002, 2 }, { 0x0018, 5 }, { 0x0019, 5 }, { 0x000D, 4 },
{ 0x001C, 5 }, { 0x001D, 5 }, { 0x001E, 5 }, { 0x001F, 5 }, { 0x001C, 5 }, { 0x001D, 5 }, { 0x001E, 5 }, { 0x001F, 5 },
} },
}; };
static const uint16_t x8_orient_highquant_table[2][12][2] = { static const uint16_t x8_orient_highquant_table[2][12][2] = {
@ -47,15 +49,15 @@ static const uint16_t x8_orient_highquant_table[2][12][2]={
{ 0x0000, 2 }, { 0x0001, 2 }, { 0x0004, 3 }, { 0x0005, 3 }, { 0x0000, 2 }, { 0x0001, 2 }, { 0x0004, 3 }, { 0x0005, 3 },
{ 0x0006, 3 }, { 0x0038, 6 }, { 0x001D, 5 }, { 0x0039, 6 }, { 0x0006, 3 }, { 0x0038, 6 }, { 0x001D, 5 }, { 0x0039, 6 },
{ 0x003C, 6 }, { 0x003D, 6 }, { 0x003E, 6 }, { 0x003F, 6 }, { 0x003C, 6 }, { 0x003D, 6 }, { 0x003E, 6 }, { 0x003F, 6 },
},{//1 },
{ // 1
{ 0x0000, 1 }, { 0x0002, 2 }, { 0x0006, 3 }, { 0x001C, 5 }, { 0x0000, 1 }, { 0x0002, 2 }, { 0x0006, 3 }, { 0x001C, 5 },
{ 0x001D, 5 }, { 0x0078, 7 }, { 0x003D, 6 }, { 0x0079, 7 }, { 0x001D, 5 }, { 0x0078, 7 }, { 0x003D, 6 }, { 0x0079, 7 },
{ 0x007C, 7 }, { 0x007D, 7 }, { 0x007E, 7 }, { 0x007F, 7 }, { 0x007C, 7 }, { 0x007D, 7 }, { 0x007E, 7 }, { 0x007F, 7 },
} },
}; };
#define MAX_OR_VLC_BITS 7 #define MAX_OR_VLC_BITS 7
static const uint16_t x8_dc_lowquant_table[8][34][2] = { static const uint16_t x8_dc_lowquant_table[8][34][2] = {
{ // 0 { // 0
{ 0x0000, 5 }, { 0x0001, 4 }, { 0x0001, 5 }, { 0x0004, 5 }, { 0x0000, 5 }, { 0x0001, 4 }, { 0x0001, 5 }, { 0x0004, 5 },
@ -67,7 +69,8 @@ static const uint16_t x8_dc_lowquant_table[8][34][2]={
{ 0x0085, 9 }, { 0x0847, 13 }, { 0x0848, 13 }, { 0x0849, 13 }, { 0x0085, 9 }, { 0x0847, 13 }, { 0x0848, 13 }, { 0x0849, 13 },
{ 0x084A, 13 }, { 0x084B, 13 }, { 0x084C, 13 }, { 0x084D, 13 }, { 0x084A, 13 }, { 0x084B, 13 }, { 0x084C, 13 }, { 0x084D, 13 },
{ 0x084E, 13 }, { 0x084F, 13 }, { 0x084E, 13 }, { 0x084F, 13 },
},{//1 },
{ // 1
{ 0x0000, 4 }, { 0x0001, 3 }, { 0x0002, 3 }, { 0x0001, 4 }, { 0x0000, 4 }, { 0x0001, 3 }, { 0x0002, 3 }, { 0x0001, 4 },
{ 0x0006, 4 }, { 0x0004, 3 }, { 0x0007, 4 }, { 0x0005, 3 }, { 0x0006, 4 }, { 0x0004, 3 }, { 0x0007, 4 }, { 0x0005, 3 },
{ 0x000C, 4 }, { 0x000D, 4 }, { 0x001C, 5 }, { 0x003A, 6 }, { 0x000C, 4 }, { 0x000D, 4 }, { 0x001C, 5 }, { 0x003A, 6 },
@ -77,7 +80,8 @@ static const uint16_t x8_dc_lowquant_table[8][34][2]={
{ 0x01FE, 9 }, { 0x1DA3, 13 }, { 0x1DA4, 13 }, { 0x1DA5, 13 }, { 0x01FE, 9 }, { 0x1DA3, 13 }, { 0x1DA4, 13 }, { 0x1DA5, 13 },
{ 0x0ED3, 12 }, { 0x0ED4, 12 }, { 0x01FF, 9 }, { 0x0ED5, 12 }, { 0x0ED3, 12 }, { 0x0ED4, 12 }, { 0x01FF, 9 }, { 0x0ED5, 12 },
{ 0x0ED6, 12 }, { 0x0ED7, 12 }, { 0x0ED6, 12 }, { 0x0ED7, 12 },
},{//2 },
{ // 2
{ 0x0000, 4 }, { 0x0001, 3 }, { 0x0002, 3 }, { 0x0001, 4 }, { 0x0000, 4 }, { 0x0001, 3 }, { 0x0002, 3 }, { 0x0001, 4 },
{ 0x0006, 4 }, { 0x0007, 4 }, { 0x0008, 4 }, { 0x0009, 4 }, { 0x0006, 4 }, { 0x0007, 4 }, { 0x0008, 4 }, { 0x0009, 4 },
{ 0x0028, 6 }, { 0x0029, 6 }, { 0x0054, 7 }, { 0x0055, 7 }, { 0x0028, 6 }, { 0x0029, 6 }, { 0x0054, 7 }, { 0x0055, 7 },
@ -87,7 +91,8 @@ static const uint16_t x8_dc_lowquant_table[8][34][2]={
{ 0x00AD, 8 }, { 0x0AC5, 12 }, { 0x0AC6, 12 }, { 0x0AC7, 12 }, { 0x00AD, 8 }, { 0x0AC5, 12 }, { 0x0AC6, 12 }, { 0x0AC7, 12 },
{ 0x0AC8, 12 }, { 0x0AC9, 12 }, { 0x0ACA, 12 }, { 0x0ACB, 12 }, { 0x0AC8, 12 }, { 0x0AC9, 12 }, { 0x0ACA, 12 }, { 0x0ACB, 12 },
{ 0x0566, 11 }, { 0x0567, 11 }, { 0x0566, 11 }, { 0x0567, 11 },
},{//3 },
{ // 3
{ 0x0000, 4 }, { 0x0001, 2 }, { 0x0001, 3 }, { 0x0004, 3 }, { 0x0000, 4 }, { 0x0001, 2 }, { 0x0001, 3 }, { 0x0004, 3 },
{ 0x0005, 3 }, { 0x0006, 3 }, { 0x0001, 4 }, { 0x000E, 4 }, { 0x0005, 3 }, { 0x0006, 3 }, { 0x0001, 4 }, { 0x000E, 4 },
{ 0x003C, 6 }, { 0x003D, 6 }, { 0x007C, 7 }, { 0x00FA, 8 }, { 0x003C, 6 }, { 0x003D, 6 }, { 0x007C, 7 }, { 0x00FA, 8 },
@ -97,7 +102,8 @@ static const uint16_t x8_dc_lowquant_table[8][34][2]={
{ 0x1F66, 13 }, { 0x1F67, 13 }, { 0x1F68, 13 }, { 0x1F69, 13 }, { 0x1F66, 13 }, { 0x1F67, 13 }, { 0x1F68, 13 }, { 0x1F69, 13 },
{ 0x1F6A, 13 }, { 0x1F6B, 13 }, { 0x1F6C, 13 }, { 0x1F6D, 13 }, { 0x1F6A, 13 }, { 0x1F6B, 13 }, { 0x1F6C, 13 }, { 0x1F6D, 13 },
{ 0x1F6E, 13 }, { 0x1F6F, 13 }, { 0x1F6E, 13 }, { 0x1F6F, 13 },
},{//4 },
{ // 4
{ 0x0000, 7 }, { 0x0001, 7 }, { 0x0002, 7 }, { 0x0003, 7 }, { 0x0000, 7 }, { 0x0001, 7 }, { 0x0002, 7 }, { 0x0003, 7 },
{ 0x0004, 7 }, { 0x0005, 7 }, { 0x0006, 7 }, { 0x0007, 7 }, { 0x0004, 7 }, { 0x0005, 7 }, { 0x0006, 7 }, { 0x0007, 7 },
{ 0x0008, 7 }, { 0x0009, 7 }, { 0x000A, 7 }, { 0x000B, 7 }, { 0x0008, 7 }, { 0x0009, 7 }, { 0x000A, 7 }, { 0x000B, 7 },
@ -107,7 +113,8 @@ static const uint16_t x8_dc_lowquant_table[8][34][2]={
{ 0x0016, 7 }, { 0x0017, 7 }, { 0x0018, 7 }, { 0x0019, 7 }, { 0x0016, 7 }, { 0x0017, 7 }, { 0x0018, 7 }, { 0x0019, 7 },
{ 0x001A, 7 }, { 0x001B, 7 }, { 0x001C, 7 }, { 0x001D, 7 }, { 0x001A, 7 }, { 0x001B, 7 }, { 0x001C, 7 }, { 0x001D, 7 },
{ 0x001E, 7 }, { 0x001F, 7 }, { 0x001E, 7 }, { 0x001F, 7 },
},{//5 },
{ // 5
{ 0x0000, 5 }, { 0x0001, 4 }, { 0x0001, 5 }, { 0x0008, 6 }, { 0x0000, 5 }, { 0x0001, 4 }, { 0x0001, 5 }, { 0x0008, 6 },
{ 0x0009, 6 }, { 0x000A, 6 }, { 0x0016, 7 }, { 0x000C, 6 }, { 0x0009, 6 }, { 0x000A, 6 }, { 0x0016, 7 }, { 0x000C, 6 },
{ 0x0017, 7 }, { 0x000D, 6 }, { 0x0038, 8 }, { 0x001D, 7 }, { 0x0017, 7 }, { 0x000D, 6 }, { 0x0038, 8 }, { 0x001D, 7 },
@ -117,7 +124,8 @@ static const uint16_t x8_dc_lowquant_table[8][34][2]={
{ 0x0785, 13 }, { 0x0786, 13 }, { 0x0787, 13 }, { 0x0788, 13 }, { 0x0785, 13 }, { 0x0786, 13 }, { 0x0787, 13 }, { 0x0788, 13 },
{ 0x0789, 13 }, { 0x078A, 13 }, { 0x078B, 13 }, { 0x078C, 13 }, { 0x0789, 13 }, { 0x078A, 13 }, { 0x078B, 13 }, { 0x078C, 13 },
{ 0x078D, 13 }, { 0x03C7, 12 }, { 0x078D, 13 }, { 0x03C7, 12 },
},{//6 },
{ // 6
{ 0x0000, 4 }, { 0x0001, 2 }, { 0x0001, 3 }, { 0x0004, 3 }, { 0x0000, 4 }, { 0x0001, 2 }, { 0x0001, 3 }, { 0x0004, 3 },
{ 0x0001, 4 }, { 0x000A, 4 }, { 0x0016, 5 }, { 0x002E, 6 }, { 0x0001, 4 }, { 0x000A, 4 }, { 0x0016, 5 }, { 0x002E, 6 },
{ 0x005E, 7 }, { 0x005F, 7 }, { 0x00C0, 8 }, { 0x3040, 14 }, { 0x005E, 7 }, { 0x005F, 7 }, { 0x00C0, 8 }, { 0x3040, 14 },
@ -127,7 +135,8 @@ static const uint16_t x8_dc_lowquant_table[8][34][2]={
{ 0x3045, 14 }, { 0x3046, 14 }, { 0x3047, 14 }, { 0x3048, 14 }, { 0x3045, 14 }, { 0x3046, 14 }, { 0x3047, 14 }, { 0x3048, 14 },
{ 0x3049, 14 }, { 0x304A, 14 }, { 0x304B, 14 }, { 0x304C, 14 }, { 0x3049, 14 }, { 0x304A, 14 }, { 0x304B, 14 }, { 0x304C, 14 },
{ 0x304D, 14 }, { 0x1827, 13 }, { 0x304D, 14 }, { 0x1827, 13 },
},{//7 },
{ // 7
{ 0x0000, 6 }, { 0x0001, 6 }, { 0x0002, 6 }, { 0x0006, 7 }, { 0x0000, 6 }, { 0x0001, 6 }, { 0x0002, 6 }, { 0x0006, 7 },
{ 0x0007, 7 }, { 0x0004, 6 }, { 0x0005, 6 }, { 0x0006, 6 }, { 0x0007, 7 }, { 0x0004, 6 }, { 0x0005, 6 }, { 0x0006, 6 },
{ 0x000E, 7 }, { 0x001E, 8 }, { 0x001F, 8 }, { 0x0040, 9 }, { 0x000E, 7 }, { 0x001E, 8 }, { 0x001F, 8 }, { 0x0040, 9 },
@ -137,7 +146,7 @@ static const uint16_t x8_dc_lowquant_table[8][34][2]={
{ 0x0834, 14 }, { 0x0835, 14 }, { 0x0836, 14 }, { 0x0837, 14 }, { 0x0834, 14 }, { 0x0835, 14 }, { 0x0836, 14 }, { 0x0837, 14 },
{ 0x0838, 14 }, { 0x0839, 14 }, { 0x083A, 14 }, { 0x083B, 14 }, { 0x0838, 14 }, { 0x0839, 14 }, { 0x083A, 14 }, { 0x083B, 14 },
{ 0x041E, 13 }, { 0x041F, 13 }, { 0x041E, 13 }, { 0x041F, 13 },
} },
}; };
static const uint16_t x8_dc_highquant_table[8][34][2] = { static const uint16_t x8_dc_highquant_table[8][34][2] = {
@ -151,7 +160,8 @@ static const uint16_t x8_dc_highquant_table[8][34][2]={
{ 0x005D, 8 }, { 0x05C7, 12 }, { 0x05C8, 12 }, { 0x05C9, 12 }, { 0x005D, 8 }, { 0x05C7, 12 }, { 0x05C8, 12 }, { 0x05C9, 12 },
{ 0x05CA, 12 }, { 0x05CB, 12 }, { 0x05CC, 12 }, { 0x05CD, 12 }, { 0x05CA, 12 }, { 0x05CB, 12 }, { 0x05CC, 12 }, { 0x05CD, 12 },
{ 0x05CE, 12 }, { 0x05CF, 12 }, { 0x05CE, 12 }, { 0x05CF, 12 },
},{//1 },
{ // 1
{ 0x0000, 3 }, { 0x0001, 3 }, { 0x0002, 3 }, { 0x0006, 4 }, { 0x0000, 3 }, { 0x0001, 3 }, { 0x0002, 3 }, { 0x0006, 4 },
{ 0x0007, 4 }, { 0x0004, 3 }, { 0x000A, 4 }, { 0x000B, 4 }, { 0x0007, 4 }, { 0x0004, 3 }, { 0x000A, 4 }, { 0x000B, 4 },
{ 0x0030, 6 }, { 0x0062, 7 }, { 0x0063, 7 }, { 0x0640, 11 }, { 0x0030, 6 }, { 0x0062, 7 }, { 0x0063, 7 }, { 0x0640, 11 },
@ -161,7 +171,8 @@ static const uint16_t x8_dc_highquant_table[8][34][2]={
{ 0x007A, 7 }, { 0x0646, 11 }, { 0x007B, 7 }, { 0x0647, 11 }, { 0x007A, 7 }, { 0x0646, 11 }, { 0x007B, 7 }, { 0x0647, 11 },
{ 0x0648, 11 }, { 0x0649, 11 }, { 0x064A, 11 }, { 0x064B, 11 }, { 0x0648, 11 }, { 0x0649, 11 }, { 0x064A, 11 }, { 0x064B, 11 },
{ 0x0326, 10 }, { 0x0327, 10 }, { 0x0326, 10 }, { 0x0327, 10 },
},{//2 },
{ // 2
{ 0x0000, 7 }, { 0x0001, 7 }, { 0x0001, 6 }, { 0x0004, 7 }, { 0x0000, 7 }, { 0x0001, 7 }, { 0x0001, 6 }, { 0x0004, 7 },
{ 0x0003, 6 }, { 0x0005, 7 }, { 0x0010, 8 }, { 0x0011, 8 }, { 0x0003, 6 }, { 0x0005, 7 }, { 0x0010, 8 }, { 0x0011, 8 },
{ 0x0240, 13 }, { 0x0241, 13 }, { 0x0242, 13 }, { 0x0243, 13 }, { 0x0240, 13 }, { 0x0241, 13 }, { 0x0242, 13 }, { 0x0243, 13 },
@ -171,7 +182,8 @@ static const uint16_t x8_dc_highquant_table[8][34][2]={
{ 0x0126, 12 }, { 0x0127, 12 }, { 0x0128, 12 }, { 0x0129, 12 }, { 0x0126, 12 }, { 0x0127, 12 }, { 0x0128, 12 }, { 0x0129, 12 },
{ 0x012A, 12 }, { 0x012B, 12 }, { 0x012C, 12 }, { 0x012D, 12 }, { 0x012A, 12 }, { 0x012B, 12 }, { 0x012C, 12 }, { 0x012D, 12 },
{ 0x012E, 12 }, { 0x012F, 12 }, { 0x012E, 12 }, { 0x012F, 12 },
},{//3 },
{ // 3
{ 0x0000, 4 }, { 0x0001, 3 }, { 0x0002, 3 }, { 0x0001, 4 }, { 0x0000, 4 }, { 0x0001, 3 }, { 0x0002, 3 }, { 0x0001, 4 },
{ 0x0006, 4 }, { 0x0004, 3 }, { 0x0005, 3 }, { 0x0006, 3 }, { 0x0006, 4 }, { 0x0004, 3 }, { 0x0005, 3 }, { 0x0006, 3 },
{ 0x000E, 5 }, { 0x000F, 5 }, { 0x0070, 7 }, { 0x0710, 11 }, { 0x000E, 5 }, { 0x000F, 5 }, { 0x0070, 7 }, { 0x0710, 11 },
@ -181,7 +193,8 @@ static const uint16_t x8_dc_highquant_table[8][34][2]={
{ 0x007E, 7 }, { 0x0716, 11 }, { 0x0717, 11 }, { 0x0718, 11 }, { 0x007E, 7 }, { 0x0716, 11 }, { 0x0717, 11 }, { 0x0718, 11 },
{ 0x007F, 7 }, { 0x0719, 11 }, { 0x071A, 11 }, { 0x071B, 11 }, { 0x007F, 7 }, { 0x0719, 11 }, { 0x071A, 11 }, { 0x071B, 11 },
{ 0x038E, 10 }, { 0x038F, 10 }, { 0x038E, 10 }, { 0x038F, 10 },
},{//4 },
{ // 4
{ 0x0000, 8 }, { 0x0001, 7 }, { 0x0002, 7 }, { 0x0003, 7 }, { 0x0000, 8 }, { 0x0001, 7 }, { 0x0002, 7 }, { 0x0003, 7 },
{ 0x0002, 9 }, { 0x0008, 8 }, { 0x0003, 9 }, { 0x0240, 14 }, { 0x0002, 9 }, { 0x0008, 8 }, { 0x0003, 9 }, { 0x0240, 14 },
{ 0x0241, 14 }, { 0x0242, 14 }, { 0x0243, 14 }, { 0x0244, 14 }, { 0x0241, 14 }, { 0x0242, 14 }, { 0x0243, 14 }, { 0x0244, 14 },
@ -191,7 +204,8 @@ static const uint16_t x8_dc_highquant_table[8][34][2]={
{ 0x0126, 13 }, { 0x0127, 13 }, { 0x0128, 13 }, { 0x0129, 13 }, { 0x0126, 13 }, { 0x0127, 13 }, { 0x0128, 13 }, { 0x0129, 13 },
{ 0x012A, 13 }, { 0x012B, 13 }, { 0x012C, 13 }, { 0x012D, 13 }, { 0x012A, 13 }, { 0x012B, 13 }, { 0x012C, 13 }, { 0x012D, 13 },
{ 0x012E, 13 }, { 0x012F, 13 }, { 0x012E, 13 }, { 0x012F, 13 },
},{//5 },
{ // 5
{ 0x0000, 7 }, { 0x0001, 7 }, { 0x0001, 6 }, { 0x0002, 6 }, { 0x0000, 7 }, { 0x0001, 7 }, { 0x0001, 6 }, { 0x0002, 6 },
{ 0x0003, 6 }, { 0x0004, 6 }, { 0x0005, 6 }, { 0x0006, 6 }, { 0x0003, 6 }, { 0x0004, 6 }, { 0x0005, 6 }, { 0x0006, 6 },
{ 0x0007, 6 }, { 0x0008, 6 }, { 0x0009, 6 }, { 0x000A, 6 }, { 0x0007, 6 }, { 0x0008, 6 }, { 0x0009, 6 }, { 0x000A, 6 },
@ -201,7 +215,8 @@ static const uint16_t x8_dc_highquant_table[8][34][2]={
{ 0x0017, 6 }, { 0x0018, 6 }, { 0x0019, 6 }, { 0x0001, 1 }, { 0x0017, 6 }, { 0x0018, 6 }, { 0x0019, 6 }, { 0x0001, 1 },
{ 0x001A, 6 }, { 0x001B, 6 }, { 0x001C, 6 }, { 0x001D, 6 }, { 0x001A, 6 }, { 0x001B, 6 }, { 0x001C, 6 }, { 0x001D, 6 },
{ 0x001E, 6 }, { 0x001F, 6 }, { 0x001E, 6 }, { 0x001F, 6 },
},{//6 },
{ // 6
{ 0x0000, 5 }, { 0x0001, 4 }, { 0x0001, 5 }, { 0x0004, 5 }, { 0x0000, 5 }, { 0x0001, 4 }, { 0x0001, 5 }, { 0x0004, 5 },
{ 0x000A, 6 }, { 0x0006, 5 }, { 0x000B, 6 }, { 0x000E, 6 }, { 0x000A, 6 }, { 0x0006, 5 }, { 0x000B, 6 }, { 0x000E, 6 },
{ 0x003C, 8 }, { 0x003D, 8 }, { 0x07C0, 13 }, { 0x07C1, 13 }, { 0x003C, 8 }, { 0x003D, 8 }, { 0x07C0, 13 }, { 0x07C1, 13 },
@ -211,7 +226,8 @@ static const uint16_t x8_dc_highquant_table[8][34][2]={
{ 0x007D, 9 }, { 0x07C7, 13 }, { 0x07C8, 13 }, { 0x07C9, 13 }, { 0x007D, 9 }, { 0x07C7, 13 }, { 0x07C8, 13 }, { 0x07C9, 13 },
{ 0x07CA, 13 }, { 0x07CB, 13 }, { 0x07CC, 13 }, { 0x07CD, 13 }, { 0x07CA, 13 }, { 0x07CB, 13 }, { 0x07CC, 13 }, { 0x07CD, 13 },
{ 0x07CE, 13 }, { 0x07CF, 13 }, { 0x07CE, 13 }, { 0x07CF, 13 },
},{//7 },
{ // 7
{ 0x0000, 7 }, { 0x0001, 7 }, { 0x0002, 7 }, { 0x0003, 7 }, { 0x0000, 7 }, { 0x0001, 7 }, { 0x0002, 7 }, { 0x0003, 7 },
{ 0x0004, 7 }, { 0x0005, 7 }, { 0x0006, 7 }, { 0x0007, 7 }, { 0x0004, 7 }, { 0x0005, 7 }, { 0x0006, 7 }, { 0x0007, 7 },
{ 0x0008, 7 }, { 0x0009, 7 }, { 0x000A, 7 }, { 0x000B, 7 }, { 0x0008, 7 }, { 0x0009, 7 }, { 0x000A, 7 }, { 0x000B, 7 },
@ -221,11 +237,10 @@ static const uint16_t x8_dc_highquant_table[8][34][2]={
{ 0x0016, 7 }, { 0x0017, 7 }, { 0x0018, 7 }, { 0x0019, 7 }, { 0x0016, 7 }, { 0x0017, 7 }, { 0x0018, 7 }, { 0x0019, 7 },
{ 0x001A, 7 }, { 0x001B, 7 }, { 0x001C, 7 }, { 0x001D, 7 }, { 0x001A, 7 }, { 0x001B, 7 }, { 0x001C, 7 }, { 0x001D, 7 },
{ 0x001E, 7 }, { 0x001F, 7 }, { 0x001E, 7 }, { 0x001F, 7 },
} },
}; };
#define MAX_DC_VLC_BITS 14 #define MAX_DC_VLC_BITS 14
static const uint16_t x8_ac0_lowquant_table[8][77][2] = { static const uint16_t x8_ac0_lowquant_table[8][77][2] = {
{ // 0 { // 0
{ 0x0000, 2 }, { 0x0002, 3 }, { 0x0006, 4 }, { 0x000E, 5 }, { 0x0000, 2 }, { 0x0002, 3 }, { 0x0006, 4 }, { 0x000E, 5 },
@ -248,7 +263,8 @@ static const uint16_t x8_ac0_lowquant_table[8][77][2]={
{ 0x3ED2, 14 }, { 0x3ED3, 14 }, { 0x3ED4, 14 }, { 0x3ED5, 14 }, { 0x3ED2, 14 }, { 0x3ED3, 14 }, { 0x3ED4, 14 }, { 0x3ED5, 14 },
{ 0x1F6B, 13 }, { 0x1F6C, 13 }, { 0x1F6D, 13 }, { 0x1F6E, 13 }, { 0x1F6B, 13 }, { 0x1F6C, 13 }, { 0x1F6D, 13 }, { 0x1F6E, 13 },
{ 0x1F6F, 13 }, { 0x1F6F, 13 },
},{//1 },
{ // 1
{ 0x0000, 3 }, { 0x0004, 5 }, { 0x0014, 7 }, { 0x000B, 6 }, { 0x0000, 3 }, { 0x0004, 5 }, { 0x0014, 7 }, { 0x000B, 6 },
{ 0x000C, 6 }, { 0x002A, 8 }, { 0x002B, 8 }, { 0x0034, 8 }, { 0x000C, 6 }, { 0x002A, 8 }, { 0x002B, 8 }, { 0x0034, 8 },
{ 0x0D40, 14 }, { 0x0D41, 14 }, { 0x001B, 7 }, { 0x0D42, 14 }, { 0x0D40, 14 }, { 0x0D41, 14 }, { 0x001B, 7 }, { 0x0D42, 14 },
@ -269,7 +285,8 @@ static const uint16_t x8_ac0_lowquant_table[8][77][2]={
{ 0x06B7, 13 }, { 0x06B8, 13 }, { 0x06B9, 13 }, { 0x06BA, 13 }, { 0x06B7, 13 }, { 0x06B8, 13 }, { 0x06B9, 13 }, { 0x06BA, 13 },
{ 0x06BB, 13 }, { 0x06BC, 13 }, { 0x06BD, 13 }, { 0x06BE, 13 }, { 0x06BB, 13 }, { 0x06BC, 13 }, { 0x06BD, 13 }, { 0x06BE, 13 },
{ 0x06BF, 13 }, { 0x06BF, 13 },
},{//2 },
{ // 2
{ 0x0000, 2 }, { 0x0002, 3 }, { 0x0003, 3 }, { 0x0008, 4 }, { 0x0000, 2 }, { 0x0002, 3 }, { 0x0003, 3 }, { 0x0008, 4 },
{ 0x0012, 5 }, { 0x0013, 5 }, { 0x0028, 6 }, { 0x0029, 6 }, { 0x0012, 5 }, { 0x0013, 5 }, { 0x0028, 6 }, { 0x0029, 6 },
{ 0x0054, 7 }, { 0x0055, 7 }, { 0x0056, 7 }, { 0x00AE, 8 }, { 0x0054, 7 }, { 0x0055, 7 }, { 0x0056, 7 }, { 0x00AE, 8 },
@ -290,7 +307,8 @@ static const uint16_t x8_ac0_lowquant_table[8][77][2]={
{ 0x7CB8, 15 }, { 0x7CB9, 15 }, { 0x7CBA, 15 }, { 0x7CBB, 15 }, { 0x7CB8, 15 }, { 0x7CB9, 15 }, { 0x7CBA, 15 }, { 0x7CBB, 15 },
{ 0x7CBC, 15 }, { 0x01F7, 9 }, { 0x7CBD, 15 }, { 0x7CBE, 15 }, { 0x7CBC, 15 }, { 0x01F7, 9 }, { 0x7CBD, 15 }, { 0x7CBE, 15 },
{ 0x7CBF, 15 }, { 0x7CBF, 15 },
},{//3 },
{ // 3
{ 0x0000, 2 }, { 0x0002, 3 }, { 0x0006, 4 }, { 0x000E, 5 }, { 0x0000, 2 }, { 0x0002, 3 }, { 0x0006, 4 }, { 0x000E, 5 },
{ 0x000F, 5 }, { 0x0020, 6 }, { 0x0021, 6 }, { 0x0044, 7 }, { 0x000F, 5 }, { 0x0020, 6 }, { 0x0021, 6 }, { 0x0044, 7 },
{ 0x0045, 7 }, { 0x008C, 8 }, { 0x008D, 8 }, { 0x011C, 9 }, { 0x0045, 7 }, { 0x008C, 8 }, { 0x008D, 8 }, { 0x011C, 9 },
@ -311,7 +329,8 @@ static const uint16_t x8_ac0_lowquant_table[8][77][2]={
{ 0x75F9, 15 }, { 0x75FA, 15 }, { 0x75FB, 15 }, { 0x75FC, 15 }, { 0x75F9, 15 }, { 0x75FA, 15 }, { 0x75FB, 15 }, { 0x75FC, 15 },
{ 0x75FD, 15 }, { 0x007F, 7 }, { 0x3AFF, 14 }, { 0x0F9E, 12 }, { 0x75FD, 15 }, { 0x007F, 7 }, { 0x3AFF, 14 }, { 0x0F9E, 12 },
{ 0x0F9F, 12 }, { 0x0F9F, 12 },
},{//4 },
{ // 4
{ 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0008, 5 }, { 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0008, 5 },
{ 0x0012, 6 }, { 0x0013, 6 }, { 0x0014, 6 }, { 0x002A, 7 }, { 0x0012, 6 }, { 0x0013, 6 }, { 0x0014, 6 }, { 0x002A, 7 },
{ 0x0016, 6 }, { 0x002B, 7 }, { 0x005C, 8 }, { 0x005D, 8 }, { 0x0016, 6 }, { 0x002B, 7 }, { 0x005C, 8 }, { 0x005D, 8 },
@ -332,7 +351,8 @@ static const uint16_t x8_ac0_lowquant_table[8][77][2]={
{ 0x03DD, 10 }, { 0x6715, 15 }, { 0x338B, 14 }, { 0x338C, 14 }, { 0x03DD, 10 }, { 0x6715, 15 }, { 0x338B, 14 }, { 0x338C, 14 },
{ 0x338D, 14 }, { 0x001F, 5 }, { 0x01EF, 9 }, { 0x338E, 14 }, { 0x338D, 14 }, { 0x001F, 5 }, { 0x01EF, 9 }, { 0x338E, 14 },
{ 0x338F, 14 }, { 0x338F, 14 },
},{//5 },
{ // 5
{ 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x000B, 5 }, { 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x000B, 5 },
{ 0x0018, 6 }, { 0x0019, 6 }, { 0x0034, 7 }, { 0x006A, 8 }, { 0x0018, 6 }, { 0x0019, 6 }, { 0x0034, 7 }, { 0x006A, 8 },
{ 0x006B, 8 }, { 0x006C, 8 }, { 0x00DA, 9 }, { 0x036C, 11 }, { 0x006B, 8 }, { 0x006C, 8 }, { 0x00DA, 9 }, { 0x036C, 11 },
@ -353,7 +373,8 @@ static const uint16_t x8_ac0_lowquant_table[8][77][2]={
{ 0x3787, 15 }, { 0x1BC4, 14 }, { 0x1BC5, 14 }, { 0x1BC6, 14 }, { 0x3787, 15 }, { 0x1BC4, 14 }, { 0x1BC5, 14 }, { 0x1BC6, 14 },
{ 0x1BC7, 14 }, { 0x001F, 5 }, { 0x03DD, 10 }, { 0x07B3, 11 }, { 0x1BC7, 14 }, { 0x001F, 5 }, { 0x03DD, 10 }, { 0x07B3, 11 },
{ 0x01EF, 9 }, { 0x01EF, 9 },
},{//6 },
{ // 6
{ 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x0016, 6 }, { 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x0016, 6 },
{ 0x0017, 6 }, { 0x0060, 8 }, { 0x00C2, 9 }, { 0x0186, 10 }, { 0x0017, 6 }, { 0x0060, 8 }, { 0x00C2, 9 }, { 0x0186, 10 },
{ 0x0187, 10 }, { 0x00C4, 9 }, { 0x3140, 15 }, { 0x3141, 15 }, { 0x0187, 10 }, { 0x00C4, 9 }, { 0x3140, 15 }, { 0x3141, 15 },
@ -374,7 +395,8 @@ static const uint16_t x8_ac0_lowquant_table[8][77][2]={
{ 0x3155, 15 }, { 0x3156, 15 }, { 0x3157, 15 }, { 0x3158, 15 }, { 0x3155, 15 }, { 0x3156, 15 }, { 0x3157, 15 }, { 0x3158, 15 },
{ 0x3159, 15 }, { 0x00FF, 8 }, { 0x18AD, 14 }, { 0x18AE, 14 }, { 0x3159, 15 }, { 0x00FF, 8 }, { 0x18AD, 14 }, { 0x18AE, 14 },
{ 0x18AF, 14 }, { 0x18AF, 14 },
},{//7 },
{ // 7
{ 0x0000, 4 }, { 0x0080, 11 }, { 0x0081, 11 }, { 0x0082, 11 }, { 0x0000, 4 }, { 0x0080, 11 }, { 0x0081, 11 }, { 0x0082, 11 },
{ 0x0083, 11 }, { 0x0084, 11 }, { 0x0085, 11 }, { 0x0086, 11 }, { 0x0083, 11 }, { 0x0084, 11 }, { 0x0085, 11 }, { 0x0086, 11 },
{ 0x0087, 11 }, { 0x0088, 11 }, { 0x0089, 11 }, { 0x008A, 11 }, { 0x0087, 11 }, { 0x0088, 11 }, { 0x0089, 11 }, { 0x008A, 11 },
@ -395,7 +417,7 @@ static const uint16_t x8_ac0_lowquant_table[8][77][2]={
{ 0x0077, 10 }, { 0x0078, 10 }, { 0x0079, 10 }, { 0x007A, 10 }, { 0x0077, 10 }, { 0x0078, 10 }, { 0x0079, 10 }, { 0x007A, 10 },
{ 0x007B, 10 }, { 0x007C, 10 }, { 0x007D, 10 }, { 0x007E, 10 }, { 0x007B, 10 }, { 0x007C, 10 }, { 0x007D, 10 }, { 0x007E, 10 },
{ 0x007F, 10 }, { 0x007F, 10 },
} },
}; };
static const uint16_t x8_ac0_highquant_table[8][77][2] = { static const uint16_t x8_ac0_highquant_table[8][77][2] = {
@ -420,7 +442,8 @@ static const uint16_t x8_ac0_highquant_table[8][77][2]={
{ 0x01FE, 9 }, { 0x0E99, 14 }, { 0x0E9A, 14 }, { 0x0E9B, 14 }, { 0x01FE, 9 }, { 0x0E99, 14 }, { 0x0E9A, 14 }, { 0x0E9B, 14 },
{ 0x0E9C, 14 }, { 0x01FF, 9 }, { 0x0E9D, 14 }, { 0x0E9E, 14 }, { 0x0E9C, 14 }, { 0x01FF, 9 }, { 0x0E9D, 14 }, { 0x0E9E, 14 },
{ 0x0E9F, 14 }, { 0x0E9F, 14 },
},{//1 },
{ // 1
{ 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0008, 5 }, { 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0008, 5 },
{ 0x0012, 6 }, { 0x0013, 6 }, { 0x0014, 6 }, { 0x0015, 6 }, { 0x0012, 6 }, { 0x0013, 6 }, { 0x0014, 6 }, { 0x0015, 6 },
{ 0x002C, 7 }, { 0x005A, 8 }, { 0x005B, 8 }, { 0x005C, 8 }, { 0x002C, 7 }, { 0x005A, 8 }, { 0x005B, 8 }, { 0x005C, 8 },
@ -441,7 +464,8 @@ static const uint16_t x8_ac0_highquant_table[8][77][2]={
{ 0x178B, 14 }, { 0x178C, 14 }, { 0x178D, 14 }, { 0x01EC, 9 }, { 0x178B, 14 }, { 0x178C, 14 }, { 0x178D, 14 }, { 0x01EC, 9 },
{ 0x178E, 14 }, { 0x001F, 5 }, { 0x00F7, 8 }, { 0x01ED, 9 }, { 0x178E, 14 }, { 0x001F, 5 }, { 0x00F7, 8 }, { 0x01ED, 9 },
{ 0x178F, 14 }, { 0x178F, 14 },
},{//2 },
{ // 2
{ 0x0000, 4 }, { 0x0002, 5 }, { 0x0180, 12 }, { 0x0181, 12 }, { 0x0000, 4 }, { 0x0002, 5 }, { 0x0180, 12 }, { 0x0181, 12 },
{ 0x0182, 12 }, { 0x0183, 12 }, { 0x0184, 12 }, { 0x0185, 12 }, { 0x0182, 12 }, { 0x0183, 12 }, { 0x0184, 12 }, { 0x0185, 12 },
{ 0x0186, 12 }, { 0x0187, 12 }, { 0x0188, 12 }, { 0x0189, 12 }, { 0x0186, 12 }, { 0x0187, 12 }, { 0x0188, 12 }, { 0x0189, 12 },
@ -462,7 +486,8 @@ static const uint16_t x8_ac0_highquant_table[8][77][2]={
{ 0x00F7, 11 }, { 0x00F8, 11 }, { 0x00F9, 11 }, { 0x00FA, 11 }, { 0x00F7, 11 }, { 0x00F8, 11 }, { 0x00F9, 11 }, { 0x00FA, 11 },
{ 0x00FB, 11 }, { 0x00FC, 11 }, { 0x00FD, 11 }, { 0x00FE, 11 }, { 0x00FB, 11 }, { 0x00FC, 11 }, { 0x00FD, 11 }, { 0x00FE, 11 },
{ 0x00FF, 11 }, { 0x00FF, 11 },
},{//3 },
{ // 3
{ 0x0000, 8 }, { 0x0001, 8 }, { 0x0002, 8 }, { 0x0003, 8 }, { 0x0000, 8 }, { 0x0001, 8 }, { 0x0002, 8 }, { 0x0003, 8 },
{ 0x0004, 8 }, { 0x0005, 8 }, { 0x0006, 8 }, { 0x0007, 8 }, { 0x0004, 8 }, { 0x0005, 8 }, { 0x0006, 8 }, { 0x0007, 8 },
{ 0x0008, 8 }, { 0x0009, 8 }, { 0x000A, 8 }, { 0x000B, 8 }, { 0x0008, 8 }, { 0x0009, 8 }, { 0x000A, 8 }, { 0x000B, 8 },
@ -483,7 +508,8 @@ static const uint16_t x8_ac0_highquant_table[8][77][2]={
{ 0x0037, 7 }, { 0x0038, 7 }, { 0x0039, 7 }, { 0x003A, 7 }, { 0x0037, 7 }, { 0x0038, 7 }, { 0x0039, 7 }, { 0x003A, 7 },
{ 0x003B, 7 }, { 0x003C, 7 }, { 0x003D, 7 }, { 0x003E, 7 }, { 0x003B, 7 }, { 0x003C, 7 }, { 0x003D, 7 }, { 0x003E, 7 },
{ 0x003F, 7 }, { 0x003F, 7 },
},{//4 },
{ // 4
{ 0x0000, 9 }, { 0x0001, 9 }, { 0x0002, 9 }, { 0x0003, 9 }, { 0x0000, 9 }, { 0x0001, 9 }, { 0x0002, 9 }, { 0x0003, 9 },
{ 0x0004, 9 }, { 0x0005, 9 }, { 0x0006, 9 }, { 0x0007, 9 }, { 0x0004, 9 }, { 0x0005, 9 }, { 0x0006, 9 }, { 0x0007, 9 },
{ 0x0008, 9 }, { 0x0009, 9 }, { 0x000A, 9 }, { 0x000B, 9 }, { 0x0008, 9 }, { 0x0009, 9 }, { 0x000A, 9 }, { 0x000B, 9 },
@ -504,7 +530,8 @@ static const uint16_t x8_ac0_highquant_table[8][77][2]={
{ 0x0037, 8 }, { 0x0038, 8 }, { 0x0039, 8 }, { 0x003A, 8 }, { 0x0037, 8 }, { 0x0038, 8 }, { 0x0039, 8 }, { 0x003A, 8 },
{ 0x003B, 8 }, { 0x003C, 8 }, { 0x003D, 8 }, { 0x003E, 8 }, { 0x003B, 8 }, { 0x003C, 8 }, { 0x003D, 8 }, { 0x003E, 8 },
{ 0x003F, 8 }, { 0x003F, 8 },
},{//5 },
{ // 5
{ 0x0000, 10 }, { 0x0001, 10 }, { 0x0002, 10 }, { 0x0003, 10 }, { 0x0000, 10 }, { 0x0001, 10 }, { 0x0002, 10 }, { 0x0003, 10 },
{ 0x0004, 10 }, { 0x0005, 10 }, { 0x0006, 10 }, { 0x0007, 10 }, { 0x0004, 10 }, { 0x0005, 10 }, { 0x0006, 10 }, { 0x0007, 10 },
{ 0x0008, 10 }, { 0x0009, 10 }, { 0x000A, 10 }, { 0x000B, 10 }, { 0x0008, 10 }, { 0x0009, 10 }, { 0x000A, 10 }, { 0x000B, 10 },
@ -525,7 +552,8 @@ static const uint16_t x8_ac0_highquant_table[8][77][2]={
{ 0x0037, 9 }, { 0x0038, 9 }, { 0x0039, 9 }, { 0x003A, 9 }, { 0x0037, 9 }, { 0x0038, 9 }, { 0x0039, 9 }, { 0x003A, 9 },
{ 0x003B, 9 }, { 0x003C, 9 }, { 0x003D, 9 }, { 0x003E, 9 }, { 0x003B, 9 }, { 0x003C, 9 }, { 0x003D, 9 }, { 0x003E, 9 },
{ 0x003F, 9 }, { 0x003F, 9 },
},{//6 },
{ // 6
{ 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x000B, 5 }, { 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x000B, 5 },
{ 0x0018, 6 }, { 0x0019, 6 }, { 0x0034, 7 }, { 0x006A, 8 }, { 0x0018, 6 }, { 0x0019, 6 }, { 0x0034, 7 }, { 0x006A, 8 },
{ 0x006B, 8 }, { 0x006C, 8 }, { 0x00DA, 9 }, { 0x00DB, 9 }, { 0x006B, 8 }, { 0x006C, 8 }, { 0x00DA, 9 }, { 0x00DB, 9 },
@ -546,7 +574,8 @@ static const uint16_t x8_ac0_highquant_table[8][77][2]={
{ 0x1BC9, 14 }, { 0x1BCA, 14 }, { 0x1BCB, 14 }, { 0x1BCC, 14 }, { 0x1BC9, 14 }, { 0x1BCA, 14 }, { 0x1BCB, 14 }, { 0x1BCC, 14 },
{ 0x1BCD, 14 }, { 0x001F, 5 }, { 0x036B, 10 }, { 0x1BCE, 14 }, { 0x1BCD, 14 }, { 0x001F, 5 }, { 0x036B, 10 }, { 0x1BCE, 14 },
{ 0x1BCF, 14 }, { 0x1BCF, 14 },
},{//7 },
{ // 7
{ 0x0000, 3 }, { 0x0002, 4 }, { 0x0006, 5 }, { 0x0007, 5 }, { 0x0000, 3 }, { 0x0002, 4 }, { 0x0006, 5 }, { 0x0007, 5 },
{ 0x0010, 6 }, { 0x0044, 8 }, { 0x0023, 7 }, { 0x0012, 6 }, { 0x0010, 6 }, { 0x0044, 8 }, { 0x0023, 7 }, { 0x0012, 6 },
{ 0x0026, 7 }, { 0x08A0, 13 }, { 0x004E, 8 }, { 0x004F, 8 }, { 0x0026, 7 }, { 0x08A0, 13 }, { 0x004E, 8 }, { 0x004F, 8 },
@ -567,7 +596,7 @@ static const uint16_t x8_ac0_highquant_table[8][77][2]={
{ 0x08B5, 13 }, { 0x08B6, 13 }, { 0x08B7, 13 }, { 0x00FB, 8 }, { 0x08B5, 13 }, { 0x08B6, 13 }, { 0x08B7, 13 }, { 0x00FB, 8 },
{ 0x045C, 12 }, { 0x003F, 6 }, { 0x045D, 12 }, { 0x045E, 12 }, { 0x045C, 12 }, { 0x003F, 6 }, { 0x045D, 12 }, { 0x045E, 12 },
{ 0x045F, 12 }, { 0x045F, 12 },
} },
}; };
static const uint16_t x8_ac1_lowquant_table[8][77][2] = { static const uint16_t x8_ac1_lowquant_table[8][77][2] = {
@ -592,7 +621,8 @@ static const uint16_t x8_ac1_lowquant_table[8][77][2]={
{ 0x3E82, 14 }, { 0x3E83, 14 }, { 0x3E84, 14 }, { 0x3E85, 14 }, { 0x3E82, 14 }, { 0x3E83, 14 }, { 0x3E84, 14 }, { 0x3E85, 14 },
{ 0x3E86, 14 }, { 0x003F, 6 }, { 0x01F5, 9 }, { 0x07D1, 11 }, { 0x3E86, 14 }, { 0x003F, 6 }, { 0x01F5, 9 }, { 0x07D1, 11 },
{ 0x3E87, 14 }, { 0x3E87, 14 },
},{//1 },
{ // 1
{ 0x0000, 2 }, { 0x0002, 3 }, { 0x0006, 4 }, { 0x000E, 5 }, { 0x0000, 2 }, { 0x0002, 3 }, { 0x0006, 4 }, { 0x000E, 5 },
{ 0x001E, 6 }, { 0x001F, 6 }, { 0x0040, 7 }, { 0x0082, 8 }, { 0x001E, 6 }, { 0x001F, 6 }, { 0x0040, 7 }, { 0x0082, 8 },
{ 0x0083, 8 }, { 0x0084, 8 }, { 0x010A, 9 }, { 0x010B, 9 }, { 0x0083, 8 }, { 0x0084, 8 }, { 0x010A, 9 }, { 0x010B, 9 },
@ -613,7 +643,8 @@ static const uint16_t x8_ac1_lowquant_table[8][77][2]={
{ 0x3DDB, 14 }, { 0x3DDC, 14 }, { 0x3DDD, 14 }, { 0x3DDE, 14 }, { 0x3DDB, 14 }, { 0x3DDC, 14 }, { 0x3DDD, 14 }, { 0x3DDE, 14 },
{ 0x3DDF, 14 }, { 0x003F, 6 }, { 0x07BC, 11 }, { 0x07BD, 11 }, { 0x3DDF, 14 }, { 0x003F, 6 }, { 0x07BC, 11 }, { 0x07BD, 11 },
{ 0x03DF, 10 }, { 0x03DF, 10 },
},{//2 },
{ // 2
{ 0x0000, 3 }, { 0x0002, 4 }, { 0x0006, 5 }, { 0x000E, 6 }, { 0x0000, 3 }, { 0x0002, 4 }, { 0x0006, 5 }, { 0x000E, 6 },
{ 0x001E, 7 }, { 0x003E, 8 }, { 0x003F, 8 }, { 0x0040, 8 }, { 0x001E, 7 }, { 0x003E, 8 }, { 0x003F, 8 }, { 0x0040, 8 },
{ 0x0104, 10 }, { 0x0083, 9 }, { 0x0105, 10 }, { 0x0108, 10 }, { 0x0104, 10 }, { 0x0083, 9 }, { 0x0105, 10 }, { 0x0108, 10 },
@ -634,7 +665,8 @@ static const uint16_t x8_ac1_lowquant_table[8][77][2]={
{ 0x212B, 15 }, { 0x212C, 15 }, { 0x212D, 15 }, { 0x212E, 15 }, { 0x212B, 15 }, { 0x212C, 15 }, { 0x212D, 15 }, { 0x212E, 15 },
{ 0x212F, 15 }, { 0x001F, 5 }, { 0x0597, 11 }, { 0x00BE, 8 }, { 0x212F, 15 }, { 0x001F, 5 }, { 0x0597, 11 }, { 0x00BE, 8 },
{ 0x00BF, 8 }, { 0x00BF, 8 },
},{//3 },
{ // 3
{ 0x0000, 2 }, { 0x0002, 3 }, { 0x0006, 4 }, { 0x0007, 4 }, { 0x0000, 2 }, { 0x0002, 3 }, { 0x0006, 4 }, { 0x0007, 4 },
{ 0x0010, 5 }, { 0x0011, 5 }, { 0x0024, 6 }, { 0x0025, 6 }, { 0x0010, 5 }, { 0x0011, 5 }, { 0x0024, 6 }, { 0x0025, 6 },
{ 0x0026, 6 }, { 0x0027, 6 }, { 0x0050, 7 }, { 0x0051, 7 }, { 0x0026, 6 }, { 0x0027, 6 }, { 0x0050, 7 }, { 0x0051, 7 },
@ -655,7 +687,8 @@ static const uint16_t x8_ac1_lowquant_table[8][77][2]={
{ 0x7882, 15 }, { 0x7883, 15 }, { 0x3C42, 14 }, { 0x3C43, 14 }, { 0x7882, 15 }, { 0x7883, 15 }, { 0x3C42, 14 }, { 0x3C43, 14 },
{ 0x3C44, 14 }, { 0x00FD, 8 }, { 0x3C45, 14 }, { 0x3C46, 14 }, { 0x3C44, 14 }, { 0x00FD, 8 }, { 0x3C45, 14 }, { 0x3C46, 14 },
{ 0x3C47, 14 }, { 0x3C47, 14 },
},{//4 },
{ // 4
{ 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x0016, 6 }, { 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x0016, 6 },
{ 0x0017, 6 }, { 0x0030, 7 }, { 0x0031, 7 }, { 0x0064, 8 }, { 0x0017, 6 }, { 0x0030, 7 }, { 0x0031, 7 }, { 0x0064, 8 },
{ 0x0065, 8 }, { 0x0066, 8 }, { 0x00CE, 9 }, { 0x00CF, 9 }, { 0x0065, 8 }, { 0x0066, 8 }, { 0x00CE, 9 }, { 0x00CF, 9 },
@ -676,7 +709,8 @@ static const uint16_t x8_ac1_lowquant_table[8][77][2]={
{ 0x07D4, 11 }, { 0x1A21, 14 }, { 0x1A22, 14 }, { 0x07D5, 11 }, { 0x07D4, 11 }, { 0x1A21, 14 }, { 0x1A22, 14 }, { 0x07D5, 11 },
{ 0x1A23, 14 }, { 0x003F, 6 }, { 0x01F6, 9 }, { 0x01F7, 9 }, { 0x1A23, 14 }, { 0x003F, 6 }, { 0x01F6, 9 }, { 0x01F7, 9 },
{ 0x03EB, 10 }, { 0x03EB, 10 },
},{//5 },
{ // 5
{ 0x0000, 2 }, { 0x0002, 3 }, { 0x0006, 4 }, { 0x000E, 5 }, { 0x0000, 2 }, { 0x0002, 3 }, { 0x0006, 4 }, { 0x000E, 5 },
{ 0x000F, 5 }, { 0x0020, 6 }, { 0x0021, 6 }, { 0x0044, 7 }, { 0x000F, 5 }, { 0x0020, 6 }, { 0x0021, 6 }, { 0x0044, 7 },
{ 0x0045, 7 }, { 0x0046, 7 }, { 0x008E, 8 }, { 0x008F, 8 }, { 0x0045, 7 }, { 0x0046, 7 }, { 0x008E, 8 }, { 0x008F, 8 },
@ -697,7 +731,8 @@ static const uint16_t x8_ac1_lowquant_table[8][77][2]={
{ 0x7E59, 15 }, { 0x7E5A, 15 }, { 0x7E5B, 15 }, { 0x7E5C, 15 }, { 0x7E59, 15 }, { 0x7E5A, 15 }, { 0x7E5B, 15 }, { 0x7E5C, 15 },
{ 0x7E5D, 15 }, { 0x007F, 7 }, { 0x3F2F, 14 }, { 0x07E6, 11 }, { 0x7E5D, 15 }, { 0x007F, 7 }, { 0x3F2F, 14 }, { 0x07E6, 11 },
{ 0x07E7, 11 }, { 0x07E7, 11 },
},{//6 },
{ // 6
{ 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0008, 5 }, { 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0008, 5 },
{ 0x0009, 5 }, { 0x0014, 6 }, { 0x0015, 6 }, { 0x002C, 7 }, { 0x0009, 5 }, { 0x0014, 6 }, { 0x0015, 6 }, { 0x002C, 7 },
{ 0x005A, 8 }, { 0x005B, 8 }, { 0x005C, 8 }, { 0x00BA, 9 }, { 0x005A, 8 }, { 0x005B, 8 }, { 0x005C, 8 }, { 0x00BA, 9 },
@ -718,7 +753,8 @@ static const uint16_t x8_ac1_lowquant_table[8][77][2]={
{ 0x6E96, 15 }, { 0x6E97, 15 }, { 0x374C, 14 }, { 0x374D, 14 }, { 0x6E96, 15 }, { 0x6E97, 15 }, { 0x374C, 14 }, { 0x374D, 14 },
{ 0x374E, 14 }, { 0x001F, 5 }, { 0x03D7, 10 }, { 0x01EF, 9 }, { 0x374E, 14 }, { 0x001F, 5 }, { 0x03D7, 10 }, { 0x01EF, 9 },
{ 0x374F, 14 }, { 0x374F, 14 },
},{//7 },
{ // 7
{ 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x0016, 6 }, { 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x0016, 6 },
{ 0x002E, 7 }, { 0x002F, 7 }, { 0x0060, 8 }, { 0x0061, 8 }, { 0x002E, 7 }, { 0x002F, 7 }, { 0x0060, 8 }, { 0x0061, 8 },
{ 0x00C4, 9 }, { 0x00C5, 9 }, { 0x00C6, 9 }, { 0x018E, 10 }, { 0x00C4, 9 }, { 0x00C5, 9 }, { 0x00C6, 9 }, { 0x018E, 10 },
@ -739,7 +775,7 @@ static const uint16_t x8_ac1_lowquant_table[8][77][2]={
{ 0x1F63, 14 }, { 0x1F64, 14 }, { 0x1F65, 14 }, { 0x1F66, 14 }, { 0x1F63, 14 }, { 0x1F64, 14 }, { 0x1F65, 14 }, { 0x1F66, 14 },
{ 0x1F67, 14 }, { 0x001F, 5 }, { 0x03ED, 11 }, { 0x00EF, 8 }, { 0x1F67, 14 }, { 0x001F, 5 }, { 0x03ED, 11 }, { 0x00EF, 8 },
{ 0x01F7, 10 }, { 0x01F7, 10 },
} },
}; };
static const uint16_t x8_ac1_highquant_table[8][77][2] = { static const uint16_t x8_ac1_highquant_table[8][77][2] = {
@ -764,7 +800,8 @@ static const uint16_t x8_ac1_highquant_table[8][77][2]={
{ 0x03E8, 10 }, { 0x368C, 14 }, { 0x368D, 14 }, { 0x03E9, 10 }, { 0x03E8, 10 }, { 0x368C, 14 }, { 0x368D, 14 }, { 0x03E9, 10 },
{ 0x368E, 14 }, { 0x003F, 6 }, { 0x01F5, 9 }, { 0x00FB, 8 }, { 0x368E, 14 }, { 0x003F, 6 }, { 0x01F5, 9 }, { 0x00FB, 8 },
{ 0x368F, 14 }, { 0x368F, 14 },
},{//1 },
{ // 1
{ 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x000B, 5 }, { 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x000B, 5 },
{ 0x0018, 6 }, { 0x0032, 7 }, { 0x0033, 7 }, { 0x0034, 7 }, { 0x0018, 6 }, { 0x0032, 7 }, { 0x0033, 7 }, { 0x0034, 7 },
{ 0x006A, 8 }, { 0x00D6, 9 }, { 0x00D7, 9 }, { 0x00D8, 9 }, { 0x006A, 8 }, { 0x00D6, 9 }, { 0x00D7, 9 }, { 0x00D8, 9 },
@ -785,7 +822,8 @@ static const uint16_t x8_ac1_highquant_table[8][77][2]={
{ 0x37C8, 14 }, { 0x37C9, 14 }, { 0x37CA, 14 }, { 0x37CB, 14 }, { 0x37C8, 14 }, { 0x37C9, 14 }, { 0x37CA, 14 }, { 0x37CB, 14 },
{ 0x37CC, 14 }, { 0x001F, 5 }, { 0x37CD, 14 }, { 0x37CE, 14 }, { 0x37CC, 14 }, { 0x001F, 5 }, { 0x37CD, 14 }, { 0x37CE, 14 },
{ 0x37CF, 14 }, { 0x37CF, 14 },
},{//2 },
{ // 2
{ 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0008, 5 }, { 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0008, 5 },
{ 0x0012, 6 }, { 0x0026, 7 }, { 0x0014, 6 }, { 0x0027, 7 }, { 0x0012, 6 }, { 0x0026, 7 }, { 0x0014, 6 }, { 0x0027, 7 },
{ 0x00A8, 9 }, { 0x00A9, 9 }, { 0x0055, 8 }, { 0x2B00, 15 }, { 0x00A8, 9 }, { 0x00A9, 9 }, { 0x0055, 8 }, { 0x2B00, 15 },
@ -806,7 +844,8 @@ static const uint16_t x8_ac1_highquant_table[8][77][2]={
{ 0x03E3, 10 }, { 0x158C, 14 }, { 0x158D, 14 }, { 0x01F4, 9 }, { 0x03E3, 10 }, { 0x158C, 14 }, { 0x158D, 14 }, { 0x01F4, 9 },
{ 0x158E, 14 }, { 0x003F, 6 }, { 0x00FB, 8 }, { 0x01F5, 9 }, { 0x158E, 14 }, { 0x003F, 6 }, { 0x00FB, 8 }, { 0x01F5, 9 },
{ 0x158F, 14 }, { 0x158F, 14 },
},{//3 },
{ // 3
{ 0x0000, 3 }, { 0x0002, 4 }, { 0x0006, 5 }, { 0x0007, 5 }, { 0x0000, 3 }, { 0x0002, 4 }, { 0x0006, 5 }, { 0x0007, 5 },
{ 0x0010, 6 }, { 0x0011, 6 }, { 0x0024, 7 }, { 0x0025, 7 }, { 0x0010, 6 }, { 0x0011, 6 }, { 0x0024, 7 }, { 0x0025, 7 },
{ 0x0013, 6 }, { 0x0014, 6 }, { 0x002A, 7 }, { 0x002B, 7 }, { 0x0013, 6 }, { 0x0014, 6 }, { 0x002A, 7 }, { 0x002B, 7 },
@ -827,7 +866,8 @@ static const uint16_t x8_ac1_highquant_table[8][77][2]={
{ 0x1C49, 13 }, { 0x1C4A, 13 }, { 0x1C4B, 13 }, { 0x1C4C, 13 }, { 0x1C49, 13 }, { 0x1C4A, 13 }, { 0x1C4B, 13 }, { 0x1C4C, 13 },
{ 0x1C4D, 13 }, { 0x00F5, 8 }, { 0x1C4E, 13 }, { 0x01E9, 9 }, { 0x1C4D, 13 }, { 0x00F5, 8 }, { 0x1C4E, 13 }, { 0x01E9, 9 },
{ 0x1C4F, 13 }, { 0x1C4F, 13 },
},{//4 },
{ // 4
{ 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x000B, 5 }, { 0x0000, 2 }, { 0x0004, 4 }, { 0x000A, 5 }, { 0x000B, 5 },
{ 0x0018, 6 }, { 0x0019, 6 }, { 0x0034, 7 }, { 0x0035, 7 }, { 0x0018, 6 }, { 0x0019, 6 }, { 0x0034, 7 }, { 0x0035, 7 },
{ 0x0036, 7 }, { 0x006E, 8 }, { 0x00DE, 9 }, { 0x00DF, 9 }, { 0x0036, 7 }, { 0x006E, 8 }, { 0x00DE, 9 }, { 0x00DF, 9 },
@ -848,7 +888,8 @@ static const uint16_t x8_ac1_highquant_table[8][77][2]={
{ 0x0FA4, 12 }, { 0x7D09, 15 }, { 0x7D0A, 15 }, { 0x7D0B, 15 }, { 0x0FA4, 12 }, { 0x7D09, 15 }, { 0x7D0A, 15 }, { 0x7D0B, 15 },
{ 0x3E86, 14 }, { 0x003F, 6 }, { 0x0FA5, 12 }, { 0x07D3, 11 }, { 0x3E86, 14 }, { 0x003F, 6 }, { 0x0FA5, 12 }, { 0x07D3, 11 },
{ 0x3E87, 14 }, { 0x3E87, 14 },
},{//5 },
{ // 5
{ 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0008, 5 }, { 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0008, 5 },
{ 0x0009, 5 }, { 0x0014, 6 }, { 0x002A, 7 }, { 0x0056, 8 }, { 0x0009, 5 }, { 0x0014, 6 }, { 0x002A, 7 }, { 0x0056, 8 },
{ 0x02B8, 11 }, { 0x00AF, 9 }, { 0x02B9, 11 }, { 0x015D, 10 }, { 0x02B8, 11 }, { 0x00AF, 9 }, { 0x02B9, 11 }, { 0x015D, 10 },
@ -869,7 +910,8 @@ static const uint16_t x8_ac1_highquant_table[8][77][2]={
{ 0x3D52, 14 }, { 0x3D53, 14 }, { 0x3D54, 14 }, { 0x01FA, 9 }, { 0x3D52, 14 }, { 0x3D53, 14 }, { 0x3D54, 14 }, { 0x01FA, 9 },
{ 0x3D55, 14 }, { 0x007F, 7 }, { 0x01FB, 9 }, { 0x3D56, 14 }, { 0x3D55, 14 }, { 0x007F, 7 }, { 0x01FB, 9 }, { 0x3D56, 14 },
{ 0x3D57, 14 }, { 0x3D57, 14 },
},{//6 },
{ // 6
{ 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0008, 5 }, { 0x0000, 3 }, { 0x0002, 4 }, { 0x0003, 4 }, { 0x0008, 5 },
{ 0x0009, 5 }, { 0x000A, 5 }, { 0x000B, 5 }, { 0x0018, 6 }, { 0x0009, 5 }, { 0x000A, 5 }, { 0x000B, 5 }, { 0x0018, 6 },
{ 0x0032, 7 }, { 0x000D, 5 }, { 0x0033, 7 }, { 0x0E00, 13 }, { 0x0032, 7 }, { 0x000D, 5 }, { 0x0033, 7 }, { 0x0E00, 13 },
@ -890,7 +932,8 @@ static const uint16_t x8_ac1_highquant_table[8][77][2]={
{ 0x0719, 12 }, { 0x071A, 12 }, { 0x071B, 12 }, { 0x071C, 12 }, { 0x0719, 12 }, { 0x071A, 12 }, { 0x071B, 12 }, { 0x071C, 12 },
{ 0x071D, 12 }, { 0x001F, 5 }, { 0x071E, 12 }, { 0x0071, 7 }, { 0x071D, 12 }, { 0x001F, 5 }, { 0x071E, 12 }, { 0x0071, 7 },
{ 0x071F, 12 }, { 0x071F, 12 },
},{//7 },
{ // 7
{ 0x0000, 3 }, { 0x0002, 4 }, { 0x0006, 5 }, { 0x000E, 6 }, { 0x0000, 3 }, { 0x0002, 4 }, { 0x0006, 5 }, { 0x000E, 6 },
{ 0x000F, 6 }, { 0x0040, 8 }, { 0x0041, 8 }, { 0x0042, 8 }, { 0x000F, 6 }, { 0x0040, 8 }, { 0x0041, 8 }, { 0x0042, 8 },
{ 0x0218, 11 }, { 0x2190, 15 }, { 0x2191, 15 }, { 0x2192, 15 }, { 0x0218, 11 }, { 0x2190, 15 }, { 0x2191, 15 }, { 0x2192, 15 },
@ -911,7 +954,7 @@ static const uint16_t x8_ac1_highquant_table[8][77][2]={
{ 0x21B7, 15 }, { 0x21B8, 15 }, { 0x21B9, 15 }, { 0x03E3, 10 }, { 0x21B7, 15 }, { 0x21B8, 15 }, { 0x21B9, 15 }, { 0x03E3, 10 },
{ 0x10DD, 14 }, { 0x007F, 7 }, { 0x01FB, 9 }, { 0x10DE, 14 }, { 0x10DD, 14 }, { 0x007F, 7 }, { 0x01FB, 9 }, { 0x10DE, 14 },
{ 0x10DF, 14 }, { 0x10DF, 14 },
} },
}; };
#define MAX_AC_VLC_BITS 16 #define MAX_AC_VLC_BITS 16