Mercurial > libavcodec.hg
comparison h263.c @ 2979:bfabfdf9ce55 libavcodec
COSMETICS: tabs --> spaces, some prettyprinting
author | diego |
---|---|
date | Thu, 22 Dec 2005 01:10:11 +0000 |
parents | ef2149182f1c |
children | 7de97d3ac7ef |
comparison
equal
deleted
inserted
replaced
2978:403183bbb505 | 2979:bfabfdf9ce55 |
---|---|
229 put_bits(&s->pb, 22, 0x20); /* PSC */ | 229 put_bits(&s->pb, 22, 0x20); /* PSC */ |
230 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp | 230 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp |
231 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den); | 231 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den); |
232 put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */ | 232 put_bits(&s->pb, 8, temp_ref & 0xff); /* TemporalReference */ |
233 | 233 |
234 put_bits(&s->pb, 1, 1); /* marker */ | 234 put_bits(&s->pb, 1, 1); /* marker */ |
235 put_bits(&s->pb, 1, 0); /* h263 id */ | 235 put_bits(&s->pb, 1, 0); /* h263 id */ |
236 put_bits(&s->pb, 1, 0); /* split screen off */ | 236 put_bits(&s->pb, 1, 0); /* split screen off */ |
237 put_bits(&s->pb, 1, 0); /* camera off */ | 237 put_bits(&s->pb, 1, 0); /* camera off */ |
238 put_bits(&s->pb, 1, 0); /* freeze picture release off */ | 238 put_bits(&s->pb, 1, 0); /* freeze picture release off */ |
239 | 239 |
240 format = h263_get_picture_format(s->width, s->height); | 240 format = h263_get_picture_format(s->width, s->height); |
241 if (!s->h263_plus) { | 241 if (!s->h263_plus) { |
242 /* H.263v1 */ | 242 /* H.263v1 */ |
243 put_bits(&s->pb, 3, format); | 243 put_bits(&s->pb, 3, format); |
244 put_bits(&s->pb, 1, (s->pict_type == P_TYPE)); | 244 put_bits(&s->pb, 1, (s->pict_type == P_TYPE)); |
245 /* By now UMV IS DISABLED ON H.263v1, since the restrictions | 245 /* By now UMV IS DISABLED ON H.263v1, since the restrictions |
246 of H.263v1 UMV implies to check the predicted MV after | 246 of H.263v1 UMV implies to check the predicted MV after |
247 calculation of the current MB to see if we're on the limits */ | 247 calculation of the current MB to see if we're on the limits */ |
248 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */ | 248 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */ |
249 put_bits(&s->pb, 1, 0); /* SAC: off */ | 249 put_bits(&s->pb, 1, 0); /* SAC: off */ |
250 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */ | 250 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */ |
251 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */ | 251 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */ |
252 put_bits(&s->pb, 5, s->qscale); | 252 put_bits(&s->pb, 5, s->qscale); |
253 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ | 253 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
254 } else { | 254 } else { |
255 int ufep=1; | 255 int ufep=1; |
256 /* H.263v2 */ | 256 /* H.263v2 */ |
257 /* H.263 Plus PTYPE */ | 257 /* H.263 Plus PTYPE */ |
258 | 258 |
284 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ | 284 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ |
285 put_bits(&s->pb,2,0); /* Reserved */ | 285 put_bits(&s->pb,2,0); /* Reserved */ |
286 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | 286 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
287 | 287 |
288 /* This should be here if PLUSPTYPE */ | 288 /* This should be here if PLUSPTYPE */ |
289 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ | 289 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ |
290 | 290 |
291 if (format == 7) { | 291 if (format == 7) { |
292 /* Custom Picture Format (CPFMT) */ | 292 /* Custom Picture Format (CPFMT) */ |
293 aspect_to_info(s, s->avctx->sample_aspect_ratio); | 293 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
294 | 294 |
295 put_bits(&s->pb,4,s->aspect_ratio_info); | 295 put_bits(&s->pb,4,s->aspect_ratio_info); |
296 put_bits(&s->pb,9,(s->width >> 2) - 1); | 296 put_bits(&s->pb,9,(s->width >> 2) - 1); |
297 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ | 297 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ |
298 put_bits(&s->pb,9,(s->height >> 2)); | 298 put_bits(&s->pb,9,(s->height >> 2)); |
299 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ | 299 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ |
300 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | 300 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); |
301 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); | 301 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); |
302 } | 302 } |
303 } | 303 } |
304 if(s->custom_pcf){ | 304 if(s->custom_pcf){ |
305 if(ufep){ | 305 if(ufep){ |
306 put_bits(&s->pb, 1, best_clock_code); | 306 put_bits(&s->pb, 1, best_clock_code); |
307 put_bits(&s->pb, 7, best_divisor); | 307 put_bits(&s->pb, 7, best_divisor); |
318 put_bits(&s->pb,2,0); /* no weird submodes */ | 318 put_bits(&s->pb,2,0); /* no weird submodes */ |
319 | 319 |
320 put_bits(&s->pb, 5, s->qscale); | 320 put_bits(&s->pb, 5, s->qscale); |
321 } | 321 } |
322 | 322 |
323 put_bits(&s->pb, 1, 0); /* no PEI */ | 323 put_bits(&s->pb, 1, 0); /* no PEI */ |
324 | 324 |
325 if(s->h263_slice_structured){ | 325 if(s->h263_slice_structured){ |
326 put_bits(&s->pb, 1, 1); | 326 put_bits(&s->pb, 1, 1); |
327 | 327 |
328 assert(s->mb_x == 0 && s->mb_y == 0); | 328 assert(s->mb_x == 0 && s->mb_y == 0); |
821 } | 821 } |
822 } | 822 } |
823 } | 823 } |
824 | 824 |
825 void mpeg4_encode_mb(MpegEncContext * s, | 825 void mpeg4_encode_mb(MpegEncContext * s, |
826 DCTELEM block[6][64], | 826 DCTELEM block[6][64], |
827 int motion_x, int motion_y) | 827 int motion_x, int motion_y) |
828 { | 828 { |
829 int cbpc, cbpy, pred_x, pred_y; | 829 int cbpc, cbpy, pred_x, pred_y; |
830 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; | 830 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; |
831 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb; | 831 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb; |
832 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb; | 832 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb; |
882 } | 882 } |
883 s->skip_count++; | 883 s->skip_count++; |
884 return; | 884 return; |
885 } | 885 } |
886 | 886 |
887 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ | 887 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ |
888 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge | 888 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge |
889 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :) | 889 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :) |
890 if(cbp) put_bits(&s->pb, 6, cbp); | 890 if(cbp) put_bits(&s->pb, 6, cbp); |
891 | 891 |
892 if(cbp && mb_type){ | 892 if(cbp && mb_type){ |
996 Picture *pic= s->reordered_input_picture[i+1]; | 996 Picture *pic= s->reordered_input_picture[i+1]; |
997 | 997 |
998 if(pic==NULL || pic->pict_type!=B_TYPE) break; | 998 if(pic==NULL || pic->pict_type!=B_TYPE) break; |
999 | 999 |
1000 b_pic= pic->data[0] + offset + 16; //FIXME +16 | 1000 b_pic= pic->data[0] + offset + 16; //FIXME +16 |
1001 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16); | 1001 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16); |
1002 if(diff>s->qscale*70){ //FIXME check that 70 is optimal | 1002 if(diff>s->qscale*70){ //FIXME check that 70 is optimal |
1003 s->mb_skipped=0; | 1003 s->mb_skipped=0; |
1004 break; | 1004 break; |
1005 } | 1005 } |
1006 } | 1006 } |
1019 | 1019 |
1020 return; | 1020 return; |
1021 } | 1021 } |
1022 } | 1022 } |
1023 | 1023 |
1024 put_bits(&s->pb, 1, 0); /* mb coded */ | 1024 put_bits(&s->pb, 1, 0); /* mb coded */ |
1025 cbpc = cbp & 3; | 1025 cbpc = cbp & 3; |
1026 cbpy = cbp >> 2; | 1026 cbpy = cbp >> 2; |
1027 cbpy ^= 0xf; | 1027 cbpy ^= 0xf; |
1028 if(s->mv_type==MV_TYPE_16X16){ | 1028 if(s->mv_type==MV_TYPE_16X16){ |
1029 if(s->dquant) cbpc+= 8; | 1029 if(s->dquant) cbpc+= 8; |
1119 } else { | 1119 } else { |
1120 int cbp; | 1120 int cbp; |
1121 int dc_diff[6]; //dc values with the dc prediction subtracted | 1121 int dc_diff[6]; //dc values with the dc prediction subtracted |
1122 int dir[6]; //prediction direction | 1122 int dir[6]; //prediction direction |
1123 int zigzag_last_index[6]; | 1123 int zigzag_last_index[6]; |
1124 uint8_t *scan_table[6]; | 1124 uint8_t *scan_table[6]; |
1125 int i; | 1125 int i; |
1126 | 1126 |
1127 for(i=0; i<6; i++){ | 1127 for(i=0; i<6; i++){ |
1128 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1); | 1128 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1); |
1129 } | 1129 } |
1150 put_bits(&s->pb, | 1150 put_bits(&s->pb, |
1151 intra_MCBPC_bits[cbpc], | 1151 intra_MCBPC_bits[cbpc], |
1152 intra_MCBPC_code[cbpc]); | 1152 intra_MCBPC_code[cbpc]); |
1153 } else { | 1153 } else { |
1154 if(s->dquant) cbpc+=8; | 1154 if(s->dquant) cbpc+=8; |
1155 put_bits(&s->pb, 1, 0); /* mb coded */ | 1155 put_bits(&s->pb, 1, 0); /* mb coded */ |
1156 put_bits(&s->pb, | 1156 put_bits(&s->pb, |
1157 inter_MCBPC_bits[cbpc + 4], | 1157 inter_MCBPC_bits[cbpc + 4], |
1158 inter_MCBPC_code[cbpc + 4]); | 1158 inter_MCBPC_code[cbpc + 4]); |
1159 } | 1159 } |
1160 put_bits(pb2, 1, s->ac_pred); | 1160 put_bits(pb2, 1, s->ac_pred); |
1183 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); | 1183 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); |
1184 } | 1184 } |
1185 } | 1185 } |
1186 | 1186 |
1187 void h263_encode_mb(MpegEncContext * s, | 1187 void h263_encode_mb(MpegEncContext * s, |
1188 DCTELEM block[6][64], | 1188 DCTELEM block[6][64], |
1189 int motion_x, int motion_y) | 1189 int motion_x, int motion_y) |
1190 { | 1190 { |
1191 int cbpc, cbpy, i, cbp, pred_x, pred_y; | 1191 int cbpc, cbpy, i, cbp, pred_x, pred_y; |
1192 int16_t pred_dc; | 1192 int16_t pred_dc; |
1193 int16_t rec_intradc[6]; | 1193 int16_t rec_intradc[6]; |
1194 uint16_t *dc_ptr[6]; | 1194 uint16_t *dc_ptr[6]; |
1209 } | 1209 } |
1210 s->skip_count++; | 1210 s->skip_count++; |
1211 | 1211 |
1212 return; | 1212 return; |
1213 } | 1213 } |
1214 put_bits(&s->pb, 1, 0); /* mb coded */ | 1214 put_bits(&s->pb, 1, 0); /* mb coded */ |
1215 | 1215 |
1216 cbpc = cbp & 3; | 1216 cbpc = cbp & 3; |
1217 cbpy = cbp >> 2; | 1217 cbpy = cbp >> 2; |
1218 if(s->alt_inter_vlc==0 || cbpc!=3) | 1218 if(s->alt_inter_vlc==0 || cbpc!=3) |
1219 cbpy ^= 0xF; | 1219 cbpy ^= 0xF; |
1344 put_bits(&s->pb, | 1344 put_bits(&s->pb, |
1345 intra_MCBPC_bits[cbpc], | 1345 intra_MCBPC_bits[cbpc], |
1346 intra_MCBPC_code[cbpc]); | 1346 intra_MCBPC_code[cbpc]); |
1347 } else { | 1347 } else { |
1348 if(s->dquant) cbpc+=8; | 1348 if(s->dquant) cbpc+=8; |
1349 put_bits(&s->pb, 1, 0); /* mb coded */ | 1349 put_bits(&s->pb, 1, 0); /* mb coded */ |
1350 put_bits(&s->pb, | 1350 put_bits(&s->pb, |
1351 inter_MCBPC_bits[cbpc + 4], | 1351 inter_MCBPC_bits[cbpc + 4], |
1352 inter_MCBPC_code[cbpc + 4]); | 1352 inter_MCBPC_code[cbpc + 4]); |
1353 } | 1353 } |
1354 if (s->h263_aic) { | 1354 if (s->h263_aic) { |
1355 /* XXX: currently, we do not try to use ac prediction */ | 1355 /* XXX: currently, we do not try to use ac prediction */ |
1356 put_bits(&s->pb, 1, 0); /* no AC prediction */ | 1356 put_bits(&s->pb, 1, 0); /* no AC prediction */ |
1357 } | 1357 } |
1358 cbpy = cbp >> 2; | 1358 cbpy = cbp >> 2; |
1359 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); | 1359 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); |
1360 if(s->dquant) | 1360 if(s->dquant) |
1361 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); | 1361 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); |
1794 /* find number of bits */ | 1794 /* find number of bits */ |
1795 size = 0; | 1795 size = 0; |
1796 v = abs(level); | 1796 v = abs(level); |
1797 while (v) { | 1797 while (v) { |
1798 v >>= 1; | 1798 v >>= 1; |
1799 size++; | 1799 size++; |
1800 } | 1800 } |
1801 | 1801 |
1802 if (level < 0) | 1802 if (level < 0) |
1803 l= (-level) ^ ((1 << size) - 1); | 1803 l= (-level) ^ ((1 << size) - 1); |
1804 else | 1804 else |
2316 put_bits(&s->pb, 16, 0); | 2316 put_bits(&s->pb, 16, 0); |
2317 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ | 2317 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ |
2318 put_bits(&s->pb, 16, 0); | 2318 put_bits(&s->pb, 16, 0); |
2319 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ | 2319 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ |
2320 | 2320 |
2321 put_bits(&s->pb, 1, 0); /* random access vol */ | 2321 put_bits(&s->pb, 1, 0); /* random access vol */ |
2322 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */ | 2322 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */ |
2323 if(s->workaround_bugs & FF_BUG_MS) { | 2323 if(s->workaround_bugs & FF_BUG_MS) { |
2324 put_bits(&s->pb, 1, 0); /* is obj layer id= no */ | 2324 put_bits(&s->pb, 1, 0); /* is obj layer id= no */ |
2325 } else { | 2325 } else { |
2326 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ | 2326 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ |
2327 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ | 2327 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ |
2328 put_bits(&s->pb, 3, 1); /* is obj layer priority */ | 2328 put_bits(&s->pb, 3, 1); /* is obj layer priority */ |
2329 } | 2329 } |
2330 | 2330 |
2331 aspect_to_info(s, s->avctx->sample_aspect_ratio); | 2331 aspect_to_info(s, s->avctx->sample_aspect_ratio); |
2332 | 2332 |
2333 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */ | 2333 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */ |
2335 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); | 2335 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); |
2336 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); | 2336 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); |
2337 } | 2337 } |
2338 | 2338 |
2339 if(s->workaround_bugs & FF_BUG_MS) { // | 2339 if(s->workaround_bugs & FF_BUG_MS) { // |
2340 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */ | 2340 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */ |
2341 } else { | 2341 } else { |
2342 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ | 2342 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ |
2343 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */ | 2343 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */ |
2344 put_bits(&s->pb, 1, s->low_delay); | 2344 put_bits(&s->pb, 1, s->low_delay); |
2345 put_bits(&s->pb, 1, 0); /* vbv parameters= no */ | 2345 put_bits(&s->pb, 1, 0); /* vbv parameters= no */ |
2346 } | 2346 } |
2347 | 2347 |
2348 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ | 2348 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ |
2349 put_bits(&s->pb, 1, 1); /* marker bit */ | 2349 put_bits(&s->pb, 1, 1); /* marker bit */ |
2350 | 2350 |
2351 put_bits(&s->pb, 16, s->avctx->time_base.den); | 2351 put_bits(&s->pb, 16, s->avctx->time_base.den); |
2352 if (s->time_increment_bits < 1) | 2352 if (s->time_increment_bits < 1) |
2353 s->time_increment_bits = 1; | 2353 s->time_increment_bits = 1; |
2354 put_bits(&s->pb, 1, 1); /* marker bit */ | 2354 put_bits(&s->pb, 1, 1); /* marker bit */ |
2355 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ | 2355 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ |
2356 put_bits(&s->pb, 1, 1); /* marker bit */ | 2356 put_bits(&s->pb, 1, 1); /* marker bit */ |
2357 put_bits(&s->pb, 13, s->width); /* vol width */ | 2357 put_bits(&s->pb, 13, s->width); /* vol width */ |
2358 put_bits(&s->pb, 1, 1); /* marker bit */ | 2358 put_bits(&s->pb, 1, 1); /* marker bit */ |
2359 put_bits(&s->pb, 13, s->height); /* vol height */ | 2359 put_bits(&s->pb, 13, s->height); /* vol height */ |
2360 put_bits(&s->pb, 1, 1); /* marker bit */ | 2360 put_bits(&s->pb, 1, 1); /* marker bit */ |
2361 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); | 2361 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); |
2362 put_bits(&s->pb, 1, 1); /* obmc disable */ | 2362 put_bits(&s->pb, 1, 1); /* obmc disable */ |
2363 if (vo_ver_id == 1) { | 2363 if (vo_ver_id == 1) { |
2364 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */ | 2364 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */ |
2365 }else{ | 2365 }else{ |
2366 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */ | 2366 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */ |
2367 } | 2367 } |
2368 | 2368 |
2369 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ | 2369 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ |
2370 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ | 2370 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ |
2371 | 2371 |
2372 if(s->mpeg_quant){ | 2372 if(s->mpeg_quant){ |
2373 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); | 2373 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); |
2374 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); | 2374 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); |
2375 } | 2375 } |
2376 | 2376 |
2377 if (vo_ver_id != 1) | 2377 if (vo_ver_id != 1) |
2378 put_bits(&s->pb, 1, s->quarter_sample); | 2378 put_bits(&s->pb, 1, s->quarter_sample); |
2379 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ | 2379 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ |
2380 s->resync_marker= s->rtp_mode; | 2380 s->resync_marker= s->rtp_mode; |
2381 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ | 2381 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ |
2382 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); | 2382 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); |
2383 if(s->data_partitioning){ | 2383 if(s->data_partitioning){ |
2384 put_bits(&s->pb, 1, 0); /* no rvlc */ | 2384 put_bits(&s->pb, 1, 0); /* no rvlc */ |
2385 } | 2385 } |
2386 | 2386 |
2387 if (vo_ver_id != 1){ | 2387 if (vo_ver_id != 1){ |
2388 put_bits(&s->pb, 1, 0); /* newpred */ | 2388 put_bits(&s->pb, 1, 0); /* newpred */ |
2389 put_bits(&s->pb, 1, 0); /* reduced res vop */ | 2389 put_bits(&s->pb, 1, 0); /* reduced res vop */ |
2390 } | 2390 } |
2391 put_bits(&s->pb, 1, 0); /* scalability */ | 2391 put_bits(&s->pb, 1, 0); /* scalability */ |
2392 | 2392 |
2393 ff_mpeg4_stuffing(&s->pb); | 2393 ff_mpeg4_stuffing(&s->pb); |
2394 | 2394 |
2395 /* user data */ | 2395 /* user data */ |
2396 if(!(s->flags & CODEC_FLAG_BITEXACT)){ | 2396 if(!(s->flags & CODEC_FLAG_BITEXACT)){ |
2397 put_bits(&s->pb, 16, 0); | 2397 put_bits(&s->pb, 16, 0); |
2398 put_bits(&s->pb, 16, 0x1B2); /* user_data */ | 2398 put_bits(&s->pb, 16, 0x1B2); /* user_data */ |
2399 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0); | 2399 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0); |
2400 } | 2400 } |
2401 } | 2401 } |
2402 | 2402 |
2403 /* write mpeg4 VOP header */ | 2403 /* write mpeg4 VOP header */ |
2404 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) | 2404 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) |
2419 | 2419 |
2420 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE; | 2420 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE; |
2421 | 2421 |
2422 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE); | 2422 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE); |
2423 | 2423 |
2424 put_bits(&s->pb, 16, 0); /* vop header */ | 2424 put_bits(&s->pb, 16, 0); /* vop header */ |
2425 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ | 2425 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ |
2426 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ | 2426 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ |
2427 | 2427 |
2428 assert(s->time>=0); | 2428 assert(s->time>=0); |
2429 time_div= s->time/s->avctx->time_base.den; | 2429 time_div= s->time/s->avctx->time_base.den; |
2430 time_mod= s->time%s->avctx->time_base.den; | 2430 time_mod= s->time%s->avctx->time_base.den; |
2431 time_incr= time_div - s->last_time_base; | 2431 time_incr= time_div - s->last_time_base; |
2433 while(time_incr--) | 2433 while(time_incr--) |
2434 put_bits(&s->pb, 1, 1); | 2434 put_bits(&s->pb, 1, 1); |
2435 | 2435 |
2436 put_bits(&s->pb, 1, 0); | 2436 put_bits(&s->pb, 1, 0); |
2437 | 2437 |
2438 put_bits(&s->pb, 1, 1); /* marker */ | 2438 put_bits(&s->pb, 1, 1); /* marker */ |
2439 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */ | 2439 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */ |
2440 put_bits(&s->pb, 1, 1); /* marker */ | 2440 put_bits(&s->pb, 1, 1); /* marker */ |
2441 put_bits(&s->pb, 1, 1); /* vop coded */ | 2441 put_bits(&s->pb, 1, 1); /* vop coded */ |
2442 if ( s->pict_type == P_TYPE | 2442 if ( s->pict_type == P_TYPE |
2443 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { | 2443 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { |
2444 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ | 2444 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ |
2445 } | 2445 } |
2446 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ | 2446 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ |
2447 if(!s->progressive_sequence){ | 2447 if(!s->progressive_sequence){ |
2448 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); | 2448 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); |
2449 put_bits(&s->pb, 1, s->alternate_scan); | 2449 put_bits(&s->pb, 1, s->alternate_scan); |
2450 } | 2450 } |
2451 //FIXME sprite stuff | 2451 //FIXME sprite stuff |
2452 | 2452 |
2453 put_bits(&s->pb, 5, s->qscale); | 2453 put_bits(&s->pb, 5, s->qscale); |
2454 | 2454 |
2455 if (s->pict_type != I_TYPE) | 2455 if (s->pict_type != I_TYPE) |
2456 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ | 2456 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ |
2457 if (s->pict_type == B_TYPE) | 2457 if (s->pict_type == B_TYPE) |
2458 put_bits(&s->pb, 3, s->b_code); /* fcode_back */ | 2458 put_bits(&s->pb, 3, s->b_code); /* fcode_back */ |
2459 // printf("****frame %d\n", picture_number); | 2459 // printf("****frame %d\n", picture_number); |
2460 } | 2460 } |
2461 | 2461 |
2462 #endif //CONFIG_ENCODERS | 2462 #endif //CONFIG_ENCODERS |
2463 | 2463 |
2490 int a, b, c, wrap, pred, scale, ret; | 2490 int a, b, c, wrap, pred, scale, ret; |
2491 uint16_t *dc_val; | 2491 uint16_t *dc_val; |
2492 | 2492 |
2493 /* find prediction */ | 2493 /* find prediction */ |
2494 if (n < 4) { | 2494 if (n < 4) { |
2495 scale = s->y_dc_scale; | 2495 scale = s->y_dc_scale; |
2496 } else { | 2496 } else { |
2497 scale = s->c_dc_scale; | 2497 scale = s->c_dc_scale; |
2498 } | 2498 } |
2499 if(IS_3IV1) | 2499 if(IS_3IV1) |
2500 scale= 8; | 2500 scale= 8; |
2501 | 2501 |
2502 wrap= s->block_wrap[n]; | 2502 wrap= s->block_wrap[n]; |
2518 if(n==0 || n==4 || n==5) | 2518 if(n==0 || n==4 || n==5) |
2519 b=1024; | 2519 b=1024; |
2520 } | 2520 } |
2521 | 2521 |
2522 if (abs(a - b) < abs(b - c)) { | 2522 if (abs(a - b) < abs(b - c)) { |
2523 pred = c; | 2523 pred = c; |
2524 *dir_ptr = 1; /* top */ | 2524 *dir_ptr = 1; /* top */ |
2525 } else { | 2525 } else { |
2526 pred = a; | 2526 pred = a; |
2527 *dir_ptr = 0; /* left */ | 2527 *dir_ptr = 0; /* left */ |
2528 } | 2528 } |
2529 /* we assume pred is positive */ | 2529 /* we assume pred is positive */ |
2530 pred = FASTDIV((pred + (scale >> 1)), scale); | 2530 pred = FASTDIV((pred + (scale >> 1)), scale); |
2531 | 2531 |
2627 { | 2627 { |
2628 #if 1 | 2628 #if 1 |
2629 // if(level<-255 || level>255) printf("dc overflow\n"); | 2629 // if(level<-255 || level>255) printf("dc overflow\n"); |
2630 level+=256; | 2630 level+=256; |
2631 if (n < 4) { | 2631 if (n < 4) { |
2632 /* luminance */ | 2632 /* luminance */ |
2633 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); | 2633 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); |
2634 } else { | 2634 } else { |
2635 /* chrominance */ | 2635 /* chrominance */ |
2636 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); | 2636 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); |
2637 } | 2637 } |
2638 #else | 2638 #else |
2639 int size, v; | 2639 int size, v; |
2640 /* find number of bits */ | 2640 /* find number of bits */ |
2641 size = 0; | 2641 size = 0; |
2642 v = abs(level); | 2642 v = abs(level); |
2643 while (v) { | 2643 while (v) { |
2644 v >>= 1; | 2644 v >>= 1; |
2645 size++; | 2645 size++; |
2646 } | 2646 } |
2647 | 2647 |
2648 if (n < 4) { | 2648 if (n < 4) { |
2649 /* luminance */ | 2649 /* luminance */ |
2650 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); | 2650 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); |
2651 } else { | 2651 } else { |
2652 /* chrominance */ | 2652 /* chrominance */ |
2653 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); | 2653 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); |
2654 } | 2654 } |
2655 | 2655 |
2656 /* encode remaining bits */ | 2656 /* encode remaining bits */ |
2657 if (size > 0) { | 2657 if (size > 0) { |
2658 if (level < 0) | 2658 if (level < 0) |
2659 level = (-level) ^ ((1 << size) - 1); | 2659 level = (-level) ^ ((1 << size) - 1); |
2660 put_bits(&s->pb, size, level); | 2660 put_bits(&s->pb, size, level); |
2661 if (size > 8) | 2661 if (size > 8) |
2662 put_bits(&s->pb, 1, 1); | 2662 put_bits(&s->pb, 1, 1); |
2663 } | 2663 } |
2664 #endif | 2664 #endif |
2665 } | 2665 } |
2666 | 2666 |
2667 static inline int mpeg4_get_dc_length(int level, int n){ | 2667 static inline int mpeg4_get_dc_length(int level, int n){ |
2687 uint32_t *bits_tab; | 2687 uint32_t *bits_tab; |
2688 uint8_t *len_tab; | 2688 uint8_t *len_tab; |
2689 const int last_index = s->block_last_index[n]; | 2689 const int last_index = s->block_last_index[n]; |
2690 | 2690 |
2691 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away | 2691 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away |
2692 /* mpeg4 based DC predictor */ | 2692 /* mpeg4 based DC predictor */ |
2693 mpeg4_encode_dc(dc_pb, intra_dc, n); | 2693 mpeg4_encode_dc(dc_pb, intra_dc, n); |
2694 if(last_index<1) return; | 2694 if(last_index<1) return; |
2695 i = 1; | 2695 i = 1; |
2696 rl = &rl_intra; | 2696 rl = &rl_intra; |
2697 bits_tab= uni_mpeg4_intra_rl_bits; | 2697 bits_tab= uni_mpeg4_intra_rl_bits; |
2698 len_tab = uni_mpeg4_intra_rl_len; | 2698 len_tab = uni_mpeg4_intra_rl_len; |
2699 } else { | 2699 } else { |
2700 if(last_index<0) return; | 2700 if(last_index<0) return; |
2701 i = 0; | 2701 i = 0; |
2702 rl = &rl_inter; | 2702 rl = &rl_inter; |
2703 bits_tab= uni_mpeg4_inter_rl_bits; | 2703 bits_tab= uni_mpeg4_inter_rl_bits; |
2704 len_tab = uni_mpeg4_inter_rl_len; | 2704 len_tab = uni_mpeg4_inter_rl_len; |
2705 } | 2705 } |
2706 | 2706 |
2707 /* AC coefs */ | 2707 /* AC coefs */ |
2708 last_non_zero = i - 1; | 2708 last_non_zero = i - 1; |
2709 #if 1 | 2709 #if 1 |
2710 for (; i < last_index; i++) { | 2710 for (; i < last_index; i++) { |
2711 int level = block[ scan_table[i] ]; | 2711 int level = block[ scan_table[i] ]; |
2712 if (level) { | 2712 if (level) { |
2713 int run = i - last_non_zero - 1; | 2713 int run = i - last_non_zero - 1; |
2714 level+=64; | 2714 level+=64; |
2715 if((level&(~127)) == 0){ | 2715 if((level&(~127)) == 0){ |
2716 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); | 2716 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); |
2717 put_bits(ac_pb, len_tab[index], bits_tab[index]); | 2717 put_bits(ac_pb, len_tab[index], bits_tab[index]); |
2718 }else{ //ESC3 | 2718 }else{ //ESC3 |
2719 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); | 2719 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); |
2720 } | 2720 } |
2721 last_non_zero = i; | 2721 last_non_zero = i; |
2722 } | 2722 } |
2723 } | 2723 } |
2724 /*if(i<=last_index)*/{ | 2724 /*if(i<=last_index)*/{ |
2725 int level = block[ scan_table[i] ]; | 2725 int level = block[ scan_table[i] ]; |
2726 int run = i - last_non_zero - 1; | 2726 int run = i - last_non_zero - 1; |
2727 level+=64; | 2727 level+=64; |
2728 if((level&(~127)) == 0){ | 2728 if((level&(~127)) == 0){ |
2729 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); | 2729 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); |
2730 put_bits(ac_pb, len_tab[index], bits_tab[index]); | 2730 put_bits(ac_pb, len_tab[index], bits_tab[index]); |
2732 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); | 2732 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); |
2733 } | 2733 } |
2734 } | 2734 } |
2735 #else | 2735 #else |
2736 for (; i <= last_index; i++) { | 2736 for (; i <= last_index; i++) { |
2737 const int slevel = block[ scan_table[i] ]; | 2737 const int slevel = block[ scan_table[i] ]; |
2738 if (slevel) { | 2738 if (slevel) { |
2739 int level; | 2739 int level; |
2740 int run = i - last_non_zero - 1; | 2740 int run = i - last_non_zero - 1; |
2741 last = (i == last_index); | 2741 last = (i == last_index); |
2742 sign = 0; | 2742 sign = 0; |
2743 level = slevel; | 2743 level = slevel; |
2744 if (level < 0) { | 2744 if (level < 0) { |
2745 sign = 1; | 2745 sign = 1; |
2746 level = -level; | 2746 level = -level; |
2747 } | 2747 } |
2748 code = get_rl_index(rl, last, run, level); | 2748 code = get_rl_index(rl, last, run, level); |
2749 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | 2749 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
2750 if (code == rl->n) { | 2750 if (code == rl->n) { |
2751 int level1, run1; | 2751 int level1, run1; |
2752 level1 = level - rl->max_level[last][run]; | 2752 level1 = level - rl->max_level[last][run]; |
2784 put_bits(ac_pb, 1, sign); | 2784 put_bits(ac_pb, 1, sign); |
2785 } | 2785 } |
2786 } else { | 2786 } else { |
2787 put_bits(ac_pb, 1, sign); | 2787 put_bits(ac_pb, 1, sign); |
2788 } | 2788 } |
2789 last_non_zero = i; | 2789 last_non_zero = i; |
2790 } | 2790 } |
2791 } | 2791 } |
2792 #endif | 2792 #endif |
2793 } | 2793 } |
2794 | 2794 |
2795 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, | 2795 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, |
2800 uint8_t *len_tab; | 2800 uint8_t *len_tab; |
2801 const int last_index = s->block_last_index[n]; | 2801 const int last_index = s->block_last_index[n]; |
2802 int len=0; | 2802 int len=0; |
2803 | 2803 |
2804 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away | 2804 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away |
2805 /* mpeg4 based DC predictor */ | 2805 /* mpeg4 based DC predictor */ |
2806 len += mpeg4_get_dc_length(intra_dc, n); | 2806 len += mpeg4_get_dc_length(intra_dc, n); |
2807 if(last_index<1) return len; | 2807 if(last_index<1) return len; |
2808 i = 1; | 2808 i = 1; |
2809 rl = &rl_intra; | 2809 rl = &rl_intra; |
2810 len_tab = uni_mpeg4_intra_rl_len; | 2810 len_tab = uni_mpeg4_intra_rl_len; |
2811 } else { | 2811 } else { |
2812 if(last_index<0) return 0; | 2812 if(last_index<0) return 0; |
2813 i = 0; | 2813 i = 0; |
2814 rl = &rl_inter; | 2814 rl = &rl_inter; |
2815 len_tab = uni_mpeg4_inter_rl_len; | 2815 len_tab = uni_mpeg4_inter_rl_len; |
2816 } | 2816 } |
2817 | 2817 |
2818 /* AC coefs */ | 2818 /* AC coefs */ |
2819 last_non_zero = i - 1; | 2819 last_non_zero = i - 1; |
2820 for (; i < last_index; i++) { | 2820 for (; i < last_index; i++) { |
2821 int level = block[ scan_table[i] ]; | 2821 int level = block[ scan_table[i] ]; |
2822 if (level) { | 2822 if (level) { |
2823 int run = i - last_non_zero - 1; | 2823 int run = i - last_non_zero - 1; |
2824 level+=64; | 2824 level+=64; |
2825 if((level&(~127)) == 0){ | 2825 if((level&(~127)) == 0){ |
2826 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); | 2826 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); |
2827 len += len_tab[index]; | 2827 len += len_tab[index]; |
2828 }else{ //ESC3 | 2828 }else{ //ESC3 |
2829 len += 7+2+1+6+1+12+1; | 2829 len += 7+2+1+6+1+12+1; |
2830 } | 2830 } |
2831 last_non_zero = i; | 2831 last_non_zero = i; |
2832 } | 2832 } |
2833 } | 2833 } |
2834 /*if(i<=last_index)*/{ | 2834 /*if(i<=last_index)*/{ |
2835 int level = block[ scan_table[i] ]; | 2835 int level = block[ scan_table[i] ]; |
2836 int run = i - last_non_zero - 1; | 2836 int run = i - last_non_zero - 1; |
2837 level+=64; | 2837 level+=64; |
2838 if((level&(~127)) == 0){ | 2838 if((level&(~127)) == 0){ |
2839 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); | 2839 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); |
2840 len += len_tab[index]; | 2840 len += len_tab[index]; |
3249 } | 3249 } |
3250 | 3250 |
3251 //FIXME reduced res stuff here | 3251 //FIXME reduced res stuff here |
3252 | 3252 |
3253 if (s->pict_type != I_TYPE) { | 3253 if (s->pict_type != I_TYPE) { |
3254 int f_code = get_bits(&s->gb, 3); /* fcode_for */ | 3254 int f_code = get_bits(&s->gb, 3); /* fcode_for */ |
3255 if(f_code==0){ | 3255 if(f_code==0){ |
3256 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n"); | 3256 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n"); |
3257 } | 3257 } |
3258 } | 3258 } |
3259 if (s->pict_type == B_TYPE) { | 3259 if (s->pict_type == B_TYPE) { |
4739 | 4739 |
4740 //Note intra & rvlc should be optimized away if this is inlined | 4740 //Note intra & rvlc should be optimized away if this is inlined |
4741 | 4741 |
4742 if(intra) { | 4742 if(intra) { |
4743 if(s->qscale < s->intra_dc_threshold){ | 4743 if(s->qscale < s->intra_dc_threshold){ |
4744 /* DC coef */ | 4744 /* DC coef */ |
4745 if(s->partitioned_frame){ | 4745 if(s->partitioned_frame){ |
4746 level = s->dc_val[0][ s->block_index[n] ]; | 4746 level = s->dc_val[0][ s->block_index[n] ]; |
4747 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale); | 4747 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale); |
4748 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale); | 4748 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale); |
4749 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; | 4749 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; |
4896 } | 4896 } |
4897 } | 4897 } |
4898 } | 4898 } |
4899 } | 4899 } |
4900 #endif | 4900 #endif |
4901 if (level>0) level= level * qmul + qadd; | 4901 if (level>0) level= level * qmul + qadd; |
4902 else level= level * qmul - qadd; | 4902 else level= level * qmul - qadd; |
4903 | 4903 |
4904 if((unsigned)(level + 2048) > 4095){ | 4904 if((unsigned)(level + 2048) > 4095){ |
4905 if(s->error_resilience > FF_ER_COMPLIANT){ | 4905 if(s->error_resilience > FF_ER_COMPLIANT){ |
4906 if(level > 2560 || level<-2560){ | 4906 if(level > 2560 || level<-2560){ |
5012 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); | 5012 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
5013 return -1; | 5013 return -1; |
5014 } | 5014 } |
5015 if (get_bits1(&s->gb) != 0) { | 5015 if (get_bits1(&s->gb) != 0) { |
5016 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); | 5016 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
5017 return -1; /* h263 id */ | 5017 return -1; /* h263 id */ |
5018 } | 5018 } |
5019 skip_bits1(&s->gb); /* split screen off */ | 5019 skip_bits1(&s->gb); /* split screen off */ |
5020 skip_bits1(&s->gb); /* camera off */ | 5020 skip_bits1(&s->gb); /* camera off */ |
5021 skip_bits1(&s->gb); /* freeze picture release off */ | 5021 skip_bits1(&s->gb); /* freeze picture release off */ |
5022 | 5022 |
5023 format = get_bits(&s->gb, 3); | 5023 format = get_bits(&s->gb, 3); |
5024 /* | 5024 /* |
5025 0 forbidden | 5025 0 forbidden |
5026 1 sub-QCIF | 5026 1 sub-QCIF |
5027 10 QCIF | 5027 10 QCIF |
5028 7 extended PTYPE (PLUSPTYPE) | 5028 7 extended PTYPE (PLUSPTYPE) |
5029 */ | 5029 */ |
5030 | 5030 |
5031 if (format != 7 && format != 6) { | 5031 if (format != 7 && format != 6) { |
5032 s->h263_plus = 0; | 5032 s->h263_plus = 0; |
5033 /* H.263v1 */ | 5033 /* H.263v1 */ |
5040 | 5040 |
5041 s->h263_long_vectors = get_bits1(&s->gb); | 5041 s->h263_long_vectors = get_bits1(&s->gb); |
5042 | 5042 |
5043 if (get_bits1(&s->gb) != 0) { | 5043 if (get_bits1(&s->gb) != 0) { |
5044 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n"); | 5044 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n"); |
5045 return -1; /* SAC: off */ | 5045 return -1; /* SAC: off */ |
5046 } | 5046 } |
5047 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ | 5047 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ |
5048 s->unrestricted_mv = s->h263_long_vectors || s->obmc; | 5048 s->unrestricted_mv = s->h263_long_vectors || s->obmc; |
5049 | 5049 |
5050 if (get_bits1(&s->gb) != 0) { | 5050 if (get_bits1(&s->gb) != 0) { |
5051 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n"); | 5051 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n"); |
5052 return -1; /* not PB frame */ | 5052 return -1; /* not PB frame */ |
5053 } | 5053 } |
5054 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); | 5054 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
5055 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ | 5055 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
5056 | 5056 |
5057 s->width = width; | 5057 s->width = width; |
5058 s->height = height; | 5058 s->height = height; |
5059 s->avctx->sample_aspect_ratio= (AVRational){12,11}; | 5059 s->avctx->sample_aspect_ratio= (AVRational){12,11}; |
5060 s->avctx->time_base= (AVRational){1001, 30000}; | 5060 s->avctx->time_base= (AVRational){1001, 30000}; |
5509 if(chroma_format!=1){ | 5509 if(chroma_format!=1){ |
5510 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n"); | 5510 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n"); |
5511 } | 5511 } |
5512 s->low_delay= get_bits1(gb); | 5512 s->low_delay= get_bits1(gb); |
5513 if(get_bits1(gb)){ /* vbv parameters */ | 5513 if(get_bits1(gb)){ /* vbv parameters */ |
5514 get_bits(gb, 15); /* first_half_bitrate */ | 5514 get_bits(gb, 15); /* first_half_bitrate */ |
5515 skip_bits1(gb); /* marker */ | 5515 skip_bits1(gb); /* marker */ |
5516 get_bits(gb, 15); /* latter_half_bitrate */ | 5516 get_bits(gb, 15); /* latter_half_bitrate */ |
5517 skip_bits1(gb); /* marker */ | 5517 skip_bits1(gb); /* marker */ |
5518 get_bits(gb, 15); /* first_half_vbv_buffer_size */ | 5518 get_bits(gb, 15); /* first_half_vbv_buffer_size */ |
5519 skip_bits1(gb); /* marker */ | 5519 skip_bits1(gb); /* marker */ |
5520 get_bits(gb, 3); /* latter_half_vbv_buffer_size */ | 5520 get_bits(gb, 3); /* latter_half_vbv_buffer_size */ |
5521 get_bits(gb, 11); /* first_half_vbv_occupancy */ | 5521 get_bits(gb, 11); /* first_half_vbv_occupancy */ |
5522 skip_bits1(gb); /* marker */ | 5522 skip_bits1(gb); /* marker */ |
5523 get_bits(gb, 15); /* latter_half_vbv_occupancy */ | 5523 get_bits(gb, 15); /* latter_half_vbv_occupancy */ |
5524 skip_bits1(gb); /* marker */ | 5524 skip_bits1(gb); /* marker */ |
5525 } | 5525 } |
5526 }else{ | 5526 }else{ |
5527 // set low delay flag only once the smartest? low delay detection won't be overriden | 5527 // set low delay flag only once the smartest? low delay detection won't be overriden |
5528 if(s->picture_number==0) | 5528 if(s->picture_number==0) |
5529 s->low_delay=0; | 5529 s->low_delay=0; |
5626 } | 5626 } |
5627 | 5627 |
5628 /* load custom intra matrix */ | 5628 /* load custom intra matrix */ |
5629 if(get_bits1(gb)){ | 5629 if(get_bits1(gb)){ |
5630 int last=0; | 5630 int last=0; |
5631 for(i=0; i<64; i++){ | 5631 for(i=0; i<64; i++){ |
5632 int j; | 5632 int j; |
5633 v= get_bits(gb, 8); | 5633 v= get_bits(gb, 8); |
5634 if(v==0) break; | 5634 if(v==0) break; |
5635 | 5635 |
5636 last= v; | 5636 last= v; |
5639 s->chroma_intra_matrix[j]= v; | 5639 s->chroma_intra_matrix[j]= v; |
5640 } | 5640 } |
5641 | 5641 |
5642 /* replicate last value */ | 5642 /* replicate last value */ |
5643 for(; i<64; i++){ | 5643 for(; i<64; i++){ |
5644 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; | 5644 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
5645 s->intra_matrix[j]= last; | 5645 s->intra_matrix[j]= last; |
5646 s->chroma_intra_matrix[j]= last; | 5646 s->chroma_intra_matrix[j]= last; |
5647 } | 5647 } |
5648 } | 5648 } |
5649 | 5649 |
5650 /* load custom non intra matrix */ | 5650 /* load custom non intra matrix */ |
5651 if(get_bits1(gb)){ | 5651 if(get_bits1(gb)){ |
5652 int last=0; | 5652 int last=0; |
5653 for(i=0; i<64; i++){ | 5653 for(i=0; i<64; i++){ |
5654 int j; | 5654 int j; |
5655 v= get_bits(gb, 8); | 5655 v= get_bits(gb, 8); |
5656 if(v==0) break; | 5656 if(v==0) break; |
5657 | 5657 |
5658 last= v; | 5658 last= v; |
5661 s->chroma_inter_matrix[j]= v; | 5661 s->chroma_inter_matrix[j]= v; |
5662 } | 5662 } |
5663 | 5663 |
5664 /* replicate last value */ | 5664 /* replicate last value */ |
5665 for(; i<64; i++){ | 5665 for(; i<64; i++){ |
5666 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; | 5666 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; |
5667 s->inter_matrix[j]= last; | 5667 s->inter_matrix[j]= last; |
5668 s->chroma_inter_matrix[j]= last; | 5668 s->chroma_inter_matrix[j]= last; |
5669 } | 5669 } |
5670 } | 5670 } |
5671 | 5671 |
5792 } | 5792 } |
5793 | 5793 |
5794 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){ | 5794 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){ |
5795 int time_incr, time_increment; | 5795 int time_incr, time_increment; |
5796 | 5796 |
5797 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */ | 5797 s->pict_type = get_bits(gb, 2) + I_TYPE; /* pict type: I = 0 , P = 1 */ |
5798 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){ | 5798 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){ |
5799 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n"); | 5799 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n"); |
5800 s->low_delay=0; | 5800 s->low_delay=0; |
5801 } | 5801 } |
5802 | 5802 |
5875 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base, | 5875 //printf("time %d %d %d || %Ld %Ld %Ld\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base, |
5876 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time); | 5876 //s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time); |
5877 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE | 5877 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE |
5878 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { | 5878 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { |
5879 /* rounding type for motion estimation */ | 5879 /* rounding type for motion estimation */ |
5880 s->no_rounding = get_bits1(gb); | 5880 s->no_rounding = get_bits1(gb); |
5881 } else { | 5881 } else { |
5882 s->no_rounding = 0; | 5882 s->no_rounding = 0; |
5883 } | 5883 } |
5884 //FIXME reduced res stuff | 5884 //FIXME reduced res stuff |
5885 | 5885 |
5886 if (s->shape != RECT_SHAPE) { | 5886 if (s->shape != RECT_SHAPE) { |
5887 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) { | 5887 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) { |
5936 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n"); | 5936 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n"); |
5937 return -1; // makes no sense to continue, as there is nothing left from the image then | 5937 return -1; // makes no sense to continue, as there is nothing left from the image then |
5938 } | 5938 } |
5939 | 5939 |
5940 if (s->pict_type != I_TYPE) { | 5940 if (s->pict_type != I_TYPE) { |
5941 s->f_code = get_bits(gb, 3); /* fcode_for */ | 5941 s->f_code = get_bits(gb, 3); /* fcode_for */ |
5942 if(s->f_code==0){ | 5942 if(s->f_code==0){ |
5943 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n"); | 5943 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n"); |
5944 return -1; // makes no sense to continue, as the MV decoding will break very quickly | 5944 return -1; // makes no sense to continue, as the MV decoding will break very quickly |
5945 } | 5945 } |
5946 }else | 5946 }else |
6092 } | 6092 } |
6093 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ | 6093 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ |
6094 | 6094 |
6095 if (get_bits1(&s->gb) != 1) { | 6095 if (get_bits1(&s->gb) != 1) { |
6096 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); | 6096 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); |
6097 return -1; /* marker */ | 6097 return -1; /* marker */ |
6098 } | 6098 } |
6099 if (get_bits1(&s->gb) != 0) { | 6099 if (get_bits1(&s->gb) != 0) { |
6100 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); | 6100 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); |
6101 return -1; /* h263 id */ | 6101 return -1; /* h263 id */ |
6102 } | 6102 } |
6103 skip_bits1(&s->gb); /* split screen off */ | 6103 skip_bits1(&s->gb); /* split screen off */ |
6104 skip_bits1(&s->gb); /* camera off */ | 6104 skip_bits1(&s->gb); /* camera off */ |
6105 skip_bits1(&s->gb); /* freeze picture release off */ | 6105 skip_bits1(&s->gb); /* freeze picture release off */ |
6106 | 6106 |
6107 format = get_bits(&s->gb, 3); | 6107 format = get_bits(&s->gb, 3); |
6108 if (format != 7) { | 6108 if (format != 7) { |
6109 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n"); | 6109 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n"); |
6110 return -1; | 6110 return -1; |
6116 s->unrestricted_mv = get_bits1(&s->gb); | 6116 s->unrestricted_mv = get_bits1(&s->gb); |
6117 s->h263_long_vectors = s->unrestricted_mv; | 6117 s->h263_long_vectors = s->unrestricted_mv; |
6118 | 6118 |
6119 if (get_bits1(&s->gb) != 0) { | 6119 if (get_bits1(&s->gb) != 0) { |
6120 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n"); | 6120 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n"); |
6121 return -1; /* SAC: off */ | 6121 return -1; /* SAC: off */ |
6122 } | 6122 } |
6123 if (get_bits1(&s->gb) != 0) { | 6123 if (get_bits1(&s->gb) != 0) { |
6124 s->obmc= 1; | 6124 s->obmc= 1; |
6125 av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n"); | 6125 av_log(s->avctx, AV_LOG_ERROR, "Advanced Prediction Mode not supported\n"); |
6126 // return -1; /* advanced prediction mode: off */ | 6126 // return -1; /* advanced prediction mode: off */ |
6127 } | 6127 } |
6128 if (get_bits1(&s->gb) != 0) { | 6128 if (get_bits1(&s->gb) != 0) { |
6129 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n"); | 6129 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n"); |
6130 return -1; /* PB frame mode */ | 6130 return -1; /* PB frame mode */ |
6131 } | 6131 } |
6132 | 6132 |
6133 /* skip unknown header garbage */ | 6133 /* skip unknown header garbage */ |
6134 skip_bits(&s->gb, 41); | 6134 skip_bits(&s->gb, 41); |
6135 | 6135 |
6136 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); | 6136 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
6137 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ | 6137 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ |
6138 | 6138 |
6139 /* PEI */ | 6139 /* PEI */ |
6140 while (get_bits1(&s->gb) != 0) { | 6140 while (get_bits1(&s->gb) != 0) { |
6141 skip_bits(&s->gb, 8); | 6141 skip_bits(&s->gb, 8); |
6142 } | 6142 } |
6206 s->pict_type = I_TYPE + get_bits(&s->gb, 2); | 6206 s->pict_type = I_TYPE + get_bits(&s->gb, 2); |
6207 s->dropable= s->pict_type > P_TYPE; | 6207 s->dropable= s->pict_type > P_TYPE; |
6208 if (s->dropable) | 6208 if (s->dropable) |
6209 s->pict_type = P_TYPE; | 6209 s->pict_type = P_TYPE; |
6210 | 6210 |
6211 skip_bits1(&s->gb); /* deblocking flag */ | 6211 skip_bits1(&s->gb); /* deblocking flag */ |
6212 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); | 6212 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
6213 | 6213 |
6214 s->h263_plus = 0; | 6214 s->h263_plus = 0; |
6215 | 6215 |
6216 s->unrestricted_mv = 1; | 6216 s->unrestricted_mv = 1; |