Mercurial > libavcodec.hg
comparison h263.c @ 745:25d7fb7c89be libavcodec
better/cleaner error resilience (done in a 2nd pass after decoding)
h263/mpeg4 out of order slice decoding
author | michaelni |
---|---|
date | Sun, 13 Oct 2002 13:16:04 +0000 |
parents | 16dab8296293 |
children | 3d4377531f6c |
comparison
equal
deleted
inserted
replaced
744:2f7da29ede37 | 745:25d7fb7c89be |
---|---|
68 int n, int coded, int intra); | 68 int n, int coded, int intra); |
69 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr); | 69 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr); |
70 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n, | 70 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n, |
71 int dir); | 71 int dir); |
72 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s); | 72 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s); |
73 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr); | |
74 | |
73 | 75 |
74 extern UINT32 inverse[256]; | 76 extern UINT32 inverse[256]; |
75 | 77 |
76 static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; | 78 static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; |
77 static UINT8 fcode_tab[MAX_MV*2+1]; | 79 static UINT8 fcode_tab[MAX_MV*2+1]; |
330 } | 332 } |
331 | 333 |
332 return score0 > score1 ? 1 : 0; | 334 return score0 > score1 ? 1 : 0; |
333 } | 335 } |
334 | 336 |
337 /** | |
338 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2) | |
339 */ | |
335 void ff_clean_h263_qscales(MpegEncContext *s){ | 340 void ff_clean_h263_qscales(MpegEncContext *s){ |
336 int i; | 341 int i; |
337 | 342 |
338 for(i=1; i<s->mb_num; i++){ | 343 for(i=1; i<s->mb_num; i++){ |
339 if(s->qscale_table[i] - s->qscale_table[i-1] >2) | 344 if(s->qscale_table[i] - s->qscale_table[i-1] >2) |
343 if(s->qscale_table[i] - s->qscale_table[i+1] >2) | 348 if(s->qscale_table[i] - s->qscale_table[i+1] >2) |
344 s->qscale_table[i]= s->qscale_table[i+1]+2; | 349 s->qscale_table[i]= s->qscale_table[i+1]+2; |
345 } | 350 } |
346 } | 351 } |
347 | 352 |
353 /** | |
354 * modify mb_type & qscale so that encoding is acually possible in mpeg4 | |
355 */ | |
348 void ff_clean_mpeg4_qscales(MpegEncContext *s){ | 356 void ff_clean_mpeg4_qscales(MpegEncContext *s){ |
349 int i; | 357 int i; |
350 | 358 |
351 ff_clean_h263_qscales(s); | 359 ff_clean_h263_qscales(s); |
352 | 360 |
1029 | 1037 |
1030 mot_val = s->motion_val[xy]; | 1038 mot_val = s->motion_val[xy]; |
1031 | 1039 |
1032 A = s->motion_val[xy - 1]; | 1040 A = s->motion_val[xy - 1]; |
1033 /* special case for first (slice) line */ | 1041 /* special case for first (slice) line */ |
1034 if ((s->mb_y == 0 || s->first_slice_line) && block<3) { | 1042 if (s->first_slice_line && block<3) { |
1035 // we cant just change some MVs to simulate that as we need them for the B frames (and ME) | 1043 // we cant just change some MVs to simulate that as we need them for the B frames (and ME) |
1036 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( | 1044 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( |
1037 if(block==0){ //most common case | 1045 if(block==0){ //most common case |
1038 if(s->mb_x == s->resync_mb_x){ //rare | 1046 if(s->mb_x == s->resync_mb_x){ //rare |
1039 *px= *py = 0; | 1047 *px= *py = 0; |
1450 } | 1458 } |
1451 } | 1459 } |
1452 } | 1460 } |
1453 | 1461 |
1454 /***************************************************/ | 1462 /***************************************************/ |
1455 | 1463 /** |
1464 * add mpeg4 stuffing bits (01...1) | |
1465 */ | |
1456 void ff_mpeg4_stuffing(PutBitContext * pbc) | 1466 void ff_mpeg4_stuffing(PutBitContext * pbc) |
1457 { | 1467 { |
1458 int length; | 1468 int length; |
1459 put_bits(pbc, 1, 0); | 1469 put_bits(pbc, 1, 0); |
1460 length= (-get_bit_count(pbc))&7; | 1470 length= (-get_bit_count(pbc))&7; |
1543 if (vo_ver_id == 1) { | 1553 if (vo_ver_id == 1) { |
1544 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */ | 1554 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */ |
1545 }else{ /* vo_ver_id == 2 */ | 1555 }else{ /* vo_ver_id == 2 */ |
1546 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */ | 1556 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */ |
1547 } | 1557 } |
1548 put_bits(&s->pb, 1, 0); /* not 8 bit */ | 1558 |
1559 s->quant_precision=5; | |
1560 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ | |
1549 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ | 1561 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ |
1550 if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */ | 1562 if(s->mpeg_quant) put_bits(&s->pb, 2, 0); /* no custom matrixes */ |
1551 | 1563 |
1552 if (vo_ver_id != 1) | 1564 if (vo_ver_id != 1) |
1553 put_bits(&s->pb, 1, s->quarter_sample=0); | 1565 put_bits(&s->pb, 1, s->quarter_sample=0); |
1587 s->no_rounding=0; | 1599 s->no_rounding=0; |
1588 if(picture_number==0 || !s->strict_std_compliance) | 1600 if(picture_number==0 || !s->strict_std_compliance) |
1589 mpeg4_encode_vol_header(s); | 1601 mpeg4_encode_vol_header(s); |
1590 } | 1602 } |
1591 | 1603 |
1604 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE; | |
1605 | |
1592 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE); | 1606 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE); |
1593 | 1607 |
1594 put_bits(&s->pb, 16, 0); /* vop header */ | 1608 put_bits(&s->pb, 16, 0); /* vop header */ |
1595 put_bits(&s->pb, 16, 0x1B6); /* vop header */ | 1609 put_bits(&s->pb, 16, 0x1B6); /* vop header */ |
1596 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ | 1610 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ |
1631 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | 1645 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; |
1632 s->h_edge_pos= s->width; | 1646 s->h_edge_pos= s->width; |
1633 s->v_edge_pos= s->height; | 1647 s->v_edge_pos= s->height; |
1634 } | 1648 } |
1635 | 1649 |
1650 /** | |
1651 * change qscale by given dquant and update qscale dependant variables. | |
1652 */ | |
1636 static void change_qscale(MpegEncContext * s, int dquant) | 1653 static void change_qscale(MpegEncContext * s, int dquant) |
1637 { | 1654 { |
1638 s->qscale += dquant; | 1655 s->qscale += dquant; |
1639 | 1656 |
1640 if (s->qscale < 1) | 1657 if (s->qscale < 1) |
1644 | 1661 |
1645 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; | 1662 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; |
1646 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; | 1663 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; |
1647 } | 1664 } |
1648 | 1665 |
1649 inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr) | 1666 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr) |
1650 { | 1667 { |
1651 int a, b, c, wrap, pred, scale; | 1668 int a, b, c, wrap, pred, scale; |
1652 UINT16 *dc_val; | 1669 UINT16 *dc_val; |
1653 int dummy; | 1670 int dummy; |
1654 | 1671 |
1665 * A X | 1682 * A X |
1666 */ | 1683 */ |
1667 a = dc_val[ - 1]; | 1684 a = dc_val[ - 1]; |
1668 b = dc_val[ - 1 - wrap]; | 1685 b = dc_val[ - 1 - wrap]; |
1669 c = dc_val[ - wrap]; | 1686 c = dc_val[ - wrap]; |
1687 | |
1688 /* outside slice handling (we cant do that by memset as we need the dc for error resilience) */ | |
1689 if(s->first_slice_line && n!=3){ | |
1690 if(n!=2) b=c= 1024; | |
1691 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024; | |
1692 } | |
1693 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){ | |
1694 if(n==0 || n==4 || n==5) | |
1695 b=1024; | |
1696 } | |
1670 | 1697 |
1671 if (abs(a - b) < abs(b - c)) { | 1698 if (abs(a - b) < abs(b - c)) { |
1672 pred = c; | 1699 pred = c; |
1673 *dir_ptr = 1; /* top */ | 1700 *dir_ptr = 1; /* top */ |
1674 } else { | 1701 } else { |
2081 &sprite_trajectory_tab[0][0], 4, 2); | 2108 &sprite_trajectory_tab[0][0], 4, 2); |
2082 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, | 2109 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, |
2083 &mb_type_b_tab[0][1], 2, 1, | 2110 &mb_type_b_tab[0][1], 2, 1, |
2084 &mb_type_b_tab[0][0], 2, 1); | 2111 &mb_type_b_tab[0][0], 2, 1); |
2085 } | 2112 } |
2086 | 2113 } |
2087 s->progressive_sequence=1; // set to most likely for the case of incomplete headers | 2114 |
2088 } | 2115 /** |
2089 | 2116 * Get the GOB height based on picture height. |
2090 int h263_decode_gob_header(MpegEncContext *s) | 2117 */ |
2118 int ff_h263_get_gob_height(MpegEncContext *s){ | |
2119 if (s->height <= 400) | |
2120 return 1; | |
2121 else if (s->height <= 800) | |
2122 return 2; | |
2123 else | |
2124 return 4; | |
2125 } | |
2126 | |
2127 /** | |
2128 * decodes the group of blocks header. | |
2129 * @return <0 if an error occured | |
2130 */ | |
2131 static int h263_decode_gob_header(MpegEncContext *s) | |
2091 { | 2132 { |
2092 unsigned int val, gfid; | 2133 unsigned int val, gfid; |
2134 int left; | |
2093 | 2135 |
2094 /* Check for GOB Start Code */ | 2136 /* Check for GOB Start Code */ |
2095 val = show_bits(&s->gb, 16); | 2137 val = show_bits(&s->gb, 16); |
2096 if (val == 0) { | 2138 if(val) |
2139 return -1; | |
2140 | |
2097 /* We have a GBSC probably with GSTUFF */ | 2141 /* We have a GBSC probably with GSTUFF */ |
2098 skip_bits(&s->gb, 16); /* Drop the zeros */ | 2142 skip_bits(&s->gb, 16); /* Drop the zeros */ |
2099 while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */ | 2143 left= s->gb.size*8 - get_bits_count(&s->gb); |
2144 //MN: we must check the bits left or we might end in a infinite loop (or segfault) | |
2145 for(;left>13; left--){ | |
2146 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */ | |
2147 } | |
2148 if(left<=13) | |
2149 return -1; | |
2150 | |
2100 #ifdef DEBUG | 2151 #ifdef DEBUG |
2101 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x); | 2152 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x); |
2102 #endif | 2153 #endif |
2103 s->gob_number = get_bits(&s->gb, 5); /* GN */ | 2154 s->gob_number = get_bits(&s->gb, 5); /* GN */ |
2104 gfid = get_bits(&s->gb, 2); /* GFID */ | 2155 gfid = get_bits(&s->gb, 2); /* GFID */ |
2105 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ | 2156 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ |
2157 if(s->qscale==0) | |
2158 return -1; | |
2159 s->mb_x= 0; | |
2160 s->mb_y= s->gob_index* s->gob_number; | |
2106 #ifdef DEBUG | 2161 #ifdef DEBUG |
2107 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale); | 2162 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale); |
2108 #endif | 2163 #endif |
2109 return 1; | |
2110 } | |
2111 return 0; | 2164 return 0; |
2112 | |
2113 } | 2165 } |
2114 | 2166 |
2115 static inline void memsetw(short *tab, int val, int n) | 2167 static inline void memsetw(short *tab, int val, int n) |
2116 { | 2168 { |
2117 int i; | 2169 int i; |
2135 put_bits(&s->pb, 19, DC_MARKER); | 2187 put_bits(&s->pb, 19, DC_MARKER); |
2136 s->misc_bits+=19 + pb2_len + bits - s->last_bits; | 2188 s->misc_bits+=19 + pb2_len + bits - s->last_bits; |
2137 s->i_tex_bits+= tex_pb_len; | 2189 s->i_tex_bits+= tex_pb_len; |
2138 }else{ | 2190 }else{ |
2139 put_bits(&s->pb, 17, MOTION_MARKER); | 2191 put_bits(&s->pb, 17, MOTION_MARKER); |
2140 s->misc_bits+=17 + pb2_len;; | 2192 s->misc_bits+=17 + pb2_len; |
2141 s->mv_bits+= bits - s->last_bits; | 2193 s->mv_bits+= bits - s->last_bits; |
2142 s->p_tex_bits+= tex_pb_len; | 2194 s->p_tex_bits+= tex_pb_len; |
2143 } | 2195 } |
2144 | 2196 |
2145 flush_put_bits(&s->pb2); | 2197 flush_put_bits(&s->pb2); |
2148 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len); | 2200 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len); |
2149 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len); | 2201 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len); |
2150 s->last_bits= get_bit_count(&s->pb); | 2202 s->last_bits= get_bit_count(&s->pb); |
2151 } | 2203 } |
2152 | 2204 |
2205 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){ | |
2206 switch(s->pict_type){ | |
2207 case I_TYPE: | |
2208 return 16; | |
2209 case P_TYPE: | |
2210 case S_TYPE: | |
2211 return s->f_code+15; | |
2212 case B_TYPE: | |
2213 return MAX(MAX(s->f_code, s->b_code)+15, 17); | |
2214 default: | |
2215 return -1; | |
2216 } | |
2217 } | |
2218 | |
2153 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) | 2219 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) |
2154 { | 2220 { |
2155 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | 2221 int mb_num_bits= av_log2(s->mb_num - 1) + 1; |
2156 | 2222 |
2157 ff_mpeg4_stuffing(&s->pb); | 2223 ff_mpeg4_stuffing(&s->pb); |
2158 if(s->pict_type==I_TYPE) | 2224 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0); |
2159 put_bits(&s->pb, 16, 0); | |
2160 else if(s->pict_type==B_TYPE) | |
2161 put_bits(&s->pb, MAX(MAX(s->f_code, s->b_code)+15, 17), 0); | |
2162 else /* S/P_TYPE */ | |
2163 put_bits(&s->pb, s->f_code+15, 0); | |
2164 put_bits(&s->pb, 1, 1); | 2225 put_bits(&s->pb, 1, 1); |
2165 | 2226 |
2166 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width); | 2227 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width); |
2167 put_bits(&s->pb, 5, s->qscale); | 2228 put_bits(&s->pb, s->quant_precision, s->qscale); |
2168 put_bits(&s->pb, 1, 0); /* no HEC */ | 2229 put_bits(&s->pb, 1, 0); /* no HEC */ |
2169 } | 2230 } |
2170 | 2231 |
2171 /** | 2232 /** |
2172 * decodes the next video packet and sets s->next_qscale | 2233 * check if the next stuff is a resync marker or the end. |
2173 * returns mb_num of the next packet or <0 if something went wrong | 2234 * @return 0 if not |
2174 */ | 2235 */ |
2175 static int decode_video_packet_header(MpegEncContext *s, GetBitContext *gb) | 2236 static inline int mpeg4_is_resync(MpegEncContext *s){ |
2237 const int bits_count= get_bits_count(&s->gb); | |
2238 | |
2239 if(s->workaround_bugs&FF_BUG_NO_PADDING){ | |
2240 return 0; | |
2241 } | |
2242 | |
2243 if(bits_count + 8 >= s->gb.size*8){ | |
2244 int v= show_bits(&s->gb, 8); | |
2245 v|= 0x7F >> (7-(bits_count&7)); | |
2246 | |
2247 if(v==0x7F) | |
2248 return 1; | |
2249 }else{ | |
2250 if(show_bits(&s->gb, 16) == ff_mpeg4_resync_prefix[bits_count&7]){ | |
2251 int len; | |
2252 GetBitContext gb= s->gb; | |
2253 | |
2254 skip_bits(&s->gb, 1); | |
2255 align_get_bits(&s->gb); | |
2256 | |
2257 for(len=0; len<32; len++){ | |
2258 if(get_bits1(&s->gb)) break; | |
2259 } | |
2260 | |
2261 s->gb= gb; | |
2262 | |
2263 if(len>=ff_mpeg4_get_video_packet_prefix_length(s)) | |
2264 return 1; | |
2265 } | |
2266 } | |
2267 return 0; | |
2268 } | |
2269 | |
2270 /** | |
2271 * decodes the next video packet. | |
2272 * @return <0 if something went wrong | |
2273 */ | |
2274 static int mpeg4_decode_video_packet_header(MpegEncContext *s) | |
2176 { | 2275 { |
2177 int bits; | |
2178 int mb_num_bits= av_log2(s->mb_num - 1) + 1; | 2276 int mb_num_bits= av_log2(s->mb_num - 1) + 1; |
2179 int header_extension=0, mb_num; | 2277 int header_extension=0, mb_num, len; |
2180 //printf("%X\n", show_bits(&gb, 24)); | |
2181 //printf("parse_video_packet_header\n"); | |
2182 // if(show_aligned_bits(gb, 1, 16) != 0) return -1; | |
2183 | 2278 |
2184 /* is there enough space left for a video packet + header */ | 2279 /* is there enough space left for a video packet + header */ |
2185 if( get_bits_count(gb) > gb->size*8-20) return -1; | 2280 if( get_bits_count(&s->gb) > s->gb.size*8-20) return -1; |
2186 | 2281 |
2187 //printf("resync at %d %d\n", s->mb_x, s->mb_y); | 2282 for(len=0; len<32; len++){ |
2188 // skip_bits(gb, 1); | 2283 if(get_bits1(&s->gb)) break; |
2189 // align_get_bits(gb); | 2284 } |
2190 if(get_bits(gb, 16)!=0){ | 2285 |
2191 printf("internal error while decoding video packet header\n"); | 2286 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){ |
2192 } | 2287 printf("marker does not match f_code\n"); |
2193 | |
2194 //printf("%X\n", show_bits(gb, 24)); | |
2195 bits=0; | |
2196 while(!get_bits1(gb) && bits<30) bits++; | |
2197 if((s->pict_type == P_TYPE || s->pict_type == S_TYPE) && bits != s->f_code-1){ | |
2198 printf("marker does not match f_code (is: %d should be: %d pos: %d end %d x: %d y: %d)\n", | |
2199 bits+1, s->f_code, get_bits_count(gb), gb->size*8, s->mb_x, s->mb_y); | |
2200 return -1; | 2288 return -1; |
2201 }else if(s->pict_type == I_TYPE && bits != 0){ | 2289 } |
2202 printf("marker too long\n"); | 2290 |
2291 if(s->shape != RECT_SHAPE){ | |
2292 header_extension= get_bits1(&s->gb); | |
2293 //FIXME more stuff here | |
2294 } | |
2295 | |
2296 mb_num= get_bits(&s->gb, mb_num_bits); | |
2297 if(mb_num>=s->mb_num){ | |
2298 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num); | |
2203 return -1; | 2299 return -1; |
2204 }else if(s->pict_type == B_TYPE && bits != MAX(MAX(s->f_code, s->b_code)-1, 1)){ | 2300 } |
2205 printf("marker does not match f/b_code\n"); | 2301 s->mb_x= mb_num % s->mb_width; |
2206 return -1; | 2302 s->mb_y= mb_num / s->mb_width; |
2207 } | |
2208 //printf("%X\n", show_bits(gb, 24)); | |
2209 | |
2210 if(s->shape != RECT_SHAPE){ | |
2211 header_extension= get_bits1(gb); | |
2212 //FIXME more stuff here | |
2213 } | |
2214 | |
2215 mb_num= get_bits(gb, mb_num_bits); | |
2216 if(mb_num < s->mb_x + s->mb_y*s->mb_width || mb_num>=s->mb_num){ | |
2217 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_x + s->mb_y*s->mb_width); | |
2218 return -1; | |
2219 } | |
2220 | 2303 |
2221 if(s->shape != BIN_ONLY_SHAPE){ | 2304 if(s->shape != BIN_ONLY_SHAPE){ |
2222 s->next_resync_qscale= get_bits(gb, 5); | 2305 int qscale= get_bits(&s->gb, s->quant_precision); |
2223 if(s->next_resync_qscale==0) | 2306 if(qscale) |
2224 s->next_resync_qscale= s->qscale; | 2307 s->qscale= qscale; |
2225 if(s->next_resync_qscale==0){ | |
2226 fprintf(stderr, "qscale==0\n"); | |
2227 return -1; | |
2228 } | |
2229 } | 2308 } |
2230 | 2309 |
2231 if(s->shape == RECT_SHAPE){ | 2310 if(s->shape == RECT_SHAPE){ |
2232 header_extension= get_bits1(gb); | 2311 header_extension= get_bits1(&s->gb); |
2233 } | 2312 } |
2234 if(header_extension){ | 2313 if(header_extension){ |
2235 int time_increment; | 2314 int time_increment; |
2236 int time_incr=0; | 2315 int time_incr=0; |
2237 | 2316 |
2238 while (get_bits1(gb) != 0) | 2317 while (get_bits1(&s->gb) != 0) |
2239 time_incr++; | 2318 time_incr++; |
2240 | 2319 |
2241 check_marker(gb, "before time_increment in video packed header"); | 2320 check_marker(&s->gb, "before time_increment in video packed header"); |
2242 time_increment= get_bits(gb, s->time_increment_bits); | 2321 time_increment= get_bits(&s->gb, s->time_increment_bits); |
2243 check_marker(gb, "before vop_coding_type in video packed header"); | 2322 check_marker(&s->gb, "before vop_coding_type in video packed header"); |
2244 | 2323 |
2245 skip_bits(gb, 2); /* vop coding type */ | 2324 skip_bits(&s->gb, 2); /* vop coding type */ |
2246 //FIXME not rect stuff here | 2325 //FIXME not rect stuff here |
2247 | 2326 |
2248 if(s->shape != BIN_ONLY_SHAPE){ | 2327 if(s->shape != BIN_ONLY_SHAPE){ |
2249 skip_bits(gb, 3); /* intra dc vlc threshold */ | 2328 skip_bits(&s->gb, 3); /* intra dc vlc threshold */ |
2250 | 2329 //FIXME dont just ignore everything |
2251 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){ | 2330 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){ |
2252 mpeg4_decode_sprite_trajectory(s); | 2331 mpeg4_decode_sprite_trajectory(s); |
2253 fprintf(stderr, "untested\n"); | 2332 fprintf(stderr, "untested\n"); |
2254 } | 2333 } |
2255 | 2334 |
2256 //FIXME reduced res stuff here | 2335 //FIXME reduced res stuff here |
2257 | 2336 |
2258 if (s->pict_type != I_TYPE) { | 2337 if (s->pict_type != I_TYPE) { |
2259 int f_code = get_bits(gb, 3); /* fcode_for */ | 2338 int f_code = get_bits(&s->gb, 3); /* fcode_for */ |
2260 if(f_code==0){ | 2339 if(f_code==0){ |
2261 printf("Error, video packet header damaged (f_code=0)\n"); | 2340 printf("Error, video packet header damaged (f_code=0)\n"); |
2262 } | 2341 } |
2263 } | 2342 } |
2264 if (s->pict_type == B_TYPE) { | 2343 if (s->pict_type == B_TYPE) { |
2265 int b_code = get_bits(gb, 3); | 2344 int b_code = get_bits(&s->gb, 3); |
2266 if(b_code==0){ | 2345 if(b_code==0){ |
2267 printf("Error, video packet header damaged (b_code=0)\n"); | 2346 printf("Error, video packet header damaged (b_code=0)\n"); |
2268 } | 2347 } |
2269 } | 2348 } |
2270 } | 2349 } |
2271 } | 2350 } |
2272 //FIXME new-pred stuff | 2351 //FIXME new-pred stuff |
2273 | 2352 |
2274 //printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb)); | 2353 //printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb)); |
2275 | 2354 |
2276 return mb_num; | 2355 return 0; |
2277 } | 2356 } |
2278 | 2357 |
2279 void ff_mpeg4_clean_buffers(MpegEncContext *s) | 2358 void ff_mpeg4_clean_buffers(MpegEncContext *s) |
2280 { | 2359 { |
2281 int c_wrap, c_xy, l_wrap, l_xy; | 2360 int c_wrap, c_xy, l_wrap, l_xy; |
2283 l_wrap= s->block_wrap[0]; | 2362 l_wrap= s->block_wrap[0]; |
2284 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2; | 2363 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2; |
2285 c_wrap= s->block_wrap[4]; | 2364 c_wrap= s->block_wrap[4]; |
2286 c_xy= s->mb_y*c_wrap + s->mb_x; | 2365 c_xy= s->mb_y*c_wrap + s->mb_x; |
2287 | 2366 |
2367 #if 0 | |
2288 /* clean DC */ | 2368 /* clean DC */ |
2289 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); | 2369 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); |
2290 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); | 2370 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); |
2291 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1); | 2371 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1); |
2372 #endif | |
2292 | 2373 |
2293 /* clean AC */ | 2374 /* clean AC */ |
2294 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16)); | 2375 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16)); |
2295 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16)); | 2376 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16)); |
2296 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16)); | 2377 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16)); |
2303 s->last_mv[0][0][1]= | 2384 s->last_mv[0][0][1]= |
2304 s->last_mv[1][0][0]= | 2385 s->last_mv[1][0][0]= |
2305 s->last_mv[1][0][1]= 0; | 2386 s->last_mv[1][0][1]= 0; |
2306 } | 2387 } |
2307 | 2388 |
2308 /* searches for the next resync marker clears ac,dc,mc, and sets s->next_resync_gb, s->mb_num_left */ | |
2309 int ff_mpeg4_resync(MpegEncContext *s) | |
2310 { | |
2311 GetBitContext gb; | |
2312 | |
2313 /* search & parse next resync marker */ | |
2314 | |
2315 gb= s->next_resync_gb; | |
2316 align_get_bits(&gb); | |
2317 //printf("mpeg4_resync %d next:%d \n", get_bits_count(&gb), get_bits_count(&s->next_resync_gb)); | |
2318 for(;;) { | |
2319 int v= show_bits(&gb, 24); | |
2320 if( get_bits_count(&gb) >= gb.size*8-24 || v == 1 /* start-code */){ | |
2321 s->mb_num_left= s->mb_num - s->mb_x - s->mb_y*s->mb_width; | |
2322 //printf("mpeg4_resync end\n"); | |
2323 s->gb= s->next_resync_gb; //continue at the next resync marker | |
2324 return -1; | |
2325 }else if(v>>8 == 0){ | |
2326 int next; | |
2327 s->next_resync_pos= get_bits_count(&gb); | |
2328 | |
2329 next= decode_video_packet_header(s, &gb); | |
2330 if(next >= 0){ | |
2331 s->mb_num_left= next - s->mb_x - s->mb_y*s->mb_width; | |
2332 break; | |
2333 } | |
2334 | |
2335 align_get_bits(&gb); | |
2336 } | |
2337 skip_bits(&gb, 8); | |
2338 } | |
2339 s->next_resync_gb=gb; | |
2340 | |
2341 return 0; | |
2342 } | |
2343 | |
2344 static inline void init_block_index(MpegEncContext *s) | |
2345 { | |
2346 s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2; | |
2347 s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1) + s->mb_x*2; | |
2348 s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2; | |
2349 s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2) + s->mb_x*2; | |
2350 s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x; | |
2351 s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x; | |
2352 } | |
2353 | |
2354 static inline void update_block_index(MpegEncContext *s) | |
2355 { | |
2356 s->block_index[0]+=2; | |
2357 s->block_index[1]+=2; | |
2358 s->block_index[2]+=2; | |
2359 s->block_index[3]+=2; | |
2360 s->block_index[4]++; | |
2361 s->block_index[5]++; | |
2362 } | |
2363 | |
2364 /** | 2389 /** |
2365 * decodes the first & second partition | 2390 * decodes the group of blocks / video packet header. |
2366 * returns error type or 0 if no error | 2391 * @return <0 if no resync found |
2367 */ | 2392 */ |
2368 int ff_mpeg4_decode_partitions(MpegEncContext *s) | 2393 int ff_h263_resync(MpegEncContext *s){ |
2369 { | 2394 int left, ret; |
2395 | |
2396 if(s->codec_id==CODEC_ID_MPEG4) | |
2397 skip_bits1(&s->gb); | |
2398 | |
2399 align_get_bits(&s->gb); | |
2400 | |
2401 if(show_bits(&s->gb, 16)==0){ | |
2402 if(s->codec_id==CODEC_ID_MPEG4) | |
2403 ret= mpeg4_decode_video_packet_header(s); | |
2404 else | |
2405 ret= h263_decode_gob_header(s); | |
2406 if(ret>=0) | |
2407 return 0; | |
2408 } | |
2409 //ok, its not where its supposed to be ... | |
2410 s->gb= s->last_resync_gb; | |
2411 align_get_bits(&s->gb); | |
2412 left= s->gb.size*8 - get_bits_count(&s->gb); | |
2413 | |
2414 for(;left>16+1+5+5; left-=8){ | |
2415 if(show_bits(&s->gb, 16)==0){ | |
2416 GetBitContext bak= s->gb; | |
2417 | |
2418 if(s->codec_id==CODEC_ID_MPEG4) | |
2419 ret= mpeg4_decode_video_packet_header(s); | |
2420 else | |
2421 ret= h263_decode_gob_header(s); | |
2422 if(ret>=0) | |
2423 return 0; | |
2424 | |
2425 s->gb= bak; | |
2426 } | |
2427 skip_bits(&s->gb, 8); | |
2428 } | |
2429 | |
2430 return -1; | |
2431 } | |
2432 | |
2433 /** | |
2434 * decodes first partition. | |
2435 * @return number of MBs decoded or <0 if an error occured | |
2436 */ | |
2437 static int mpeg4_decode_partition_a(MpegEncContext *s){ | |
2438 int mb_num; | |
2370 static const INT8 quant_tab[4] = { -1, -2, 1, 2 }; | 2439 static const INT8 quant_tab[4] = { -1, -2, 1, 2 }; |
2371 int mb_num; | |
2372 | 2440 |
2373 /* decode first partition */ | 2441 /* decode first partition */ |
2374 mb_num=0; | 2442 mb_num=0; |
2375 s->first_slice_line=1; | 2443 s->first_slice_line=1; |
2376 s->mb_x= s->resync_mb_x; | 2444 for(; s->mb_y<s->mb_height; s->mb_y++){ |
2377 for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){ | 2445 ff_init_block_index(s); |
2378 init_block_index(s); | 2446 for(; s->mb_x<s->mb_width; s->mb_x++){ |
2379 for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){ | |
2380 const int xy= s->mb_x + s->mb_y*s->mb_width; | 2447 const int xy= s->mb_x + s->mb_y*s->mb_width; |
2381 int cbpc; | 2448 int cbpc; |
2382 int dir=0; | 2449 int dir=0; |
2383 | 2450 |
2384 mb_num++; | 2451 mb_num++; |
2385 update_block_index(s); | 2452 ff_update_block_index(s); |
2386 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) | 2453 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) |
2387 s->first_slice_line=0; | 2454 s->first_slice_line=0; |
2388 | 2455 |
2389 if(s->mb_x==0) PRINT_MB_TYPE("\n"); | 2456 if(s->mb_x==0) PRINT_MB_TYPE("\n"); |
2390 | 2457 |
2391 if(s->pict_type==I_TYPE){ | 2458 if(s->pict_type==I_TYPE){ |
2392 int i; | 2459 int i; |
2393 | 2460 |
2461 if(show_bits(&s->gb, 19)==DC_MARKER){ | |
2462 return mb_num-1; | |
2463 } | |
2464 | |
2394 PRINT_MB_TYPE("I"); | 2465 PRINT_MB_TYPE("I"); |
2395 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1); | 2466 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1); |
2396 if (cbpc < 0){ | 2467 if (cbpc < 0){ |
2468 | |
2397 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); | 2469 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); |
2398 return DECODING_DESYNC; | 2470 return -1; |
2399 } | 2471 } |
2400 s->cbp_table[xy]= cbpc & 3; | 2472 s->cbp_table[xy]= cbpc & 3; |
2401 s->mb_type[xy]= MB_TYPE_INTRA; | 2473 s->mb_type[xy]= MB_TYPE_INTRA; |
2402 s->mb_intra = 1; | 2474 s->mb_intra = 1; |
2403 | 2475 |
2410 for(i=0; i<6; i++){ | 2482 for(i=0; i<6; i++){ |
2411 int dc_pred_dir; | 2483 int dc_pred_dir; |
2412 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | 2484 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); |
2413 if(dc < 0){ | 2485 if(dc < 0){ |
2414 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); | 2486 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); |
2415 return DECODING_DESYNC; | 2487 return -1; |
2416 } | 2488 } |
2417 dir<<=1; | 2489 dir<<=1; |
2418 if(dc_pred_dir) dir|=1; | 2490 if(dc_pred_dir) dir|=1; |
2419 } | 2491 } |
2420 s->pred_dir_table[xy]= dir; | 2492 s->pred_dir_table[xy]= dir; |
2493 | |
2494 s->error_status_table[xy]= AC_ERROR; | |
2421 }else{ /* P/S_TYPE */ | 2495 }else{ /* P/S_TYPE */ |
2422 int mx, my, pred_x, pred_y; | 2496 int mx, my, pred_x, pred_y, bits; |
2423 INT16 * const mot_val= s->motion_val[s->block_index[0]]; | 2497 INT16 * const mot_val= s->motion_val[s->block_index[0]]; |
2424 const int stride= s->block_wrap[0]*2; | 2498 const int stride= s->block_wrap[0]*2; |
2425 | 2499 |
2426 if(get_bits1(&s->gb)){ | 2500 bits= show_bits(&s->gb, 17); |
2501 if(bits==MOTION_MARKER){ | |
2502 return mb_num-1; | |
2503 } | |
2504 skip_bits1(&s->gb); | |
2505 if(bits&0x10000){ | |
2427 /* skip mb */ | 2506 /* skip mb */ |
2428 s->mb_type[xy]= MB_TYPE_SKIPED; | 2507 s->mb_type[xy]= MB_TYPE_SKIPED; |
2429 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ | 2508 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ |
2430 const int a= s->sprite_warping_accuracy; | 2509 const int a= s->sprite_warping_accuracy; |
2431 PRINT_MB_TYPE("G"); | 2510 PRINT_MB_TYPE("G"); |
2448 mot_val[1+stride]= mot_val[3+stride]= my; | 2527 mot_val[1+stride]= mot_val[3+stride]= my; |
2449 | 2528 |
2450 if(s->mbintra_table[xy]) | 2529 if(s->mbintra_table[xy]) |
2451 ff_clean_intra_table_entries(s); | 2530 ff_clean_intra_table_entries(s); |
2452 | 2531 |
2532 s->error_status_table[xy]= AC_ERROR; | |
2453 continue; | 2533 continue; |
2454 } | 2534 } |
2455 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | 2535 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
2456 if (cbpc < 0){ | 2536 if (cbpc < 0){ |
2457 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); | 2537 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); |
2458 return DECODING_DESYNC; | 2538 return -1; |
2459 } | 2539 } |
2460 if (cbpc > 20) | 2540 if (cbpc > 20) |
2461 cbpc+=3; | 2541 cbpc+=3; |
2462 else if (cbpc == 20) | 2542 else if (cbpc == 20) |
2463 fprintf(stderr, "Stuffing !"); | 2543 fprintf(stderr, "Stuffing !"); |
2471 s->mb_type[xy]= MB_TYPE_INTRA; | 2551 s->mb_type[xy]= MB_TYPE_INTRA; |
2472 mot_val[0 ]= mot_val[2 ]= | 2552 mot_val[0 ]= mot_val[2 ]= |
2473 mot_val[0+stride]= mot_val[2+stride]= 0; | 2553 mot_val[0+stride]= mot_val[2+stride]= 0; |
2474 mot_val[1 ]= mot_val[3 ]= | 2554 mot_val[1 ]= mot_val[3 ]= |
2475 mot_val[1+stride]= mot_val[3+stride]= 0; | 2555 mot_val[1+stride]= mot_val[3+stride]= 0; |
2556 s->error_status_table[xy]= DC_ERROR|AC_ERROR; | |
2476 }else{ | 2557 }else{ |
2477 if(s->mbintra_table[xy]) | 2558 if(s->mbintra_table[xy]) |
2478 ff_clean_intra_table_entries(s); | 2559 ff_clean_intra_table_entries(s); |
2479 | 2560 |
2480 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) | 2561 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) |
2496 }else{ | 2577 }else{ |
2497 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample); | 2578 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample); |
2498 } | 2579 } |
2499 } | 2580 } |
2500 if (mx >= 0xffff) | 2581 if (mx >= 0xffff) |
2501 return DECODING_DESYNC; | 2582 return -1; |
2502 | 2583 |
2503 if(!s->mcsel) | 2584 if(!s->mcsel) |
2504 my = h263_decode_motion(s, pred_y, s->f_code); | 2585 my = h263_decode_motion(s, pred_y, s->f_code); |
2505 else{ | 2586 else{ |
2506 const int a= s->sprite_warping_accuracy; | 2587 const int a= s->sprite_warping_accuracy; |
2509 }else{ | 2590 }else{ |
2510 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample); | 2591 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample); |
2511 } | 2592 } |
2512 } | 2593 } |
2513 if (my >= 0xffff) | 2594 if (my >= 0xffff) |
2514 return DECODING_DESYNC; | 2595 return -1; |
2515 mot_val[0 ]= mot_val[2 ] = | 2596 mot_val[0 ]= mot_val[2 ] = |
2516 mot_val[0+stride]= mot_val[2+stride]= mx; | 2597 mot_val[0+stride]= mot_val[2+stride]= mx; |
2517 mot_val[1 ]= mot_val[3 ]= | 2598 mot_val[1 ]= mot_val[3 ]= |
2518 mot_val[1+stride]= mot_val[3+stride]= my; | 2599 mot_val[1+stride]= mot_val[3+stride]= my; |
2519 } else { | 2600 } else { |
2522 s->mb_type[xy]= MB_TYPE_INTER4V; | 2603 s->mb_type[xy]= MB_TYPE_INTER4V; |
2523 for(i=0;i<4;i++) { | 2604 for(i=0;i<4;i++) { |
2524 INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y); | 2605 INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y); |
2525 mx = h263_decode_motion(s, pred_x, s->f_code); | 2606 mx = h263_decode_motion(s, pred_x, s->f_code); |
2526 if (mx >= 0xffff) | 2607 if (mx >= 0xffff) |
2527 return DECODING_DESYNC; | 2608 return -1; |
2528 | 2609 |
2529 my = h263_decode_motion(s, pred_y, s->f_code); | 2610 my = h263_decode_motion(s, pred_y, s->f_code); |
2530 if (my >= 0xffff) | 2611 if (my >= 0xffff) |
2531 return DECODING_DESYNC; | 2612 return -1; |
2532 mot_val[0] = mx; | 2613 mot_val[0] = mx; |
2533 mot_val[1] = my; | 2614 mot_val[1] = my; |
2534 } | 2615 } |
2535 } | 2616 } |
2617 s->error_status_table[xy]= AC_ERROR; | |
2536 } | 2618 } |
2537 } | 2619 } |
2538 } | 2620 } |
2539 s->mb_x= 0; | 2621 s->mb_x= 0; |
2540 } | 2622 } |
2541 | 2623 |
2542 if (s->pict_type==I_TYPE && get_bits(&s->gb, 19)!=DC_MARKER ) s->decoding_error= DECODING_DESYNC; | 2624 return mb_num; |
2543 else if(s->pict_type!=I_TYPE && get_bits(&s->gb, 17)!=MOTION_MARKER) s->decoding_error= DECODING_DESYNC; | 2625 } |
2544 if(s->decoding_error== DECODING_DESYNC){ | 2626 |
2545 fprintf(stderr, "marker missing after first partition at %d %d\n", s->mb_x, s->mb_y); | 2627 /** |
2546 return DECODING_DESYNC; | 2628 * decode second partition. |
2547 } | 2629 * @return <0 if an error occured |
2548 | 2630 */ |
2549 /* decode second partition */ | 2631 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){ |
2550 mb_num=0; | 2632 int mb_num=0; |
2633 static const INT8 quant_tab[4] = { -1, -2, 1, 2 }; | |
2634 | |
2551 s->mb_x= s->resync_mb_x; | 2635 s->mb_x= s->resync_mb_x; |
2552 for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){ | 2636 s->first_slice_line=1; |
2553 init_block_index(s); | 2637 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){ |
2554 for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){ | 2638 ff_init_block_index(s); |
2639 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){ | |
2555 const int xy= s->mb_x + s->mb_y*s->mb_width; | 2640 const int xy= s->mb_x + s->mb_y*s->mb_width; |
2556 | 2641 |
2557 mb_num++; | 2642 mb_num++; |
2558 update_block_index(s); | 2643 ff_update_block_index(s); |
2644 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) | |
2645 s->first_slice_line=0; | |
2559 | 2646 |
2560 if(s->pict_type==I_TYPE){ | 2647 if(s->pict_type==I_TYPE){ |
2561 int ac_pred= get_bits1(&s->gb); | 2648 int ac_pred= get_bits1(&s->gb); |
2562 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | 2649 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
2563 if(cbpy<0){ | 2650 if(cbpy<0){ |
2564 fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); | 2651 fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); |
2565 return DECODING_AC_LOST; | 2652 return -1; |
2566 } | 2653 } |
2567 | 2654 |
2568 s->cbp_table[xy]|= cbpy<<2; | 2655 s->cbp_table[xy]|= cbpy<<2; |
2569 s->pred_dir_table[xy]|= ac_pred<<7; | 2656 s->pred_dir_table[xy]|= ac_pred<<7; |
2570 }else{ /* P || S_TYPE */ | 2657 }else{ /* P || S_TYPE */ |
2573 int ac_pred = get_bits1(&s->gb); | 2660 int ac_pred = get_bits1(&s->gb); |
2574 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | 2661 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
2575 | 2662 |
2576 if(cbpy<0){ | 2663 if(cbpy<0){ |
2577 fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); | 2664 fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); |
2578 return DECODING_ACDC_LOST; | 2665 return -1; |
2579 } | 2666 } |
2580 | 2667 |
2581 if(s->cbp_table[xy] & 8) { | 2668 if(s->cbp_table[xy] & 8) { |
2582 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); | 2669 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
2583 } | 2670 } |
2586 for(i=0; i<6; i++){ | 2673 for(i=0; i<6; i++){ |
2587 int dc_pred_dir; | 2674 int dc_pred_dir; |
2588 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); | 2675 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); |
2589 if(dc < 0){ | 2676 if(dc < 0){ |
2590 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); | 2677 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); |
2591 return DECODING_ACDC_LOST; | 2678 return -1; |
2592 } | 2679 } |
2593 dir<<=1; | 2680 dir<<=1; |
2594 if(dc_pred_dir) dir|=1; | 2681 if(dc_pred_dir) dir|=1; |
2595 } | 2682 } |
2596 s->cbp_table[xy]&= 3; //remove dquant | 2683 s->cbp_table[xy]&= 3; //remove dquant |
2597 s->cbp_table[xy]|= cbpy<<2; | 2684 s->cbp_table[xy]|= cbpy<<2; |
2598 s->pred_dir_table[xy]= dir | (ac_pred<<7); | 2685 s->pred_dir_table[xy]= dir | (ac_pred<<7); |
2686 s->error_status_table[xy]&= ~DC_ERROR; | |
2599 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){ | 2687 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){ |
2600 s->qscale_table[xy]= s->qscale; | 2688 s->qscale_table[xy]= s->qscale; |
2601 s->cbp_table[xy]= 0; | 2689 s->cbp_table[xy]= 0; |
2602 }else{ | 2690 }else{ |
2603 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | 2691 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
2604 | 2692 |
2605 if(cbpy<0){ | 2693 if(cbpy<0){ |
2606 fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); | 2694 fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); |
2607 return DECODING_ACDC_LOST; | 2695 return -1; |
2608 } | 2696 } |
2609 | 2697 |
2610 if(s->cbp_table[xy] & 8) { | 2698 if(s->cbp_table[xy] & 8) { |
2611 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); | 2699 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
2612 } | 2700 } |
2615 s->cbp_table[xy]&= 3; //remove dquant | 2703 s->cbp_table[xy]&= 3; //remove dquant |
2616 s->cbp_table[xy]|= (cbpy^0xf)<<2; | 2704 s->cbp_table[xy]|= (cbpy^0xf)<<2; |
2617 } | 2705 } |
2618 } | 2706 } |
2619 } | 2707 } |
2708 if(mb_num >= mb_count) return 0; | |
2620 s->mb_x= 0; | 2709 s->mb_x= 0; |
2621 } | 2710 } |
2622 | 2711 return 0; |
2712 } | |
2713 | |
2714 /** | |
2715 * decodes the first & second partition | |
2716 * @return <0 if error (and sets error type in the error_status_table) | |
2717 */ | |
2718 int ff_mpeg4_decode_partitions(MpegEncContext *s) | |
2719 { | |
2720 int mb_num; | |
2721 | |
2722 mb_num= mpeg4_decode_partition_a(s); | |
2723 if(mb_num<0) | |
2724 return -1; | |
2725 | |
2726 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){ | |
2727 fprintf(stderr, "slice below monitor ...\n"); | |
2728 return -1; | |
2729 } | |
2730 | |
2731 s->mb_num_left= mb_num; | |
2732 | |
2733 if(s->pict_type==I_TYPE){ | |
2734 if(get_bits(&s->gb, 19)!=DC_MARKER){ | |
2735 fprintf(stderr, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y); | |
2736 return -1; | |
2737 }else | |
2738 s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END|DC_END; | |
2739 }else{ | |
2740 if(get_bits(&s->gb, 17)!=MOTION_MARKER){ | |
2741 fprintf(stderr, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y); | |
2742 return -1; | |
2743 }else | |
2744 s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= MV_END; | |
2745 } | |
2746 | |
2747 if( mpeg4_decode_partition_b(s, mb_num) < 0){ | |
2748 return -1; | |
2749 } | |
2750 | |
2751 s->error_status_table[s->mb_x + s->mb_y*s->mb_width-1]|= DC_END; | |
2623 | 2752 |
2624 return 0; | 2753 return 0; |
2625 } | 2754 } |
2626 | 2755 |
2627 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, | 2756 /** |
2628 DCTELEM block[6][64]) | 2757 * decode partition C of one MB. |
2758 * @return <0 if an error occured | |
2759 */ | |
2760 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) | |
2629 { | 2761 { |
2630 int cbp, mb_type; | 2762 int cbp, mb_type; |
2631 const int xy= s->mb_x + s->mb_y*s->mb_width; | 2763 const int xy= s->mb_x + s->mb_y*s->mb_width; |
2632 | 2764 |
2633 if(s->mb_x==s->resync_mb_x && s->mb_y==s->resync_mb_y){ //Note resync_mb_{x,y}==0 at the start | |
2634 int i; | |
2635 int block_index_backup[6]; | |
2636 int qscale= s->qscale; | |
2637 | |
2638 for(i=0; i<6; i++) block_index_backup[i]= s->block_index[i]; | |
2639 | |
2640 s->decoding_error= ff_mpeg4_decode_partitions(s); | |
2641 | |
2642 for(i=0; i<6; i++) s->block_index[i]= block_index_backup[i]; | |
2643 s->first_slice_line=1; | |
2644 s->mb_x= s->resync_mb_x; | |
2645 s->mb_y= s->resync_mb_y; | |
2646 s->qscale= qscale; | |
2647 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; | |
2648 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; | |
2649 | |
2650 if(s->decoding_error==DECODING_DESYNC) return -1; | |
2651 } | |
2652 | |
2653 mb_type= s->mb_type[xy]; | 2765 mb_type= s->mb_type[xy]; |
2654 if(s->decoding_error) | 2766 cbp = s->cbp_table[xy]; |
2655 cbp=0; | 2767 |
2656 else | 2768 if(s->qscale_table[xy] != s->qscale){ |
2657 cbp = s->cbp_table[xy]; | |
2658 | |
2659 if(s->decoding_error!=DECODING_ACDC_LOST && s->qscale_table[xy] != s->qscale){ | |
2660 s->qscale= s->qscale_table[xy]; | 2769 s->qscale= s->qscale_table[xy]; |
2661 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; | 2770 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ]; |
2662 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; | 2771 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ]; |
2663 } | 2772 } |
2664 | 2773 |
2665 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { | 2774 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
2666 int i; | 2775 int i; |
2667 for(i=0; i<4; i++){ | 2776 for(i=0; i<4; i++){ |
2668 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0]; | 2777 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0]; |
2669 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1]; | 2778 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1]; |
2681 s->mb_skiped = 0; | 2790 s->mb_skiped = 0; |
2682 }else{ | 2791 }else{ |
2683 s->mcsel=0; | 2792 s->mcsel=0; |
2684 s->mb_skiped = 1; | 2793 s->mb_skiped = 1; |
2685 } | 2794 } |
2686 return 0; | 2795 }else if(s->mb_intra){ |
2687 }else if(s->mb_intra && s->decoding_error!=DECODING_ACDC_LOST){ | |
2688 s->ac_pred = s->pred_dir_table[xy]>>7; | 2796 s->ac_pred = s->pred_dir_table[xy]>>7; |
2689 | 2797 |
2690 /* decode each block */ | 2798 /* decode each block */ |
2691 for (i = 0; i < 6; i++) { | 2799 for (i = 0; i < 6; i++) { |
2692 int ret= mpeg4_decode_block(s, block[i], i, cbp&32, 1); | 2800 if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){ |
2693 if(ret==DECODING_AC_LOST){ | 2801 fprintf(stderr, "texture corrupted at %d %d\n", s->mb_x, s->mb_y); |
2694 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y); | 2802 return -1; |
2695 s->decoding_error=DECODING_AC_LOST; | |
2696 cbp=0; | |
2697 }else if(ret==DECODING_ACDC_LOST){ | |
2698 fprintf(stderr, "dc corrupted at %d %d (trying to continue with mc only)\n", s->mb_x, s->mb_y); | |
2699 s->decoding_error=DECODING_ACDC_LOST; | |
2700 break; | |
2701 } | 2803 } |
2702 cbp+=cbp; | 2804 cbp+=cbp; |
2703 } | 2805 } |
2704 }else if(!s->mb_intra){ | 2806 }else if(!s->mb_intra){ |
2705 // s->mcsel= 0; //FIXME do we need to init that | 2807 // s->mcsel= 0; //FIXME do we need to init that |
2708 if (mb_type&MB_TYPE_INTER4V) { | 2810 if (mb_type&MB_TYPE_INTER4V) { |
2709 s->mv_type = MV_TYPE_8X8; | 2811 s->mv_type = MV_TYPE_8X8; |
2710 } else { | 2812 } else { |
2711 s->mv_type = MV_TYPE_16X16; | 2813 s->mv_type = MV_TYPE_16X16; |
2712 } | 2814 } |
2713 if(s->decoding_error==0 && cbp){ | 2815 /* decode each block */ |
2714 /* decode each block */ | 2816 for (i = 0; i < 6; i++) { |
2715 for (i = 0; i < 6; i++) { | 2817 if(mpeg4_decode_block(s, block[i], i, cbp&32, 0) < 0){ |
2716 int ret= mpeg4_decode_block(s, block[i], i, cbp&32, 0); | 2818 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y); |
2717 if(ret==DECODING_AC_LOST){ | 2819 return -1; |
2718 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y); | 2820 } |
2719 s->decoding_error=DECODING_AC_LOST; | 2821 cbp+=cbp; |
2720 break; | |
2721 } | |
2722 cbp+=cbp; | |
2723 } | |
2724 } | 2822 } |
2725 } | 2823 } |
2726 } else { /* I-Frame */ | 2824 } else { /* I-Frame */ |
2727 int i; | 2825 int i; |
2728 s->mb_intra = 1; | 2826 s->mb_intra = 1; |
2729 s->ac_pred = s->pred_dir_table[xy]>>7; | 2827 s->ac_pred = s->pred_dir_table[xy]>>7; |
2730 | 2828 |
2731 /* decode each block */ | 2829 /* decode each block */ |
2732 for (i = 0; i < 6; i++) { | 2830 for (i = 0; i < 6; i++) { |
2733 int ret= mpeg4_decode_block(s, block[i], i, cbp&32, 1); | 2831 if(mpeg4_decode_block(s, block[i], i, cbp&32, 1) < 0){ |
2734 if(ret==DECODING_AC_LOST){ | |
2735 fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y); | 2832 fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y); |
2736 s->decoding_error=DECODING_AC_LOST; | |
2737 cbp=0; | |
2738 }else if(ret==DECODING_ACDC_LOST){ | |
2739 fprintf(stderr, "dc corrupted at %d %d\n", s->mb_x, s->mb_y); | |
2740 return -1; | 2833 return -1; |
2741 } | 2834 } |
2742 cbp+=cbp; | 2835 cbp+=cbp; |
2743 } | 2836 } |
2744 } | 2837 } |
2745 | 2838 |
2746 return 0; | 2839 s->error_status_table[xy]&= ~AC_ERROR; |
2747 } | 2840 |
2748 #if 0 | 2841 /* per-MB end of slice check */ |
2749 static inline void decode_interlaced_info(MpegEncContext *s, int cbp, int mb_type){ | 2842 |
2750 s->mv_type= 0; | 2843 if(--s->mb_num_left <= 0){ |
2751 if(!s->progressive_sequence){ | 2844 //printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size*8 - get_bits_count(&s->gb)); |
2752 if(cbp || s->mb_intra) | 2845 if(mpeg4_is_resync(s)) |
2753 s->interlaced_dct= get_bits1(&s->gb); | 2846 return SLICE_END; |
2754 | 2847 else |
2755 if(!s->mb_intra){ | 2848 return SLICE_NOEND; |
2756 if( s->pict_type==P_TYPE //FIXME check that 4MV is forbidden | 2849 }else{ |
2757 || (s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && !s->mcsel) | 2850 if(s->cbp_table[xy+1] && mpeg4_is_resync(s)) |
2758 || (s->pict_type==B_TYPE && mb_type!=0) ){ | 2851 return SLICE_END; |
2759 | 2852 else |
2760 if(get_bits1(&s->gb)){ | 2853 return SLICE_OK; |
2761 s->mv_type= MV_TYPE_FIELD; | 2854 } |
2762 | 2855 } |
2763 if( s->pict_type==P_TYPE | 2856 |
2764 || (s->pict_type==B_TYPE && mb_type!=2)){ | 2857 int ff_h263_decode_mb(MpegEncContext *s, |
2765 s->field_select[0][0]= get_bits1(&s->gb); | 2858 DCTELEM block[6][64]) |
2766 s->field_select[0][1]= get_bits1(&s->gb); | |
2767 } | |
2768 if(s->pict_type==B_TYPE && mb_type!=3){ | |
2769 s->field_select[1][0]= get_bits1(&s->gb); | |
2770 s->field_select[1][1]= get_bits1(&s->gb); | |
2771 } | |
2772 }else | |
2773 s->mv_type= 0; | |
2774 } | |
2775 } | |
2776 } | |
2777 } | |
2778 #endif | |
2779 | |
2780 int h263_decode_mb(MpegEncContext *s, | |
2781 DCTELEM block[6][64]) | |
2782 { | 2859 { |
2783 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; | 2860 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; |
2784 INT16 *mot_val; | 2861 INT16 *mot_val; |
2785 static INT8 quant_tab[4] = { -1, -2, 1, 2 }; | 2862 static INT8 quant_tab[4] = { -1, -2, 1, 2 }; |
2786 | 2863 |
2864 s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0; | |
2865 | |
2787 if(s->mb_x==0) PRINT_MB_TYPE("\n"); | 2866 if(s->mb_x==0) PRINT_MB_TYPE("\n"); |
2788 | |
2789 if(s->resync_marker){ | |
2790 if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){ | |
2791 s->first_slice_line=0; | |
2792 } | |
2793 } | |
2794 | |
2795 if(s->data_partitioning && s->pict_type!=B_TYPE) | |
2796 return mpeg4_decode_partitioned_mb(s, block); | |
2797 | 2867 |
2798 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { | 2868 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) { |
2799 if (get_bits1(&s->gb)) { | 2869 if (get_bits1(&s->gb)) { |
2800 /* skip mb */ | 2870 /* skip mb */ |
2801 s->mb_intra = 0; | 2871 s->mb_intra = 0; |
2826 s->mcsel=0; | 2896 s->mcsel=0; |
2827 s->mv[0][0][0] = 0; | 2897 s->mv[0][0][0] = 0; |
2828 s->mv[0][0][1] = 0; | 2898 s->mv[0][0][1] = 0; |
2829 s->mb_skiped = 1; | 2899 s->mb_skiped = 1; |
2830 } | 2900 } |
2831 return 0; | 2901 goto end; |
2832 } | 2902 } |
2833 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); | 2903 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
2834 //fprintf(stderr, "\tCBPC: %d", cbpc); | 2904 //fprintf(stderr, "\tCBPC: %d", cbpc); |
2835 if (cbpc < 0) | 2905 if (cbpc < 0) |
2836 return -1; | 2906 return -1; |
2849 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); | 2919 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); |
2850 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2); | 2920 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2); |
2851 if (dquant) { | 2921 if (dquant) { |
2852 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); | 2922 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
2853 } | 2923 } |
2854 if((!s->progressive_sequence) && (cbp || s->workaround_bugs==2)) | 2924 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE))) |
2855 s->interlaced_dct= get_bits1(&s->gb); | 2925 s->interlaced_dct= get_bits1(&s->gb); |
2856 | 2926 |
2857 s->mv_dir = MV_DIR_FORWARD; | 2927 s->mv_dir = MV_DIR_FORWARD; |
2858 if ((cbpc & 16) == 0) { | 2928 if ((cbpc & 16) == 0) { |
2859 if(s->mcsel){ | 2929 if(s->mcsel){ |
2979 s->mv[0][0][0] = 0; | 3049 s->mv[0][0][0] = 0; |
2980 s->mv[0][0][1] = 0; | 3050 s->mv[0][0][1] = 0; |
2981 s->mv[1][0][0] = 0; | 3051 s->mv[1][0][0] = 0; |
2982 s->mv[1][0][1] = 0; | 3052 s->mv[1][0][1] = 0; |
2983 PRINT_MB_TYPE("s"); | 3053 PRINT_MB_TYPE("s"); |
2984 return 0; | 3054 goto end; |
2985 } | 3055 } |
2986 | 3056 |
2987 modb1= get_bits1(&s->gb); | 3057 modb1= get_bits1(&s->gb); |
2988 if(modb1){ | 3058 if(modb1){ |
2989 mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded | 3059 mb_type=4; //like MB_TYPE_B_DIRECT but no vectors coded |
3158 if(cbpy<0) return -1; | 3228 if(cbpy<0) return -1; |
3159 cbp = (cbpc & 3) | (cbpy << 2); | 3229 cbp = (cbpc & 3) | (cbpy << 2); |
3160 if (dquant) { | 3230 if (dquant) { |
3161 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); | 3231 change_qscale(s, quant_tab[get_bits(&s->gb, 2)]); |
3162 } | 3232 } |
3233 | |
3163 if(!s->progressive_sequence) | 3234 if(!s->progressive_sequence) |
3164 s->interlaced_dct= get_bits1(&s->gb); | 3235 s->interlaced_dct= get_bits1(&s->gb); |
3165 | 3236 |
3166 /* decode each block */ | 3237 /* decode each block */ |
3167 if (s->h263_pred) { | 3238 if (s->h263_pred) { |
3175 if (h263_decode_block(s, block[i], i, cbp&32) < 0) | 3246 if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
3176 return -1; | 3247 return -1; |
3177 cbp+=cbp; | 3248 cbp+=cbp; |
3178 } | 3249 } |
3179 } | 3250 } |
3180 return 0; | 3251 goto end; |
3181 } | 3252 } |
3182 | 3253 |
3183 /* decode each block */ | 3254 /* decode each block */ |
3184 if (s->h263_pred) { | 3255 if (s->h263_pred) { |
3185 for (i = 0; i < 6; i++) { | 3256 for (i = 0; i < 6; i++) { |
3192 if (h263_decode_block(s, block[i], i, cbp&32) < 0) | 3263 if (h263_decode_block(s, block[i], i, cbp&32) < 0) |
3193 return -1; | 3264 return -1; |
3194 cbp+=cbp; | 3265 cbp+=cbp; |
3195 } | 3266 } |
3196 } | 3267 } |
3197 return 0; | 3268 end: |
3269 | |
3270 /* per-MB end of slice check */ | |
3271 if(s->codec_id==CODEC_ID_MPEG4){ | |
3272 if(mpeg4_is_resync(s)){ | |
3273 if(s->pict_type==B_TYPE && s->mbskip_table[s->mb_y * s->mb_width + s->mb_x+1]) | |
3274 return SLICE_OK; | |
3275 return SLICE_END; | |
3276 } | |
3277 }else{ | |
3278 if(get_bits_count(&s->gb) + 7 >= s->gb.size*8){ | |
3279 int v= show_bits(&s->gb, 8) >> (((get_bits_count(&s->gb)-1)&7)+1); | |
3280 if(v==0) | |
3281 return SLICE_END; | |
3282 }else{ | |
3283 if(show_bits(&s->gb, 16)==0) | |
3284 return SLICE_END; | |
3285 } | |
3286 } | |
3287 | |
3288 return SLICE_OK; | |
3198 } | 3289 } |
3199 | 3290 |
3200 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) | 3291 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) |
3201 { | 3292 { |
3202 int code, val, sign, shift, l; | 3293 int code, val, sign, shift, l; |
3312 return 0; | 3403 return 0; |
3313 } | 3404 } |
3314 | 3405 |
3315 for(;;) { | 3406 for(;;) { |
3316 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2); | 3407 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2); |
3317 if (code < 0) | 3408 if (code < 0){ |
3409 fprintf(stderr, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); | |
3318 return -1; | 3410 return -1; |
3411 } | |
3319 if (code == rl->n) { | 3412 if (code == rl->n) { |
3320 /* escape */ | 3413 /* escape */ |
3321 last = get_bits1(&s->gb); | 3414 last = get_bits1(&s->gb); |
3322 run = get_bits(&s->gb, 6); | 3415 run = get_bits(&s->gb, 6); |
3323 level = (INT8)get_bits(&s->gb, 8); | 3416 level = (INT8)get_bits(&s->gb, 8); |
3332 last = code >= rl->last; | 3425 last = code >= rl->last; |
3333 if (get_bits1(&s->gb)) | 3426 if (get_bits1(&s->gb)) |
3334 level = -level; | 3427 level = -level; |
3335 } | 3428 } |
3336 i += run; | 3429 i += run; |
3337 if (i >= 64) | 3430 if (i >= 64){ |
3431 fprintf(stderr, "run overflow at %dx%d\n", s->mb_x, s->mb_y); | |
3338 return -1; | 3432 return -1; |
3433 } | |
3339 j = scan_table[i]; | 3434 j = scan_table[i]; |
3340 block[j] = level; | 3435 block[j] = level; |
3341 if (last) | 3436 if (last) |
3342 break; | 3437 break; |
3343 i++; | 3438 i++; |
3370 level = get_bits(&s->gb, code); | 3465 level = get_bits(&s->gb, code); |
3371 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/ | 3466 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/ |
3372 level = - (level ^ ((1 << code) - 1)); | 3467 level = - (level ^ ((1 << code) - 1)); |
3373 if (code > 8){ | 3468 if (code > 8){ |
3374 if(get_bits1(&s->gb)==0){ /* marker */ | 3469 if(get_bits1(&s->gb)==0){ /* marker */ |
3375 fprintf(stderr, "dc marker bit missing\n"); | 3470 if(s->error_resilience>=2){ |
3376 return -1; | 3471 fprintf(stderr, "dc marker bit missing\n"); |
3377 } | 3472 return -1; |
3378 } | 3473 } |
3379 } | 3474 } |
3380 | 3475 } |
3476 } | |
3381 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr); | 3477 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr); |
3382 level += pred; | 3478 level += pred; |
3383 if (level < 0) | 3479 if (level < 0){ |
3480 if(s->error_resilience>=3){ | |
3481 fprintf(stderr, "dc<0 at %dx%d\n", s->mb_x, s->mb_y); | |
3482 return -1; | |
3483 } | |
3384 level = 0; | 3484 level = 0; |
3485 } | |
3385 if (n < 4) { | 3486 if (n < 4) { |
3386 *dc_val = level * s->y_dc_scale; | 3487 *dc_val = level * s->y_dc_scale; |
3387 } else { | 3488 } else { |
3388 *dc_val = level * s->c_dc_scale; | 3489 *dc_val = level * s->c_dc_scale; |
3389 } | 3490 } |
3491 if(s->error_resilience>=3){ | |
3492 if(*dc_val > 2048 + s->y_dc_scale + s->c_dc_scale){ | |
3493 fprintf(stderr, "dc overflow at %dx%d\n", s->mb_x, s->mb_y); | |
3494 return -1; | |
3495 } | |
3496 } | |
3390 return level; | 3497 return level; |
3391 } | 3498 } |
3392 | 3499 |
3393 /** | 3500 /** |
3394 * decode a block | 3501 * decodes a block. |
3395 * returns 0 if everything went ok | 3502 * @return <0 if an error occured |
3396 * returns DECODING_AC_LOST if an error was detected during AC decoding | |
3397 * returns DECODING_ACDC_LOST if an error was detected during DC decoding | |
3398 */ | 3503 */ |
3399 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, | 3504 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, |
3400 int n, int coded, int intra) | 3505 int n, int coded, int intra) |
3401 { | 3506 { |
3402 int level, i, last, run; | 3507 int level, i, last, run; |
3406 const UINT8 * scan_table; | 3511 const UINT8 * scan_table; |
3407 int qmul, qadd; | 3512 int qmul, qadd; |
3408 | 3513 |
3409 if(intra) { | 3514 if(intra) { |
3410 /* DC coef */ | 3515 /* DC coef */ |
3411 if(s->data_partitioning && s->pict_type!=B_TYPE){ | 3516 if(s->partitioned_frame){ |
3412 level = s->dc_val[0][ s->block_index[n] ]; | 3517 level = s->dc_val[0][ s->block_index[n] ]; |
3413 if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs | 3518 if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs |
3414 else level= (level + (s->c_dc_scale>>1))/s->c_dc_scale; | 3519 else level= (level + (s->c_dc_scale>>1))/s->c_dc_scale; |
3415 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32; | 3520 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32; |
3416 }else{ | 3521 }else{ |
3417 level = mpeg4_decode_dc(s, n, &dc_pred_dir); | 3522 level = mpeg4_decode_dc(s, n, &dc_pred_dir); |
3418 if (level < 0) | 3523 if (level < 0) |
3419 return DECODING_ACDC_LOST; | 3524 return -1; |
3420 } | 3525 } |
3421 block[0] = level; | 3526 block[0] = level; |
3422 i = 0; | 3527 i = 0; |
3423 if (!coded) | 3528 if (!coded) |
3424 goto not_coded; | 3529 goto not_coded; |
3472 SKIP_COUNTER(re, &s->gb, 2+1+6); | 3577 SKIP_COUNTER(re, &s->gb, 2+1+6); |
3473 UPDATE_CACHE(re, &s->gb); | 3578 UPDATE_CACHE(re, &s->gb); |
3474 | 3579 |
3475 if(SHOW_UBITS(re, &s->gb, 1)==0){ | 3580 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
3476 fprintf(stderr, "1. marker bit missing in 3. esc\n"); | 3581 fprintf(stderr, "1. marker bit missing in 3. esc\n"); |
3477 return DECODING_AC_LOST; | 3582 return -1; |
3478 }; SKIP_CACHE(re, &s->gb, 1); | 3583 }; SKIP_CACHE(re, &s->gb, 1); |
3479 | 3584 |
3480 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12); | 3585 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12); |
3481 | 3586 |
3482 if(SHOW_UBITS(re, &s->gb, 1)==0){ | 3587 if(SHOW_UBITS(re, &s->gb, 1)==0){ |
3483 fprintf(stderr, "2. marker bit missing in 3. esc\n"); | 3588 fprintf(stderr, "2. marker bit missing in 3. esc\n"); |
3484 return DECODING_AC_LOST; | 3589 return -1; |
3485 }; LAST_SKIP_CACHE(re, &s->gb, 1); | 3590 }; LAST_SKIP_CACHE(re, &s->gb, 1); |
3486 | 3591 |
3487 SKIP_COUNTER(re, &s->gb, 1+12+1); | 3592 SKIP_COUNTER(re, &s->gb, 1+12+1); |
3488 | 3593 |
3489 if(level*s->qscale>1024 || level*s->qscale<-1024){ | 3594 if(level*s->qscale>1024 || level*s->qscale<-1024){ |
3490 fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale); | 3595 fprintf(stderr, "|level| overflow in 3. esc, qp=%d\n", s->qscale); |
3491 return DECODING_AC_LOST; | 3596 return -1; |
3492 } | 3597 } |
3493 #if 1 | 3598 #if 1 |
3494 { | 3599 { |
3495 const int abs_level= ABS(level); | 3600 const int abs_level= ABS(level); |
3496 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && s->error_resilience>=0){ | 3601 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && ((s->workaround_bugs&FF_BUG_AC_VLC)==0)){ |
3497 const int run1= run - rl->max_run[last][abs_level] - 1; | 3602 const int run1= run - rl->max_run[last][abs_level] - 1; |
3498 if(abs_level <= rl->max_level[last][run]){ | 3603 if(abs_level <= rl->max_level[last][run]){ |
3499 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n"); | 3604 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n"); |
3500 return DECODING_AC_LOST; | 3605 return -1; |
3501 } | 3606 } |
3502 if(abs_level <= rl->max_level[last][run]*2){ | 3607 if(abs_level <= rl->max_level[last][run]*2){ |
3503 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n"); | 3608 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n"); |
3504 return DECODING_AC_LOST; | 3609 return -1; |
3505 } | 3610 } |
3506 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){ | 3611 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){ |
3507 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n"); | 3612 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n"); |
3508 return DECODING_AC_LOST; | 3613 return -1; |
3509 } | 3614 } |
3510 } | 3615 } |
3511 } | 3616 } |
3512 #endif | 3617 #endif |
3513 if (level>0) level= level * qmul + qadd; | 3618 if (level>0) level= level * qmul + qadd; |
3549 } | 3654 } |
3550 if (i > 62){ | 3655 if (i > 62){ |
3551 i-= 192; | 3656 i-= 192; |
3552 if(i&(~63)){ | 3657 if(i&(~63)){ |
3553 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); | 3658 fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
3554 return DECODING_AC_LOST; | 3659 return -1; |
3555 } | 3660 } |
3556 | 3661 |
3557 block[scan_table[i]] = level; | 3662 block[scan_table[i]] = level; |
3558 break; | 3663 break; |
3559 } | 3664 } |
4182 int v_sampling_factor_n= get_bits(&s->gb, 5); | 4287 int v_sampling_factor_n= get_bits(&s->gb, 5); |
4183 int v_sampling_factor_m= get_bits(&s->gb, 5); | 4288 int v_sampling_factor_m= get_bits(&s->gb, 5); |
4184 s->enhancement_type= get_bits1(&s->gb); | 4289 s->enhancement_type= get_bits1(&s->gb); |
4185 | 4290 |
4186 if( h_sampling_factor_n==0 || h_sampling_factor_m==0 | 4291 if( h_sampling_factor_n==0 || h_sampling_factor_m==0 |
4187 || v_sampling_factor_n==0 || v_sampling_factor_m==0 || s->workaround_bugs==1){ | 4292 || v_sampling_factor_n==0 || v_sampling_factor_m==0){ |
4188 | 4293 |
4189 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n"); | 4294 // fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n"); |
4190 s->scalability=0; | 4295 s->scalability=0; |
4191 | 4296 |
4192 s->gb= bak; | 4297 s->gb= bak; |
4201 goto redo; | 4306 goto redo; |
4202 } else if (startcode == 0x1b2) { //userdata | 4307 } else if (startcode == 0x1b2) { //userdata |
4203 char buf[256]; | 4308 char buf[256]; |
4204 int i; | 4309 int i; |
4205 int e; | 4310 int e; |
4206 int ver, build; | 4311 int ver, build, ver2, ver3; |
4207 | 4312 |
4208 //printf("user Data %X\n", show_bits(&s->gb, 32)); | 4313 //printf("user Data %X\n", show_bits(&s->gb, 32)); |
4209 buf[0]= show_bits(&s->gb, 8); | 4314 buf[0]= show_bits(&s->gb, 8); |
4210 for(i=1; i<256; i++){ | 4315 for(i=1; i<256; i++){ |
4211 buf[i]= show_bits(&s->gb, 16)&0xFF; | 4316 buf[i]= show_bits(&s->gb, 16)&0xFF; |
4224 if(ver==500 && build==413){ | 4329 if(ver==500 && build==413){ |
4225 printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n"); | 4330 printf("WARNING: this version of DivX is not MPEG4 compatible, trying to workaround these bugs...\n"); |
4226 } | 4331 } |
4227 } | 4332 } |
4228 } | 4333 } |
4334 e=sscanf(buf, "FFmpeg%d.%d.%db%d", &ver, &ver2, &ver3, &build); | |
4335 if(e!=4) | |
4336 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); | |
4337 if(e!=4){ | |
4338 if(strcmp(buf, "ffmpeg")==0){ | |
4339 s->ffmpeg_version= 0x000406; | |
4340 s->lavc_build= 4600; | |
4341 } | |
4342 } | |
4343 if(e==4){ | |
4344 s->ffmpeg_version= ver*256*256 + ver2*256 + ver3; | |
4345 s->lavc_build= build; | |
4346 if(s->picture_number==0) | |
4347 printf("This file was encoded with libavcodec build %d\n", build); | |
4348 } | |
4229 //printf("User Data: %s\n", buf); | 4349 //printf("User Data: %s\n", buf); |
4230 goto redo; | 4350 goto redo; |
4231 } else if (startcode != 0x1b6) { //VOP | 4351 } else if (startcode != 0x1b6) { //VOP |
4232 goto redo; | 4352 goto redo; |
4233 } | 4353 } |
4234 | 4354 |
4235 s->pict_type = get_bits(&s->gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */ | 4355 s->pict_type = get_bits(&s->gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */ |
4236 //if(s->pict_type!=I_TYPE) return FRAME_SKIPED; | 4356 //if(s->pict_type!=I_TYPE) return FRAME_SKIPED; |
4237 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){ | 4357 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0){ |
4238 printf("low_delay flag set, but shouldnt, clearing it\n"); | 4358 printf("low_delay flag set, but shouldnt, clearing it\n"); |
4239 s->low_delay=0; | 4359 s->low_delay=0; |
4240 } | 4360 } |
4241 // printf("pic: %d, qpel:%d part:%d resync:%d\n", s->pict_type, s->quarter_sample, s->data_partitioning, s->resync_marker); | 4361 // printf("pic: %d, qpel:%d part:%d resync:%d\n", s->pict_type, s->quarter_sample, s->data_partitioning, s->resync_marker); |
4242 | 4362 |
4363 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE; | |
4364 if(s->partitioned_frame) | |
4365 s->decode_mb= mpeg4_decode_partitioned_mb; | |
4366 else | |
4367 s->decode_mb= ff_h263_decode_mb; | |
4368 | |
4243 if(s->time_increment_resolution==0){ | 4369 if(s->time_increment_resolution==0){ |
4244 s->time_increment_resolution=1; | 4370 s->time_increment_resolution=1; |
4245 // fprintf(stderr, "time_increment_resolution is illegal\n"); | 4371 // fprintf(stderr, "time_increment_resolution is illegal\n"); |
4246 } | 4372 } |
4247 time_incr=0; | 4373 time_incr=0; |
4253 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment); | 4379 //printf(" type:%d modulo_time_base:%d increment:%d\n", s->pict_type, time_incr, time_increment); |
4254 if(s->pict_type!=B_TYPE){ | 4380 if(s->pict_type!=B_TYPE){ |
4255 s->last_time_base= s->time_base; | 4381 s->last_time_base= s->time_base; |
4256 s->time_base+= time_incr; | 4382 s->time_base+= time_incr; |
4257 s->time= s->time_base*s->time_increment_resolution + time_increment; | 4383 s->time= s->time_base*s->time_increment_resolution + time_increment; |
4258 if(s->workaround_bugs==3 || s->avctx->fourcc == ff_get_fourcc("UMP4")){ | 4384 if(s->workaround_bugs&FF_BUG_UMP4){ |
4259 if(s->time < s->last_non_b_time){ | 4385 if(s->time < s->last_non_b_time){ |
4260 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n"); | 4386 // fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n"); |
4261 s->time_base++; | 4387 s->time_base++; |
4262 s->time+= s->time_increment_resolution; | 4388 s->time+= s->time_increment_resolution; |
4263 } | 4389 } |
4354 if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n"); | 4480 if(s->sprite_brightness_change) printf("sprite_brightness_change not supported\n"); |
4355 if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n"); | 4481 if(s->vol_sprite_usage==STATIC_SPRITE) printf("static sprite not supported\n"); |
4356 } | 4482 } |
4357 | 4483 |
4358 if (s->shape != BIN_ONLY_SHAPE) { | 4484 if (s->shape != BIN_ONLY_SHAPE) { |
4359 /* note: we do not use quant_precision to avoid problem if no | 4485 s->qscale = get_bits(&s->gb, s->quant_precision); |
4360 MPEG4 vol header as it is found on some old opendivx | |
4361 movies */ | |
4362 s->qscale = get_bits(&s->gb, 5); | |
4363 if(s->qscale==0){ | 4486 if(s->qscale==0){ |
4364 printf("Error, header damaged or not MPEG4 header (qscale=0)\n"); | 4487 printf("Error, header damaged or not MPEG4 header (qscale=0)\n"); |
4365 return -1; // makes no sense to continue, as there is nothing left from the image then | 4488 return -1; // makes no sense to continue, as there is nothing left from the image then |
4366 } | 4489 } |
4367 | 4490 |