From c609a04c8b4fc564849b69b59ac5366514157fa8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?St=C3=A9phane=20Borel?= Date: Mon, 10 Jan 2000 01:09:37 +0000 Subject: [PATCH] =?UTF-8?q?*=20Modifications=20d'erreurs=20dans=20=20Macro?= =?UTF-8?q?BlockAddressIncrement=20*=20Ajout=20des=20fonctions=20vpar=5F*M?= =?UTF-8?q?Btype=20*=20Ajout=20de=20tables=20de=20lookup=20(pour=20les=20t?= =?UTF-8?q?ableaux=20B1=20=EF=BF=BD=20B4=20et=20B9)=20*=20Ajout=20de=20vpa?= =?UTF-8?q?r=5FCodedPattern420?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Il manque encore pas mal de fonctions (en particulier DecodeMPEG) --- include/video_parser.h | 10 +- include/vpar_blocks.h | 19 +- include/vpar_headers.h | 12 -- src/video_parser/video_parser.c | 4 + src/video_parser/vpar_blocks.c | 370 +++++++++++++++++++++++++------- 5 files changed, 319 insertions(+), 96 deletions(-) diff --git a/include/video_parser.h b/include/video_parser.h index 3a464d7dee..d29a377e60 100644 --- a/include/video_parser.h +++ b/include/video_parser.h @@ -63,7 +63,15 @@ typedef struct vpar_thread_s s16 pi_crop_buf[65536]; s16 * pi_crop; #endif - mb_addr_inc_t mb_addr_inc[2048]; + lookup_t pl_mb_addr_inc[2048]; /* for macroblock + address increment */ + /* variable length codes for the structure dct_dc_size */ + lookup_t pppl_dct_dc_size[2][2][32]; + lookup_t pppl_dct_dc_size[2][2][32]; + /* tables for macroblock types 0=P 1=B */ + lookup_t pl_mb_type[2][64]; + /* table for coded_block_pattern */ + lookup_t pl_coded_pattern[512]; #ifdef STATS /* Statistics */ diff --git a/include/vpar_blocks.h b/include/vpar_blocks.h index 4ba49cd824..3fe5feeeec 100644 --- a/include/vpar_blocks.h +++ b/include/vpar_blocks.h @@ -61,12 +61,24 @@ typedef struct boolean_t b_dmv; /* AddressIncrement information */ int i_addr_inc; + + /* Macroblock Type */ int i_coded_block_pattern; boolean_t b_dct_type; int i_l_x, i_l_y, i_c_x, i_c_y; } macroblock_parsing_t; +/****************************************************************************** + * lookup_t : entry type for lookup tables * + ******************************************************************************/ + +typedef struct lookup_s +{ + int i_value; + int i_length; +} lookup_t; + /***************************************************************************** * Standard codes *****************************************************************************/ @@ -84,8 +96,11 @@ typedef struct #define MOTION_DMV 3 /* Macroblock Address Increment types */ -#define MACROBLOCK_ESCAPE 8 -#define MACROBLOCK_STUFFING 15 +#define MB_ADDRINC_ESCAPE 8 +#define MB_ADDRINC_STUFFING 15 + +/* Error constant for lookup tables */ +#define MB_ERROR (-1) /* Scan */ #define SCAN_ZIGZAG 0 diff --git a/include/vpar_headers.h b/include/vpar_headers.h index 9b97d63146..5036f0b94b 100644 --- a/include/vpar_headers.h +++ b/include/vpar_headers.h @@ -115,18 +115,6 @@ typedef struct slice_parsing_s int pppi_pmv[2][2][2]; /* Motion vect predictors, 7.6.3 */ } slice_parsing_t; - -/***************************************************************************** - * mb_addr_inc_t : entry type for MacroblockAddressIncrement lookup table * - *****************************************************************************/ - -typedef struct mb_addr_inc_s -{ - int i_value; - int i_length; -} mb_addr_inc_t; - - /***************************************************************************** * Standard codes *****************************************************************************/ diff --git a/src/video_parser/video_parser.c b/src/video_parser/video_parser.c index 90ecbfe626..4af81c5337 100644 --- a/src/video_parser/video_parser.c +++ b/src/video_parser/video_parser.c @@ -226,6 +226,10 @@ static int InitThread( vpar_thread_t *p_vpar ) vpar_InitCrop( p_vpar ); #endif InitMbAddrInc( p_vpar ); + InitDCTTables( p_vpar ); + InitPMBType( p_vpar ); + InitBMBType( p_vpar ); + InitCodedPattern( p_vpar ); /* Mark thread as running and return */ intf_DbgMsg("vpar debug: InitThread(%p) succeeded\n", p_vpar); diff --git a/src/video_parser/vpar_blocks.c b/src/video_parser/vpar_blocks.c index adab006f95..00afe5188b 100644 --- a/src/video_parser/vpar_blocks.c +++ b/src/video_parser/vpar_blocks.c @@ -168,80 +168,234 @@ void vpar_InitCrop( vpar_thread_t * p_vpar ) * InitMbAddrInc : Initialize the lookup table for mb_addr_inc * *****************************************************************************/ +/* Fonction for filling up the lookup table for mb_addr_inc */ +void __inline__ FillMbAddrIncTable( vpar_thread_t * p_vpar, + int i_start, int i_end, int i_step, + int * pi_value, int i_length ) +{ + int i_dummy, i_dummy2; + for( i_dummy = i_start, i_dummy < i_end, i_dummy += i_step ) + for( i_dummy2 = 0, i_dummy2 < i_step, i_dummy2 ++ ) + { + p_vpar->pl_mb_addr_inc[i_dummy + i_dummy2].value = * pi_value; + p_vpar->pl_mb_addr_inc[i_dummy + i_dummy2].length = i_length; + } + i_value --; +} + +/* Fonction that initialize the table using the last one */ void InitMbAddrInc( vpar_thread_t * p_vpar ) { - bzero( &p_vpar->mb_addr_inc, 4096*sizeof( int ) ); - p_vpar->mb_addr_inc[8].i_value = MACROBLOCK_ESCAPE; - p_vpar->mb_addr_inc[15].i_value = MACROBLOCK_STUFFING; - p_vpar->mb_addr_inc[24].i_value = 33; - p_vpar->mb_addr_inc[25].i_value = 32; - p_vpar->mb_addr_inc[26].i_value = 31; - p_vpar->mb_addr_inc[27].i_value = 30; - p_vpar->mb_addr_inc[28].i_value = 29; - p_vpar->mb_addr_inc[29].i_value = 28; - p_vpar->mb_addr_inc[30].i_value = 27; - p_vpar->mb_addr_inc[31].i_value = 26; - p_vpar->mb_addr_inc[32].i_value = 25; - p_vpar->mb_addr_inc[33].i_value = 24; - p_vpar->mb_addr_inc[34].i_value = 23; - p_vpar->mb_addr_inc[35].i_value = 22; - p_vpar->mb_addr_inc[36].i_value = 21; - p_vpar->mb_addr_inc[38].i_value = 20; - p_vpar->mb_addr_inc[40].i_value = 19; - p_vpar->mb_addr_inc[42].i_value = 18; - p_vpar->mb_addr_inc[44].i_value = 17; - p_vpar->mb_addr_inc[46].i_value = 16; - p_vpar->mb_addr_inc[48].i_value = 15; - p_vpar->mb_addr_inc[56].i_value = 14; - p_vpar->mb_addr_inc[64].i_value = 13; - p_vpar->mb_addr_inc[72].i_value = 12; - p_vpar->mb_addr_inc[80].i_value = 11; - p_vpar->mb_addr_inc[88].i_value = 10; - p_vpar->mb_addr_inc[96].i_value = 9; - p_vpar->mb_addr_inc[112].i_value = 8; - p_vpar->mb_addr_inc[128].i_value = 7; - p_vpar->mb_addr_inc[192].i_value = 6; - p_vpar->mb_addr_inc[256].i_value = 5; - p_vpar->mb_addr_inc[384].i_value = 4; - p_vpar->mb_addr_inc[512].i_value = 3; - p_vpar->mb_addr_inc[768].i_value = 2; - p_vpar->mb_addr_inc[1024].i_value = 1; - /* Length of the variable length code */ - p_vpar->mb_addr_inc[8].i_length = 11; - p_vpar->mb_addr_inc[15].i_length = 11; - p_vpar->mb_addr_inc[24].i_length = 11; - p_vpar->mb_addr_inc[25].i_length = 11; - p_vpar->mb_addr_inc[26].i_length = 11; - p_vpar->mb_addr_inc[27].i_length = 11; - p_vpar->mb_addr_inc[28].i_length = 11; - p_vpar->mb_addr_inc[29].i_length = 11; - p_vpar->mb_addr_inc[30].i_length = 11; - p_vpar->mb_addr_inc[31].i_length = 11; - p_vpar->mb_addr_inc[32].i_length = 11; - p_vpar->mb_addr_inc[33].i_length = 11; - p_vpar->mb_addr_inc[34].i_length = 11; - p_vpar->mb_addr_inc[35].i_length = 11; - p_vpar->mb_addr_inc[36].i_length = 10; - p_vpar->mb_addr_inc[38].i_length = 10; - p_vpar->mb_addr_inc[40].i_length = 10; - p_vpar->mb_addr_inc[42].i_length = 10; - p_vpar->mb_addr_inc[44].i_length = 10; - p_vpar->mb_addr_inc[46].i_length = 10; - p_vpar->mb_addr_inc[48].i_length = 8; - p_vpar->mb_addr_inc[56].i_length = 8; - p_vpar->mb_addr_inc[64].i_length = 8; - p_vpar->mb_addr_inc[72].i_length = 8; - p_vpar->mb_addr_inc[80].i_length = 8; - p_vpar->mb_addr_inc[88].i_length = 8; - p_vpar->mb_addr_inc[96].i_length = 7; - p_vpar->mb_addr_inc[112].i_length = 7; - p_vpar->mb_addr_inc[128].i_length = 5; - p_vpar->mb_addr_inc[192].i_length = 5; - p_vpar->mb_addr_inc[256].i_length = 4; - p_vpar->mb_addr_inc[384].i_length = 4; - p_vpar->mb_addr_inc[512].i_length = 3; - p_vpar->mb_addr_inc[768].i_length = 3; - p_vpar->mb_addr_inc[1024].i_length = 1; + int i_dummy; + int * pi_value; + for (i_dummy = 0; i_dummy < 8; i_dummy++) + { + p_vpar->pl_mb_addr_inc[i_dummy].i_value = MB_ERROR; + p_vpar->pl_mb_addr_inc[i_dummy].i_length = 0; + } + + p_vpar->pl_mb_addr_inc[8].i_value = MB_ADDRINC_ESCAPE; + p_vpar->pl_mb_addr_inc[8].i_length = 11; + + for (i_dummy = 9; i_dummy < 15; i_dummy ++) + { + p_vpar->pl_mb_addr_inc[i_dummy].i_value = MB_ERROR; + p_vpar->pl_mb_addr_inc[i_dummy].i_length = 0; + } + + p_vpar->pl_mb_addr_inc[15].i_value = MB_ADDRINC_STUFFING; + p_vpar->pl_mb_addr_inc[15].i_length = 11; + + for (i = 16; i < 24; i++) + { + p_vpar->pl_mb_addr_inc[i_dummy].i_value = MB_ERROR; + p_vpar->pl_mb_addr_inc[i_dummy].i_length = 0; + } + pi_value = (int *) malloc( sizeof( int ) ); + * pi_value = 33; + FillMbAddrIncTable( p_vpar, 1024, 2048, 1024, pi_value, 1 ); + FillMbAddrIncTable( p_vpar, 512, 1024, 256, pi_value, 3 ); + FillMbAddrIncTable( p_vpar, 256, 512, 128, pi_value, 4 ); + FillMbAddrIncTable( p_vpar, 128, 256, 64, pi_value, 5 ); + FillMbAddrIncTable( p_vpar, 96, 128, 16, pi_value, 7 ); + FillMbAddrIncTable( p_vpar, 48, 96, 8, pi_value, 8 ); + FillMbAddrIncTable( p_vpar, 36, 48, 2, pi_value, 10 ); + FillMbAddrIncTable( p_vpar, 24, 36, 1, pi_value, 11 ); +} +/***************************************************************************** + * InitDCT : Initialize tables giving the length of the dct coefficient + * from the vlc code + *****************************************************************************/ + +void InitDCTTables( vpar_thread_t * p_vpar ) +{ + /* Tables are cut in two parts to reduce memory occupation */ + + /* Table B-12, dct_dc_size_luminance, codes 00xxx ... 11110 */ + p_vpar->pppl_dct_dc_size[0][0] = + { {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, + {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, + {0, 3}, {0, 3}, {0, 3}, {0, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, + {4, 3}, {4, 3}, {4, 3}, {4, 3}, {5, 4}, {5, 4}, {6, 5}, {MB_ERROR, 0} + }; + + /* Table B-12, dct_dc_size_luminance, codes 111110xxx ... 111111111 */ + p_vpar->pppl_dct_dc_lum_size[1][0] = + { {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, + {8, 7}, {8, 7}, {8, 7}, {8, 7}, {9, 8}, {9, 8}, {10,9}, {11,9} + {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, + {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, + {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, + {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0} + }; + + /* Table B-13, dct_dc_size_chrominance, codes 00xxx ... 11110 */ + p_vpar->pppl_dct_dc_chrom_size[0][1] = + { {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, + {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, + {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, + {3, 3}, {3, 3}, {3, 3}, {3, 3}, {4, 4}, {4, 4}, {5, 5}, {MB_ERROR, 0} + }; + + /* Table B-13, dct_dc_size_chrominance, codes 111110xxxx ... 1111111111 */ + p_vpar->pppl_dct_dc_size[1][1] = + { {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, + {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, + {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, + {8, 8}, {8, 8}, {8, 8}, {8, 8}, {9, 9}, {9, 9}, {10,10}, {11,10} + }; + +} + +/***************************************************************************** + * Init*MBType : Initialize lookup table for the Macroblock type * + * ***************************************************************************/ + +/* Fonction for filling up the tables */ +static void __inline__ FillMBType( vpar_thread_t * p_vpar, + int i_mb_type, + int i_start, + int i_end, + int i_value, + int i_length ) +{ + int i_dummy; + for( i_dummy = i_start, i_dummy < i_end, i++ ) + { + p_vpar->pm_mb_type[i_mb_type][i_dummy].i_value = i_value; + p_vpar->pm_mb_type[i_mb_type][i_dummy].i_length = i_length; + } +} + +/* Fonction that fills the table for P MB_Type */ +void InitPMBType( vpar_thread_t * p_vpar ) +{ + FillMBType( p_vpar, 0, 32, 64, MB_MOTION_FORWARD|MB_PATTERN, 1 ); + FillMBType( p_vpar, 0, 16, 32, MB_PATTERN, 2 ); + FillMBType( p_vpar, 0, 8, 16, MB_MOTION_FORWARD, 3 ); + FillMBType( p_vpar, 0, 6, 8, MB_INTRA, 5 ); + FillMBType( p_vpar, 0, 4, 6, MB_QUANT|MB_MOTION_FORWARD|PATTERN, 5 ); + FillMBType( p_vpar, 0, 2, 4, MB_QUANT|MB_PATTERN, 5 ); + p_vpar->pm_mb_type[0][1].i_value = MB_QUANT|MB_INTRA; + p_vpar->pm_mb_type[0][1].i_length = 6; + p_vpar->pm_mb_type[0][0].i_value = MB_ERROR; + p_vpar->pm_mb_type[0][0].i_length = 0; +} + +/* Fonction that fills the table for B MB_Type */ +void InitBMBType( vpar_thread_t * p_vpar ) +{ + FillMBType( p_vpar, 1, 48, 64, MB_MOTION_FORWARD + |MB_MOTION_BACKWARD|MB_PATTERN, 2 ); + FillMBType( p_vpar, 1, 32, 48, MB_MOTION_FORWARD|MB_MOTION_BACKWARD, 2 ); + FillMBType( p_vpar, 1, 24, 32, MB_MOTION_BACKWARD|MB_PATTERN, 3 ); + FillMBType( p_vpar, 1, 16, 24, MB_MOTION_BACKWARD, 3 ); + FillMBType( p_vpar, 1, 12, 16, MB_MOTION_FORWARD|MB_PATTERN, 4 ); + FillMBType( p_vpar, 1, 8, 12, MB_MOTION_FORWARD, 4 ); + FillMBType( p_vpar, 1, 6, 8, MB_INTRA, 5 ); + FillMBType( p_vpar, 1, 4, 6, MB_QUANT|MB_MOTION_FORWARD + |MB_MOTION_BACKWARD|MB_PATTERN, 5 ); + p_vpar->pm_mb_type[1][3].i_value = MB_QUANT|MB_MOTION_FORWARD|MB_PATTERN + p_vpar->pm_mb_type[1][3].i_length = 6; + p_vpar->pm_mb_type[1][2].i_value = MB_QUANT|MB_MOTION_BACKWARD|MB_PATTERN; + p_vpar->pm_mb_type[1][2].i_length = 6; + p_vpar->pm_mb_type[1][1].i_value = MB_QUANT|MB_INTRA; + p_vpar->pm_mb_type[1][1].i_length = 6; + p_vpar->pm_mb_type[1][0].i_value =MB_ERROR; + p_vpar->pm_mb_type[1][0].i_length = 0; +} + +/***************************************************************************** + * InitCodedPattern : Initialize the lookup table for decoding + * coded block pattern + *****************************************************************************/ +void InitCodedPattern( vpar_thread_t * p_vpar ) +{ + p_vpar->pl_coded_pattern = + { {(unsigned int)ERROR, 0}, {(unsigned int)ERROR, 0}, {39, 9}, {27, 9}, {59, 9}, {55, 9}, {47, 9}, {31, 9}, + {58, 8}, {58, 8}, {54, 8}, {54, 8}, {46, 8}, {46, 8}, {30, 8}, {30, 8}, + {57, 8}, {57, 8}, {53, 8}, {53, 8}, {45, 8}, {45, 8}, {29, 8}, {29, 8}, + {38, 8}, {38, 8}, {26, 8}, {26, 8}, {37, 8}, {37, 8}, {25, 8}, {25, 8}, + {43, 8}, {43, 8}, {23, 8}, {23, 8}, {51, 8}, {51, 8}, {15, 8}, {15, 8}, + {42, 8}, {42, 8}, {22, 8}, {22, 8}, {50, 8}, {50, 8}, {14, 8}, {14, 8}, + {41, 8}, {41, 8}, {21, 8}, {21, 8}, {49, 8}, {49, 8}, {13, 8}, {13, 8}, + {35, 8}, {35, 8}, {19, 8}, {19, 8}, {11, 8}, {11, 8}, {7, 8}, {7, 8}, + {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7}, + {10, 7}, {10, 7}, {10, 7}, {10, 7}, {6, 7}, {6, 7}, {6, 7}, {6, 7}, + {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7}, + {9, 7}, {9, 7}, {9, 7}, {9, 7}, {5, 7}, {5, 7}, {5, 7}, {5, 7}, + {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, + {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, + {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, + {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, + {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, + {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, + {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, + {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, + {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, + {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, + {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, + {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, + {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, + {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, + {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, + {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, + {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, + {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, + {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, + {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, + {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, + {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, + {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, + {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, + {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, + {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, + {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, + {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, + {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, + {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, + {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, + {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, + {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, + {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, + {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, + {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, + {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, + {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, + {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, + {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, + {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, + {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, + {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, + {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, + {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, + {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, + {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, + {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, + {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, + {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, + {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, + {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3} }; } /* @@ -499,7 +653,7 @@ static __inline__ int MacroblockAddressIncrement( vpar_thread_t * p_vpar ) { /* Index in the lookup table mb_addr_inc */ int i_index = ShowBits( &p_vpar->bit_stream, 11 ); - p_vpar->mb.i_addr_inc = 0; + p_vpar->pl_mb.i_addr_inc = 0; /* Test the presence of the escape character */ while( i_index == 8 ) { @@ -508,9 +662,9 @@ static __inline__ int MacroblockAddressIncrement( vpar_thread_t * p_vpar ) i_index = ShowBits( &p_vpar->bit_stream, 11 ); } /* Affect the value from the lookup table */ - p_vpar->mb.i_addr_inc += p_vpar->mb_addr_inc[i_index].i_value; + p_vpar->pl_mb.i_addr_inc += p_vpar->pl_mb_addr_inc[i_index].i_value; /* Dump the good number of bits */ - DumpBits( &p_vpar->bit_stream, p_vpar->mb_addr_inc[i_index].i_length ); + DumpBits( &p_vpar->bit_stream, p_vpar->pl_mb_addr_inc[i_index].i_length ); } /***************************************************************************** @@ -580,7 +734,16 @@ static __inline__ void MacroblockModes( vpar_thread_t * p_vpar, *****************************************************************************/ int vpar_IMBType( vpar_thread_t * p_vpar ) { - /* À pomper dans Berkeley */ + /* Take two bits for testing */ + int i_type = ShowBits( &p_vpar->bit_stream, 2 ); + /* Lookup table for macroblock_type */ + static lookup_t pl_mb_Itype[4] = { {MB_ERROR, 0}, + {MB_QUANT|MB_INTRA, 2}, + {MB_INTRA, 1}, + {MB_INTRA, 2} }; + /* Dump the good number of bits */ + DumpBits( &p_vpar->bit_stream, pl_mb_Itype[i_type].i_length ); + return pl_mb_Itype[i_type]; } /***************************************************************************** @@ -588,7 +751,12 @@ int vpar_IMBType( vpar_thread_t * p_vpar ) *****************************************************************************/ int vpar_PMBType( vpar_thread_t * p_vpar ) { - /* À pomper dans Berkeley */ + /* Testing on 6 bits */ + int i_type = ShowBits( &p_vpar->bit_stream, 6 ); + /* Dump the good number of bits */ + DumpBits( &p_vpar->bit_stream, p_vpar->pm_mb_type[0][i_type].i_length ); + /* return the value from the lookup table for P type */ + return p_vpar->pm_mb_type[0][i_type].i_value; } /***************************************************************************** @@ -596,7 +764,12 @@ int vpar_PMBType( vpar_thread_t * p_vpar ) *****************************************************************************/ int vpar_BMBType( vpar_thread_t * p_vpar ) { - /* À pomper dans Berkeley */ + /* Testing on 6 bits */ + int i_type = ShowBits( &p_vpar->bit_stream, 6 ); + /* Dump the good number of bits */ + DumpBits( &p_vpar->bit_stream, p_vpar->pm_mb_type[1][i_type].i_length ); + /* return the value from the lookup table for B type */ + return p_vpar->pm_mb_type[1][i_type].i_value; } /***************************************************************************** @@ -604,7 +777,11 @@ int vpar_BMBType( vpar_thread_t * p_vpar ) *****************************************************************************/ int vpar_DMBType( vpar_thread_t * p_vpar ) { - /* À pomper dans Berkeley */ + /* Taking 1 bit */ + int i_type = GetBits( &p_vpar->bit_stream, 1 ); + /* Lookup table */ + static int pi_mb_Dtype[2] = { MB_ERROR, 1 }; + return pi_mb_Dtype[i_type]; } /***************************************************************************** @@ -612,7 +789,9 @@ int vpar_DMBType( vpar_thread_t * p_vpar ) *****************************************************************************/ int vpar_CodedPattern420( vpar_thread_t * p_vpar ) { - /* À pomper dans Berkeley */ + int i_vlc = ShowBits( p_vpar->bit_stream, 9 ); + DumpBits( p_vpar->bit_stream, p_vpar->pl_coded_pattern[i_vlc].i_length ); + return p_vpar->pl_coded_pattern[i_vlc].i_value; } /***************************************************************************** @@ -679,5 +858,34 @@ static void vpar_DecodeMPEG2Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, in *****************************************************************************/ static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b ) { - /* À pomper dans Berkeley. */ + /* Lookup Table for the chromatic component */ + static int pi_cc_index[12] = { 0, 0, 0, 0, 1, 2, 1, 2, 1, 2 }; + int i_cc = pi_cc_index[i_b]; + /* Determine whether it is luminance or not (chrominance) */ + int i_type = ( i_cc + 1 ) / 2; + + /* Decoding of the DC intra coefficient */ + /* The nb of bits to parse depends on i_type */ + int i_code = ShowBits( &p_vpar->bit_stream, 9 + i_type ); + /* To reduce memory occupation, there are two lookup tables + * See InitDCT above */ + int i_code5 = i_code >> 4; + /* Shall we lookup in the first or in the second table ? */ + int i_select = ( i_code5 - 1 ) / 31; + /* Offset value for looking in the second table */ + int i_offset = 0x1f0 + ( i_type * 0x1f0 ); + int i_pos = i_code5 * ( ! i_select ) + + ( i_code - i_offset ) * i_select; + int i_dct_dc_size; + int i_dct_dc_diff; + i_dct_dc_size = p_vpar->pppl_dct_dc_size[i_select][i_type][i_pos].i_value; + /* Dump the variable length code */ + DumpBits( &p_vpar->bit_stream, + pppl_dct_dc_size[i_select][i_type][i_pos].i_length ); + i_dct_diff = GetBits( &p_vpar->bit_stream, i_dct_dc_size ); + p_vpar->slice.pi_dct_dc_pred[i_cc] += i_dct_diff; + + /* Decoding of the AC coefficients */ + int i_dummy = 1; + }