00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00034
00035 #include <limits.h>
00036
00037 #include "dsputil.h"
00038 #include "avcodec.h"
00039 #include "mpegvideo.h"
00040 #include "h263data.h"
00041 #include "mpeg4data.h"
00042
00043
00044
00045
00046 #define INTRA_MCBPC_VLC_BITS 6
00047 #define INTER_MCBPC_VLC_BITS 7
00048 #define CBPY_VLC_BITS 6
00049 #define MV_VLC_BITS 9
00050 #define DC_VLC_BITS 9
00051 #define SPRITE_TRAJ_VLC_BITS 6
00052 #define MB_TYPE_B_VLC_BITS 4
00053 #define TEX_VLC_BITS 9
00054 #define H263_MBTYPE_B_VLC_BITS 6
00055 #define CBPC_B_VLC_BITS 3
00056
00057 #ifdef CONFIG_ENCODERS
00058 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
00059 int n);
00060 static void h263p_encode_umotion(MpegEncContext * s, int val);
00061 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
00062 int n, int dc, uint8_t *scan_table,
00063 PutBitContext *dc_pb, PutBitContext *ac_pb);
00064 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
00065 uint8_t *scan_table);
00066 #endif
00067
00068 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
00069 static int h263p_decode_umotion(MpegEncContext * s, int pred);
00070 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
00071 int n, int coded);
00072 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
00073 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
00074 int n, int coded, int intra, int rvlc);
00075 #ifdef CONFIG_ENCODERS
00076 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr);
00077 static void mpeg4_encode_visual_object_header(MpegEncContext * s);
00078 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number);
00079 #endif //CONFIG_ENCODERS
00080 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb);
00081 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding);
00082
00083 #ifdef CONFIG_ENCODERS
00084 static uint8_t uni_DCtab_lum_len[512];
00085 static uint8_t uni_DCtab_chrom_len[512];
00086 static uint16_t uni_DCtab_lum_bits[512];
00087 static uint16_t uni_DCtab_chrom_bits[512];
00088
00089 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
00090 static uint8_t fcode_tab[MAX_MV*2+1];
00091 static uint8_t umv_fcode_tab[MAX_MV*2+1];
00092
00093 static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2];
00094 static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2];
00095 static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2];
00096 static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2];
00097 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
00098 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
00099
00100
00101 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112 #endif
00113
00114 static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3];
00115
00116 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
00117 #define IS_3IV1 s->codec_tag == ff_get_fourcc("3IV1")
00118 #else
00119 #define IS_3IV1 0
00120 #endif
00121
00122 int h263_get_picture_format(int width, int height)
00123 {
00124 int format;
00125
00126 if (width == 128 && height == 96)
00127 format = 1;
00128 else if (width == 176 && height == 144)
00129 format = 2;
00130 else if (width == 352 && height == 288)
00131 format = 3;
00132 else if (width == 704 && height == 576)
00133 format = 4;
00134 else if (width == 1408 && height == 1152)
00135 format = 5;
00136 else
00137 format = 7;
00138 return format;
00139 }
00140
00141 static void show_pict_info(MpegEncContext *s){
00142 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
00143 s->qscale, av_get_pict_type_char(s->pict_type),
00144 s->gb.size_in_bits, 1-s->no_rounding,
00145 s->obmc ? " AP" : "",
00146 s->umvplus ? " UMV" : "",
00147 s->h263_long_vectors ? " LONG" : "",
00148 s->h263_plus ? " +" : "",
00149 s->h263_aic ? " AIC" : "",
00150 s->alt_inter_vlc ? " AIV" : "",
00151 s->modified_quant ? " MQ" : "",
00152 s->loop_filter ? " LOOP" : "",
00153 s->h263_slice_structured ? " SS" : "",
00154 s->avctx->time_base.den, s->avctx->time_base.num
00155 );
00156 }
00157
00158 #ifdef CONFIG_ENCODERS
00159
00160 static void aspect_to_info(MpegEncContext * s, AVRational aspect){
00161 int i;
00162
00163 if(aspect.num==0) aspect= (AVRational){1,1};
00164
00165 for(i=1; i<6; i++){
00166 if(av_cmp_q(pixel_aspect[i], aspect) == 0){
00167 s->aspect_ratio_info=i;
00168 return;
00169 }
00170 }
00171
00172 s->aspect_ratio_info= FF_ASPECT_EXTENDED;
00173 }
00174
00175 void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)
00176 {
00177 int format;
00178
00179 align_put_bits(&s->pb);
00180
00181 put_bits(&s->pb, 17, 1);
00182 put_bits(&s->pb, 5, (s->h263_flv-1));
00183 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) /
00184 s->avctx->time_base.den) & 0xff);
00185 if (s->width == 352 && s->height == 288)
00186 format = 2;
00187 else if (s->width == 176 && s->height == 144)
00188 format = 3;
00189 else if (s->width == 128 && s->height == 96)
00190 format = 4;
00191 else if (s->width == 320 && s->height == 240)
00192 format = 5;
00193 else if (s->width == 160 && s->height == 120)
00194 format = 6;
00195 else if (s->width <= 255 && s->height <= 255)
00196 format = 0;
00197 else
00198 format = 1;
00199 put_bits(&s->pb, 3, format);
00200 if (format == 0) {
00201 put_bits(&s->pb, 8, s->width);
00202 put_bits(&s->pb, 8, s->height);
00203 } else if (format == 1) {
00204 put_bits(&s->pb, 16, s->width);
00205 put_bits(&s->pb, 16, s->height);
00206 }
00207 put_bits(&s->pb, 2, s->pict_type == P_TYPE);
00208 put_bits(&s->pb, 1, 1);
00209 put_bits(&s->pb, 5, s->qscale);
00210 put_bits(&s->pb, 1, 0);
00211
00212 if(s->h263_aic){
00213 s->y_dc_scale_table=
00214 s->c_dc_scale_table= ff_aic_dc_scale_table;
00215 }else{
00216 s->y_dc_scale_table=
00217 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
00218 }
00219 }
00220
00221 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
00222 {
00223 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
00224 int best_clock_code=1;
00225 int best_divisor=60;
00226 int best_error= INT_MAX;
00227
00228 if(s->h263_plus){
00229 for(i=0; i<2; i++){
00230 int div, error;
00231 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
00232 div= av_clip(div, 1, 127);
00233 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
00234 if(error < best_error){
00235 best_error= error;
00236 best_divisor= div;
00237 best_clock_code= i;
00238 }
00239 }
00240 }
00241 s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
00242 coded_frame_rate= 1800000;
00243 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
00244
00245 align_put_bits(&s->pb);
00246
00247
00248 s->ptr_lastgob = pbBufPtr(&s->pb);
00249 put_bits(&s->pb, 22, 0x20);
00250 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num /
00251 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
00252 put_bits(&s->pb, 8, temp_ref & 0xff);
00253
00254 put_bits(&s->pb, 1, 1);
00255 put_bits(&s->pb, 1, 0);
00256 put_bits(&s->pb, 1, 0);
00257 put_bits(&s->pb, 1, 0);
00258 put_bits(&s->pb, 1, 0);
00259
00260 format = h263_get_picture_format(s->width, s->height);
00261 if (!s->h263_plus) {
00262
00263 put_bits(&s->pb, 3, format);
00264 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
00265
00266
00267
00268 put_bits(&s->pb, 1, 0);
00269 put_bits(&s->pb, 1, 0);
00270 put_bits(&s->pb, 1, s->obmc);
00271 put_bits(&s->pb, 1, 0);
00272 put_bits(&s->pb, 5, s->qscale);
00273 put_bits(&s->pb, 1, 0);
00274 } else {
00275 int ufep=1;
00276
00277
00278
00279 put_bits(&s->pb, 3, 7);
00280 put_bits(&s->pb,3,ufep);
00281 if (format == 7)
00282 put_bits(&s->pb,3,6);
00283 else
00284 put_bits(&s->pb, 3, format);
00285
00286 put_bits(&s->pb,1, s->custom_pcf);
00287 put_bits(&s->pb,1, s->umvplus);
00288 put_bits(&s->pb,1,0);
00289 put_bits(&s->pb,1,s->obmc);
00290 put_bits(&s->pb,1,s->h263_aic);
00291 put_bits(&s->pb,1,s->loop_filter);
00292 put_bits(&s->pb,1,s->h263_slice_structured);
00293 put_bits(&s->pb,1,0);
00294 put_bits(&s->pb,1,0);
00295 put_bits(&s->pb,1,s->alt_inter_vlc);
00296 put_bits(&s->pb,1,s->modified_quant);
00297 put_bits(&s->pb,1,1);
00298 put_bits(&s->pb,3,0);
00299
00300 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
00301
00302 put_bits(&s->pb,1,0);
00303 put_bits(&s->pb,1,0);
00304 put_bits(&s->pb,1,s->no_rounding);
00305 put_bits(&s->pb,2,0);
00306 put_bits(&s->pb,1,1);
00307
00308
00309 put_bits(&s->pb, 1, 0);
00310
00311 if (format == 7) {
00312
00313 aspect_to_info(s, s->avctx->sample_aspect_ratio);
00314
00315 put_bits(&s->pb,4,s->aspect_ratio_info);
00316 put_bits(&s->pb,9,(s->width >> 2) - 1);
00317 put_bits(&s->pb,1,1);
00318 put_bits(&s->pb,9,(s->height >> 2));
00319 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
00320 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
00321 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
00322 }
00323 }
00324 if(s->custom_pcf){
00325 if(ufep){
00326 put_bits(&s->pb, 1, best_clock_code);
00327 put_bits(&s->pb, 7, best_divisor);
00328 }
00329 put_bits(&s->pb, 2, (temp_ref>>8)&3);
00330 }
00331
00332
00333 if (s->umvplus)
00334
00335
00336 put_bits(&s->pb,2,1);
00337 if(s->h263_slice_structured)
00338 put_bits(&s->pb,2,0);
00339
00340 put_bits(&s->pb, 5, s->qscale);
00341 }
00342
00343 put_bits(&s->pb, 1, 0);
00344
00345 if(s->h263_slice_structured){
00346 put_bits(&s->pb, 1, 1);
00347
00348 assert(s->mb_x == 0 && s->mb_y == 0);
00349 ff_h263_encode_mba(s);
00350
00351 put_bits(&s->pb, 1, 1);
00352 }
00353
00354 if(s->h263_aic){
00355 s->y_dc_scale_table=
00356 s->c_dc_scale_table= ff_aic_dc_scale_table;
00357 }else{
00358 s->y_dc_scale_table=
00359 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
00360 }
00361 }
00362
00366 void h263_encode_gob_header(MpegEncContext * s, int mb_line)
00367 {
00368 put_bits(&s->pb, 17, 1);
00369
00370 if(s->h263_slice_structured){
00371 put_bits(&s->pb, 1, 1);
00372
00373 ff_h263_encode_mba(s);
00374
00375 if(s->mb_num > 1583)
00376 put_bits(&s->pb, 1, 1);
00377 put_bits(&s->pb, 5, s->qscale);
00378 put_bits(&s->pb, 1, 1);
00379 put_bits(&s->pb, 2, s->pict_type == I_TYPE);
00380 }else{
00381 int gob_number= mb_line / s->gob_index;
00382
00383 put_bits(&s->pb, 5, gob_number);
00384 put_bits(&s->pb, 2, s->pict_type == I_TYPE);
00385 put_bits(&s->pb, 5, s->qscale);
00386 }
00387 }
00388
00389 static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){
00390 int last=0;
00391 int j;
00392 int rate=0;
00393
00394 for(j=1; j<=block_last_index; j++){
00395 const int index= scantable[j];
00396 int level= block[index];
00397 if(level){
00398 level+= 64;
00399 if((level&(~127)) == 0){
00400 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)];
00401 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)];
00402 }else
00403 rate += s->ac_esc_length;
00404 level-= 64;
00405
00406 last= j;
00407 }
00408 }
00409
00410 return rate;
00411 }
00412
00413 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
00414 {
00415 int score= 0;
00416 int i, n;
00417 int8_t * const qscale_table= s->current_picture.qscale_table;
00418
00419 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6);
00420
00421 for(n=0; n<6; n++){
00422 int16_t *ac_val, *ac_val1;
00423
00424 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated);
00425
00426 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
00427 ac_val1= ac_val;
00428 if(dir[n]){
00429 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
00430
00431 ac_val-= s->block_wrap[n]*16;
00432 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
00433
00434 for(i=1; i<8; i++){
00435 const int level= block[n][s->dsp.idct_permutation[i ]];
00436 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8];
00437 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
00438 ac_val1[i+8]= level;
00439 }
00440 }else{
00441
00442 for(i=1; i<8; i++){
00443 const int level= block[n][s->dsp.idct_permutation[i ]];
00444 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
00445 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]];
00446 ac_val1[i+8]= level;
00447 }
00448 }
00449 st[n]= s->intra_h_scantable.permutated;
00450 }else{
00451 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
00452
00453 ac_val-= 16;
00454 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
00455
00456 for(i=1; i<8; i++){
00457 const int level= block[n][s->dsp.idct_permutation[i<<3]];
00458 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i];
00459 ac_val1[i ]= level;
00460 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
00461 }
00462 }else{
00463
00464 for(i=1; i<8; i++){
00465 const int level= block[n][s->dsp.idct_permutation[i<<3]];
00466 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
00467 ac_val1[i ]= level;
00468 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]];
00469 }
00470 }
00471 st[n]= s->intra_v_scantable.permutated;
00472 }
00473
00474 for(i=63; i>0; i--)
00475 if(block[n][ st[n][i] ]) break;
00476 s->block_last_index[n]= i;
00477
00478 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
00479 }
00480
00481 return score < 0;
00482 }
00483
00484 static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6])
00485 {
00486 int i, n;
00487 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6);
00488
00489 for(n=0; n<6; n++){
00490 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
00491
00492 st[n]= s->intra_scantable.permutated;
00493 if(dir[n]){
00494
00495 for(i=1; i<8; i++){
00496 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8];
00497 }
00498 }else{
00499
00500 for(i=1; i<8; i++){
00501 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ];
00502 }
00503 }
00504 }
00505 }
00506
00510 static void ff_init_qscale_tab(MpegEncContext *s){
00511 int8_t * const qscale_table= s->current_picture.qscale_table;
00512 int i;
00513
00514 for(i=0; i<s->mb_num; i++){
00515 unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ];
00516 int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
00517 qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax);
00518 }
00519 }
00520
00524 void ff_clean_h263_qscales(MpegEncContext *s){
00525 int i;
00526 int8_t * const qscale_table= s->current_picture.qscale_table;
00527
00528 ff_init_qscale_tab(s);
00529
00530 for(i=1; i<s->mb_num; i++){
00531 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
00532 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
00533 }
00534 for(i=s->mb_num-2; i>=0; i--){
00535 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
00536 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
00537 }
00538
00539 if(s->codec_id != CODEC_ID_H263P){
00540 for(i=1; i<s->mb_num; i++){
00541 int mb_xy= s->mb_index2xy[i];
00542
00543 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
00544 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
00545 }
00546 }
00547 }
00548 }
00549
00553 void ff_clean_mpeg4_qscales(MpegEncContext *s){
00554 int i;
00555 int8_t * const qscale_table= s->current_picture.qscale_table;
00556
00557 ff_clean_h263_qscales(s);
00558
00559 if(s->pict_type== B_TYPE){
00560 int odd=0;
00561
00562
00563 for(i=0; i<s->mb_num; i++){
00564 int mb_xy= s->mb_index2xy[i];
00565 odd += qscale_table[mb_xy]&1;
00566 }
00567
00568 if(2*odd > s->mb_num) odd=1;
00569 else odd=0;
00570
00571 for(i=0; i<s->mb_num; i++){
00572 int mb_xy= s->mb_index2xy[i];
00573 if((qscale_table[mb_xy]&1) != odd)
00574 qscale_table[mb_xy]++;
00575 if(qscale_table[mb_xy] > 31)
00576 qscale_table[mb_xy]= 31;
00577 }
00578
00579 for(i=1; i<s->mb_num; i++){
00580 int mb_xy= s->mb_index2xy[i];
00581 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){
00582 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;
00583 }
00584 }
00585 }
00586 }
00587
00588 #endif //CONFIG_ENCODERS
00589
00590 #define tab_size ((signed)(sizeof(s->direct_scale_mv[0])/sizeof(int16_t)))
00591 #define tab_bias (tab_size/2)
00592
00593 void ff_mpeg4_init_direct_mv(MpegEncContext *s){
00594 int i;
00595 for(i=0; i<tab_size; i++){
00596 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time;
00597 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time;
00598 }
00599 }
00600
00601 static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){
00602 int xy= s->block_index[i];
00603 uint16_t time_pp= s->pp_time;
00604 uint16_t time_pb= s->pb_time;
00605 int p_mx, p_my;
00606
00607 p_mx= s->next_picture.motion_val[0][xy][0];
00608 if((unsigned)(p_mx + tab_bias) < tab_size){
00609 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx;
00610 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
00611 : s->direct_scale_mv[1][p_mx + tab_bias];
00612 }else{
00613 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx;
00614 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx
00615 : p_mx*(time_pb - time_pp)/time_pp;
00616 }
00617 p_my= s->next_picture.motion_val[0][xy][1];
00618 if((unsigned)(p_my + tab_bias) < tab_size){
00619 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my;
00620 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
00621 : s->direct_scale_mv[1][p_my + tab_bias];
00622 }else{
00623 s->mv[0][i][1] = p_my*time_pb/time_pp + my;
00624 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my
00625 : p_my*(time_pb - time_pp)/time_pp;
00626 }
00627 }
00628
00629 #undef tab_size
00630 #undef tab_bias
00631
00636 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){
00637 const int mb_index= s->mb_x + s->mb_y*s->mb_stride;
00638 const int colocated_mb_type= s->next_picture.mb_type[mb_index];
00639 uint16_t time_pp= s->pp_time;
00640 uint16_t time_pb= s->pb_time;
00641 int i;
00642
00643
00644
00645
00646 if(IS_8X8(colocated_mb_type)){
00647 s->mv_type = MV_TYPE_8X8;
00648 for(i=0; i<4; i++){
00649 ff_mpeg4_set_one_direct_mv(s, mx, my, i);
00650 }
00651 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
00652 } else if(IS_INTERLACED(colocated_mb_type)){
00653 s->mv_type = MV_TYPE_FIELD;
00654 for(i=0; i<2; i++){
00655 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]];
00656 s->field_select[0][i]= field_select;
00657 s->field_select[1][i]= i;
00658 if(s->top_field_first){
00659 time_pp= s->pp_field_time - field_select + i;
00660 time_pb= s->pb_field_time - field_select + i;
00661 }else{
00662 time_pp= s->pp_field_time + field_select - i;
00663 time_pb= s->pb_field_time + field_select - i;
00664 }
00665 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;
00666 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;
00667 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]
00668 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;
00669 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1]
00670 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;
00671 }
00672 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;
00673 }else{
00674 ff_mpeg4_set_one_direct_mv(s, mx, my, 0);
00675 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0];
00676 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1];
00677 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0];
00678 s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1];
00679 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample)
00680 s->mv_type= MV_TYPE_16X16;
00681 else
00682 s->mv_type= MV_TYPE_8X8;
00683 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1;
00684 }
00685 }
00686
00687 void ff_h263_update_motion_val(MpegEncContext * s){
00688 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
00689
00690 const int wrap = s->b8_stride;
00691 const int xy = s->block_index[0];
00692
00693 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped;
00694
00695 if(s->mv_type != MV_TYPE_8X8){
00696 int motion_x, motion_y;
00697 if (s->mb_intra) {
00698 motion_x = 0;
00699 motion_y = 0;
00700 } else if (s->mv_type == MV_TYPE_16X16) {
00701 motion_x = s->mv[0][0][0];
00702 motion_y = s->mv[0][0][1];
00703 } else {
00704 int i;
00705 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
00706 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
00707 motion_x = (motion_x>>1) | (motion_x&1);
00708 for(i=0; i<2; i++){
00709 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];
00710 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];
00711 }
00712 s->current_picture.ref_index[0][xy ]=
00713 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0];
00714 s->current_picture.ref_index[0][xy + wrap ]=
00715 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1];
00716 }
00717
00718
00719 s->current_picture.motion_val[0][xy][0] = motion_x;
00720 s->current_picture.motion_val[0][xy][1] = motion_y;
00721 s->current_picture.motion_val[0][xy + 1][0] = motion_x;
00722 s->current_picture.motion_val[0][xy + 1][1] = motion_y;
00723 s->current_picture.motion_val[0][xy + wrap][0] = motion_x;
00724 s->current_picture.motion_val[0][xy + wrap][1] = motion_y;
00725 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x;
00726 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y;
00727 }
00728
00729 if(s->encoding){
00730 if (s->mv_type == MV_TYPE_8X8)
00731 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
00732 else if(s->mb_intra)
00733 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA;
00734 else
00735 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
00736 }
00737 }
00738
00739 #ifdef CONFIG_ENCODERS
00740
00741 static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){
00742 int l, bit_size, code;
00743
00744 if (val == 0) {
00745 return mvtab[0][1];
00746 } else {
00747 bit_size = f_code - 1;
00748
00749 l= INT_BIT - 6 - bit_size;
00750 val = (val<<l)>>l;
00751 val--;
00752 code = (val >> bit_size) + 1;
00753
00754 return mvtab[code][1] + 1 + bit_size;
00755 }
00756 }
00757
00758 static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
00759 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
00760 skip_put_bits(&s->pb,
00761 h263_get_motion_length(s, x, f_code)
00762 +h263_get_motion_length(s, y, f_code));
00763 }else{
00764 ff_h263_encode_motion(s, x, f_code);
00765 ff_h263_encode_motion(s, y, f_code);
00766 }
00767 }
00768
00769 static inline int get_p_cbp(MpegEncContext * s,
00770 DCTELEM block[6][64],
00771 int motion_x, int motion_y){
00772 int cbp, i;
00773
00774 if(s->flags & CODEC_FLAG_CBP_RD){
00775 int best_cbpy_score= INT_MAX;
00776 int best_cbpc_score= INT_MAX;
00777 int cbpc = (-1), cbpy= (-1);
00778 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
00779 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
00780
00781 for(i=0; i<4; i++){
00782 int score= inter_MCBPC_bits[i + offset] * lambda;
00783 if(i&1) score += s->coded_score[5];
00784 if(i&2) score += s->coded_score[4];
00785
00786 if(score < best_cbpc_score){
00787 best_cbpc_score= score;
00788 cbpc= i;
00789 }
00790 }
00791
00792 for(i=0; i<16; i++){
00793 int score= cbpy_tab[i ^ 0xF][1] * lambda;
00794 if(i&1) score += s->coded_score[3];
00795 if(i&2) score += s->coded_score[2];
00796 if(i&4) score += s->coded_score[1];
00797 if(i&8) score += s->coded_score[0];
00798
00799 if(score < best_cbpy_score){
00800 best_cbpy_score= score;
00801 cbpy= i;
00802 }
00803 }
00804 cbp= cbpc + 4*cbpy;
00805 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
00806 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
00807 cbp= 0;
00808 }
00809
00810 for (i = 0; i < 6; i++) {
00811 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
00812 s->block_last_index[i]= -1;
00813 memset(s->block[i], 0, sizeof(DCTELEM)*64);
00814 }
00815 }
00816 }else{
00817 cbp= 0;
00818 for (i = 0; i < 6; i++) {
00819 if (s->block_last_index[i] >= 0)
00820 cbp |= 1 << (5 - i);
00821 }
00822 }
00823 return cbp;
00824 }
00825
00826 static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64],
00827 int motion_x, int motion_y, int mb_type){
00828 int cbp=0, i;
00829
00830 if(s->flags & CODEC_FLAG_CBP_RD){
00831 int score=0;
00832 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
00833
00834 for(i=0; i<6; i++){
00835 if(s->coded_score[i] < 0){
00836 score += s->coded_score[i];
00837 cbp |= 1 << (5 - i);
00838 }
00839 }
00840
00841 if(cbp){
00842 int zero_score= -6;
00843 if ((motion_x | motion_y | s->dquant | mb_type) == 0){
00844 zero_score-= 4;
00845 }
00846
00847 zero_score*= lambda;
00848 if(zero_score <= score){
00849 cbp=0;
00850 }
00851 }
00852
00853 for (i = 0; i < 6; i++) {
00854 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
00855 s->block_last_index[i]= -1;
00856 memset(s->block[i], 0, sizeof(DCTELEM)*64);
00857 }
00858 }
00859 }else{
00860 for (i = 0; i < 6; i++) {
00861 if (s->block_last_index[i] >= 0)
00862 cbp |= 1 << (5 - i);
00863 }
00864 }
00865 return cbp;
00866 }
00867
00868 static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6],
00869 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){
00870 int i;
00871
00872 if(scan_table){
00873 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
00874 for (i = 0; i < 6; i++) {
00875 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i]));
00876 }
00877 }else{
00878
00879 for (i = 0; i < 6; i++) {
00880 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb);
00881 }
00882 }
00883 }else{
00884 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){
00885 for (i = 0; i < 6; i++) {
00886 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated));
00887 }
00888 }else{
00889
00890 for (i = 0; i < 6; i++) {
00891 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb);
00892 }
00893 }
00894 }
00895 }
00896
00897 void mpeg4_encode_mb(MpegEncContext * s,
00898 DCTELEM block[6][64],
00899 int motion_x, int motion_y)
00900 {
00901 int cbpc, cbpy, pred_x, pred_y;
00902 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
00903 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
00904 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
00905 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
00906 const int dquant_code[5]= {1,0,9,2,3};
00907
00908
00909 if (!s->mb_intra) {
00910 int i, cbp;
00911
00912 if(s->pict_type==B_TYPE){
00913 static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0};
00914 int mb_type= mb_type_table[s->mv_dir];
00915
00916 if(s->mb_x==0){
00917 for(i=0; i<2; i++){
00918 s->last_mv[i][0][0]=
00919 s->last_mv[i][0][1]=
00920 s->last_mv[i][1][0]=
00921 s->last_mv[i][1][1]= 0;
00922 }
00923 }
00924
00925 assert(s->dquant>=-2 && s->dquant<=2);
00926 assert((s->dquant&1)==0);
00927 assert(mb_type>=0);
00928
00929
00930 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){
00931 s->skip_count++;
00932 s->mv[0][0][0]=
00933 s->mv[0][0][1]=
00934 s->mv[1][0][0]=
00935 s->mv[1][0][1]= 0;
00936 s->mv_dir= MV_DIR_FORWARD;
00937 s->qscale -= s->dquant;
00938
00939
00940 return;
00941 }
00942
00943 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type);
00944
00945 if ((cbp | motion_x | motion_y | mb_type) ==0) {
00946
00947 assert(s->dquant==0);
00948
00949 put_bits(&s->pb, 1, 1);
00950
00951 if(interleaved_stats){
00952 s->misc_bits++;
00953 s->last_bits++;
00954 }
00955 s->skip_count++;
00956 return;
00957 }
00958
00959 put_bits(&s->pb, 1, 0);
00960 put_bits(&s->pb, 1, cbp ? 0 : 1);
00961 put_bits(&s->pb, mb_type+1, 1);
00962 if(cbp) put_bits(&s->pb, 6, cbp);
00963
00964 if(cbp && mb_type){
00965 if(s->dquant)
00966 put_bits(&s->pb, 2, (s->dquant>>2)+3);
00967 else
00968 put_bits(&s->pb, 1, 0);
00969 }else
00970 s->qscale -= s->dquant;
00971
00972 if(!s->progressive_sequence){
00973 if(cbp)
00974 put_bits(&s->pb, 1, s->interlaced_dct);
00975 if(mb_type)
00976 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
00977 }
00978
00979 if(interleaved_stats){
00980 s->misc_bits+= get_bits_diff(s);
00981 }
00982
00983 if(mb_type == 0){
00984 assert(s->mv_dir & MV_DIRECT);
00985 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
00986 s->b_count++;
00987 s->f_count++;
00988 }else{
00989 assert(mb_type > 0 && mb_type < 4);
00990 if(s->mv_type != MV_TYPE_FIELD){
00991 if(s->mv_dir & MV_DIR_FORWARD){
00992 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0],
00993 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
00994 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];
00995 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];
00996 s->f_count++;
00997 }
00998 if(s->mv_dir & MV_DIR_BACKWARD){
00999 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0],
01000 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
01001 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];
01002 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];
01003 s->b_count++;
01004 }
01005 }else{
01006 if(s->mv_dir & MV_DIR_FORWARD){
01007 put_bits(&s->pb, 1, s->field_select[0][0]);
01008 put_bits(&s->pb, 1, s->field_select[0][1]);
01009 }
01010 if(s->mv_dir & MV_DIR_BACKWARD){
01011 put_bits(&s->pb, 1, s->field_select[1][0]);
01012 put_bits(&s->pb, 1, s->field_select[1][1]);
01013 }
01014 if(s->mv_dir & MV_DIR_FORWARD){
01015 for(i=0; i<2; i++){
01016 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] ,
01017 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);
01018 s->last_mv[0][i][0]= s->mv[0][i][0];
01019 s->last_mv[0][i][1]= s->mv[0][i][1]*2;
01020 }
01021 s->f_count++;
01022 }
01023 if(s->mv_dir & MV_DIR_BACKWARD){
01024 for(i=0; i<2; i++){
01025 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] ,
01026 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);
01027 s->last_mv[1][i][0]= s->mv[1][i][0];
01028 s->last_mv[1][i][1]= s->mv[1][i][1]*2;
01029 }
01030 s->b_count++;
01031 }
01032 }
01033 }
01034
01035 if(interleaved_stats){
01036 s->mv_bits+= get_bits_diff(s);
01037 }
01038
01039 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
01040
01041 if(interleaved_stats){
01042 s->p_tex_bits+= get_bits_diff(s);
01043 }
01044
01045 }else{
01046 cbp= get_p_cbp(s, block, motion_x, motion_y);
01047
01048 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) {
01049
01050
01051 if(s->max_b_frames>0){
01052 int i;
01053 int x,y, offset;
01054 uint8_t *p_pic;
01055
01056 x= s->mb_x*16;
01057 y= s->mb_y*16;
01058 if(x+16 > s->width) x= s->width-16;
01059 if(y+16 > s->height) y= s->height-16;
01060
01061 offset= x + y*s->linesize;
01062 p_pic= s->new_picture.data[0] + offset;
01063
01064 s->mb_skipped=1;
01065 for(i=0; i<s->max_b_frames; i++){
01066 uint8_t *b_pic;
01067 int diff;
01068 Picture *pic= s->reordered_input_picture[i+1];
01069
01070 if(pic==NULL || pic->pict_type!=B_TYPE) break;
01071
01072 b_pic= pic->data[0] + offset;
01073 if(pic->type != FF_BUFFER_TYPE_SHARED)
01074 b_pic+= INPLACE_OFFSET;
01075 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
01076 if(diff>s->qscale*70){
01077 s->mb_skipped=0;
01078 break;
01079 }
01080 }
01081 }else
01082 s->mb_skipped=1;
01083
01084 if(s->mb_skipped==1){
01085
01086 put_bits(&s->pb, 1, 1);
01087
01088 if(interleaved_stats){
01089 s->misc_bits++;
01090 s->last_bits++;
01091 }
01092 s->skip_count++;
01093
01094 return;
01095 }
01096 }
01097
01098 put_bits(&s->pb, 1, 0);
01099 cbpc = cbp & 3;
01100 cbpy = cbp >> 2;
01101 cbpy ^= 0xf;
01102 if(s->mv_type==MV_TYPE_16X16){
01103 if(s->dquant) cbpc+= 8;
01104 put_bits(&s->pb,
01105 inter_MCBPC_bits[cbpc],
01106 inter_MCBPC_code[cbpc]);
01107
01108 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01109 if(s->dquant)
01110 put_bits(pb2, 2, dquant_code[s->dquant+2]);
01111
01112 if(!s->progressive_sequence){
01113 if(cbp)
01114 put_bits(pb2, 1, s->interlaced_dct);
01115 put_bits(pb2, 1, 0);
01116 }
01117
01118 if(interleaved_stats){
01119 s->misc_bits+= get_bits_diff(s);
01120 }
01121
01122
01123 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
01124
01125 ff_h263_encode_motion_vector(s, motion_x - pred_x,
01126 motion_y - pred_y, s->f_code);
01127 }else if(s->mv_type==MV_TYPE_FIELD){
01128 if(s->dquant) cbpc+= 8;
01129 put_bits(&s->pb,
01130 inter_MCBPC_bits[cbpc],
01131 inter_MCBPC_code[cbpc]);
01132
01133 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01134 if(s->dquant)
01135 put_bits(pb2, 2, dquant_code[s->dquant+2]);
01136
01137 assert(!s->progressive_sequence);
01138 if(cbp)
01139 put_bits(pb2, 1, s->interlaced_dct);
01140 put_bits(pb2, 1, 1);
01141
01142 if(interleaved_stats){
01143 s->misc_bits+= get_bits_diff(s);
01144 }
01145
01146
01147 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
01148 pred_y /=2;
01149
01150 put_bits(&s->pb, 1, s->field_select[0][0]);
01151 put_bits(&s->pb, 1, s->field_select[0][1]);
01152
01153 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x,
01154 s->mv[0][0][1] - pred_y, s->f_code);
01155 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x,
01156 s->mv[0][1][1] - pred_y, s->f_code);
01157 }else{
01158 assert(s->mv_type==MV_TYPE_8X8);
01159 put_bits(&s->pb,
01160 inter_MCBPC_bits[cbpc+16],
01161 inter_MCBPC_code[cbpc+16]);
01162 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01163
01164 if(!s->progressive_sequence){
01165 if(cbp)
01166 put_bits(pb2, 1, s->interlaced_dct);
01167 }
01168
01169 if(interleaved_stats){
01170 s->misc_bits+= get_bits_diff(s);
01171 }
01172
01173 for(i=0; i<4; i++){
01174
01175 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
01176
01177 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x,
01178 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code);
01179 }
01180 }
01181
01182 if(interleaved_stats){
01183 s->mv_bits+= get_bits_diff(s);
01184 }
01185
01186 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
01187
01188 if(interleaved_stats){
01189 s->p_tex_bits+= get_bits_diff(s);
01190 }
01191 s->f_count++;
01192 }
01193 } else {
01194 int cbp;
01195 int dc_diff[6];
01196 int dir[6];
01197 int zigzag_last_index[6];
01198 uint8_t *scan_table[6];
01199 int i;
01200
01201 for(i=0; i<6; i++){
01202 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
01203 }
01204
01205 if(s->flags & CODEC_FLAG_AC_PRED){
01206 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
01207 if(!s->ac_pred)
01208 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
01209 }else{
01210 for(i=0; i<6; i++)
01211 scan_table[i]= s->intra_scantable.permutated;
01212 }
01213
01214
01215 cbp = 0;
01216 for (i = 0; i < 6; i++) {
01217 if (s->block_last_index[i] >= 1)
01218 cbp |= 1 << (5 - i);
01219 }
01220
01221 cbpc = cbp & 3;
01222 if (s->pict_type == I_TYPE) {
01223 if(s->dquant) cbpc+=4;
01224 put_bits(&s->pb,
01225 intra_MCBPC_bits[cbpc],
01226 intra_MCBPC_code[cbpc]);
01227 } else {
01228 if(s->dquant) cbpc+=8;
01229 put_bits(&s->pb, 1, 0);
01230 put_bits(&s->pb,
01231 inter_MCBPC_bits[cbpc + 4],
01232 inter_MCBPC_code[cbpc + 4]);
01233 }
01234 put_bits(pb2, 1, s->ac_pred);
01235 cbpy = cbp >> 2;
01236 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01237 if(s->dquant)
01238 put_bits(dc_pb, 2, dquant_code[s->dquant+2]);
01239
01240 if(!s->progressive_sequence){
01241 put_bits(dc_pb, 1, s->interlaced_dct);
01242 }
01243
01244 if(interleaved_stats){
01245 s->misc_bits+= get_bits_diff(s);
01246 }
01247
01248 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
01249
01250 if(interleaved_stats){
01251 s->i_tex_bits+= get_bits_diff(s);
01252 }
01253 s->i_count++;
01254
01255
01256 if(s->ac_pred)
01257 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
01258 }
01259 }
01260
01261 void h263_encode_mb(MpegEncContext * s,
01262 DCTELEM block[6][64],
01263 int motion_x, int motion_y)
01264 {
01265 int cbpc, cbpy, i, cbp, pred_x, pred_y;
01266 int16_t pred_dc;
01267 int16_t rec_intradc[6];
01268 int16_t *dc_ptr[6];
01269 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
01270 const int dquant_code[5]= {1,0,9,2,3};
01271
01272
01273 if (!s->mb_intra) {
01274
01275 cbp= get_p_cbp(s, block, motion_x, motion_y);
01276
01277 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
01278
01279 put_bits(&s->pb, 1, 1);
01280 if(interleaved_stats){
01281 s->misc_bits++;
01282 s->last_bits++;
01283 }
01284 s->skip_count++;
01285
01286 return;
01287 }
01288 put_bits(&s->pb, 1, 0);
01289
01290 cbpc = cbp & 3;
01291 cbpy = cbp >> 2;
01292 if(s->alt_inter_vlc==0 || cbpc!=3)
01293 cbpy ^= 0xF;
01294 if(s->dquant) cbpc+= 8;
01295 if(s->mv_type==MV_TYPE_16X16){
01296 put_bits(&s->pb,
01297 inter_MCBPC_bits[cbpc],
01298 inter_MCBPC_code[cbpc]);
01299
01300 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01301 if(s->dquant)
01302 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
01303
01304 if(interleaved_stats){
01305 s->misc_bits+= get_bits_diff(s);
01306 }
01307
01308
01309 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
01310
01311 if (!s->umvplus) {
01312 ff_h263_encode_motion_vector(s, motion_x - pred_x,
01313 motion_y - pred_y, 1);
01314 }
01315 else {
01316 h263p_encode_umotion(s, motion_x - pred_x);
01317 h263p_encode_umotion(s, motion_y - pred_y);
01318 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
01319
01320 put_bits(&s->pb,1,1);
01321 }
01322 }else{
01323 put_bits(&s->pb,
01324 inter_MCBPC_bits[cbpc+16],
01325 inter_MCBPC_code[cbpc+16]);
01326 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01327 if(s->dquant)
01328 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
01329
01330 if(interleaved_stats){
01331 s->misc_bits+= get_bits_diff(s);
01332 }
01333
01334 for(i=0; i<4; i++){
01335
01336 h263_pred_motion(s, i, 0, &pred_x, &pred_y);
01337
01338 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0];
01339 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1];
01340 if (!s->umvplus) {
01341 ff_h263_encode_motion_vector(s, motion_x - pred_x,
01342 motion_y - pred_y, 1);
01343 }
01344 else {
01345 h263p_encode_umotion(s, motion_x - pred_x);
01346 h263p_encode_umotion(s, motion_y - pred_y);
01347 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
01348
01349 put_bits(&s->pb,1,1);
01350 }
01351 }
01352 }
01353
01354 if(interleaved_stats){
01355 s->mv_bits+= get_bits_diff(s);
01356 }
01357 } else {
01358 assert(s->mb_intra);
01359
01360 cbp = 0;
01361 if (s->h263_aic) {
01362
01363 for(i=0; i<6; i++) {
01364 int16_t level = block[i][0];
01365 int scale;
01366
01367 if(i<4) scale= s->y_dc_scale;
01368 else scale= s->c_dc_scale;
01369
01370 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
01371 level -= pred_dc;
01372
01373 if (level >= 0)
01374 level = (level + (scale>>1))/scale;
01375 else
01376 level = (level - (scale>>1))/scale;
01377
01378
01379 if (level == 0 && s->block_last_index[i] == 0)
01380 s->block_last_index[i] = -1;
01381
01382 if(!s->modified_quant){
01383 if (level < -127)
01384 level = -127;
01385 else if (level > 127)
01386 level = 127;
01387 }
01388
01389 block[i][0] = level;
01390
01391 rec_intradc[i] = scale*level + pred_dc;
01392
01393 rec_intradc[i] |= 1;
01394
01395
01396
01397 if (rec_intradc[i] < 0)
01398 rec_intradc[i] = 0;
01399 else if (rec_intradc[i] > 2047)
01400 rec_intradc[i] = 2047;
01401
01402
01403 *dc_ptr[i] = rec_intradc[i];
01404 if (s->block_last_index[i] >= 0)
01405 cbp |= 1 << (5 - i);
01406 }
01407 }else{
01408 for(i=0; i<6; i++) {
01409
01410 if (s->block_last_index[i] >= 1)
01411 cbp |= 1 << (5 - i);
01412 }
01413 }
01414
01415 cbpc = cbp & 3;
01416 if (s->pict_type == I_TYPE) {
01417 if(s->dquant) cbpc+=4;
01418 put_bits(&s->pb,
01419 intra_MCBPC_bits[cbpc],
01420 intra_MCBPC_code[cbpc]);
01421 } else {
01422 if(s->dquant) cbpc+=8;
01423 put_bits(&s->pb, 1, 0);
01424 put_bits(&s->pb,
01425 inter_MCBPC_bits[cbpc + 4],
01426 inter_MCBPC_code[cbpc + 4]);
01427 }
01428 if (s->h263_aic) {
01429
01430 put_bits(&s->pb, 1, 0);
01431 }
01432 cbpy = cbp >> 2;
01433 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
01434 if(s->dquant)
01435 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
01436
01437 if(interleaved_stats){
01438 s->misc_bits+= get_bits_diff(s);
01439 }
01440 }
01441
01442 for(i=0; i<6; i++) {
01443
01444 h263_encode_block(s, block[i], i);
01445
01446
01447 if (s->h263_aic && s->mb_intra) {
01448 block[i][0] = rec_intradc[i];
01449
01450 }
01451 }
01452
01453 if(interleaved_stats){
01454 if (!s->mb_intra) {
01455 s->p_tex_bits+= get_bits_diff(s);
01456 s->f_count++;
01457 }else{
01458 s->i_tex_bits+= get_bits_diff(s);
01459 s->i_count++;
01460 }
01461 }
01462 }
01463 #endif
01464
01465 void ff_h263_loop_filter(MpegEncContext * s){
01466 int qp_c;
01467 const int linesize = s->linesize;
01468 const int uvlinesize= s->uvlinesize;
01469 const int xy = s->mb_y * s->mb_stride + s->mb_x;
01470 uint8_t *dest_y = s->dest[0];
01471 uint8_t *dest_cb= s->dest[1];
01472 uint8_t *dest_cr= s->dest[2];
01473
01474
01475
01476
01477
01478
01479
01480 if(!IS_SKIP(s->current_picture.mb_type[xy])){
01481 qp_c= s->qscale;
01482 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c);
01483 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
01484 }else
01485 qp_c= 0;
01486
01487 if(s->mb_y){
01488 int qp_dt, qp_t, qp_tc;
01489
01490 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride]))
01491 qp_t=0;
01492 else
01493 qp_t= s->current_picture.qscale_table[xy-s->mb_stride];
01494
01495 if(qp_c)
01496 qp_tc= qp_c;
01497 else
01498 qp_tc= qp_t;
01499
01500 if(qp_tc){
01501 const int chroma_qp= s->chroma_qscale_table[qp_tc];
01502 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc);
01503 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc);
01504
01505 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp);
01506 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp);
01507 }
01508
01509 if(qp_t)
01510 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_t);
01511
01512 if(s->mb_x){
01513 if(qp_t || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride]))
01514 qp_dt= qp_t;
01515 else
01516 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride];
01517
01518 if(qp_dt){
01519 const int chroma_qp= s->chroma_qscale_table[qp_dt];
01520 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt);
01521 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp);
01522 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp);
01523 }
01524 }
01525 }
01526
01527 if(qp_c){
01528 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c);
01529 if(s->mb_y + 1 == s->mb_height)
01530 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c);
01531 }
01532
01533 if(s->mb_x){
01534 int qp_lc;
01535 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1]))
01536 qp_lc= qp_c;
01537 else
01538 qp_lc= s->current_picture.qscale_table[xy-1];
01539
01540 if(qp_lc){
01541 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc);
01542 if(s->mb_y + 1 == s->mb_height){
01543 const int chroma_qp= s->chroma_qscale_table[qp_lc];
01544 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc);
01545 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp);
01546 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp);
01547 }
01548 }
01549 }
01550 }
01551
01552 #ifdef CONFIG_ENCODERS
01553 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
01554 {
01555 int x, y, wrap, a, c, pred_dc, scale;
01556 int16_t *dc_val;
01557
01558
01559 if (n < 4) {
01560 x = 2 * s->mb_x + (n & 1);
01561 y = 2 * s->mb_y + ((n & 2) >> 1);
01562 wrap = s->b8_stride;
01563 dc_val = s->dc_val[0];
01564 scale = s->y_dc_scale;
01565 } else {
01566 x = s->mb_x;
01567 y = s->mb_y;
01568 wrap = s->mb_stride;
01569 dc_val = s->dc_val[n - 4 + 1];
01570 scale = s->c_dc_scale;
01571 }
01572
01573
01574
01575 a = dc_val[(x - 1) + (y) * wrap];
01576 c = dc_val[(x) + (y - 1) * wrap];
01577
01578
01579 if(s->first_slice_line && n!=3){
01580 if(n!=2) c= 1024;
01581 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
01582 }
01583 pred_dc = 1024;
01584
01585 if (a != 1024 && c != 1024)
01586 pred_dc = (a + c) >> 1;
01587 else if (a != 1024)
01588 pred_dc = a;
01589 else
01590 pred_dc = c;
01591
01592
01593
01594 *dc_val_ptr = &dc_val[x + y * wrap];
01595 return pred_dc;
01596 }
01597 #endif
01598
01599 static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n)
01600 {
01601 int x, y, wrap, a, c, pred_dc, scale, i;
01602 int16_t *dc_val, *ac_val, *ac_val1;
01603
01604
01605 if (n < 4) {
01606 x = 2 * s->mb_x + (n & 1);
01607 y = 2 * s->mb_y + (n>> 1);
01608 wrap = s->b8_stride;
01609 dc_val = s->dc_val[0];
01610 ac_val = s->ac_val[0][0];
01611 scale = s->y_dc_scale;
01612 } else {
01613 x = s->mb_x;
01614 y = s->mb_y;
01615 wrap = s->mb_stride;
01616 dc_val = s->dc_val[n - 4 + 1];
01617 ac_val = s->ac_val[n - 4 + 1][0];
01618 scale = s->c_dc_scale;
01619 }
01620
01621 ac_val += ((y) * wrap + (x)) * 16;
01622 ac_val1 = ac_val;
01623
01624
01625
01626
01627 a = dc_val[(x - 1) + (y) * wrap];
01628 c = dc_val[(x) + (y - 1) * wrap];
01629
01630
01631 if(s->first_slice_line && n!=3){
01632 if(n!=2) c= 1024;
01633 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024;
01634 }
01635
01636 if (s->ac_pred) {
01637 pred_dc = 1024;
01638 if (s->h263_aic_dir) {
01639
01640 if (a != 1024) {
01641 ac_val -= 16;
01642 for(i=1;i<8;i++) {
01643 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
01644 }
01645 pred_dc = a;
01646 }
01647 } else {
01648
01649 if (c != 1024) {
01650 ac_val -= 16 * wrap;
01651 for(i=1;i<8;i++) {
01652 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];
01653 }
01654 pred_dc = c;
01655 }
01656 }
01657 } else {
01658
01659 if (a != 1024 && c != 1024)
01660 pred_dc = (a + c) >> 1;
01661 else if (a != 1024)
01662 pred_dc = a;
01663 else
01664 pred_dc = c;
01665 }
01666
01667
01668 block[0]=block[0]*scale + pred_dc;
01669
01670 if (block[0] < 0)
01671 block[0] = 0;
01672 else
01673 block[0] |= 1;
01674
01675
01676 dc_val[(x) + (y) * wrap] = block[0];
01677
01678
01679 for(i=1;i<8;i++)
01680 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
01681
01682 for(i=1;i<8;i++)
01683 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
01684 }
01685
01686 int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir,
01687 int *px, int *py)
01688 {
01689 int wrap;
01690 int16_t *A, *B, *C, (*mot_val)[2];
01691 static const int off[4]= {2, 1, 1, -1};
01692
01693 wrap = s->b8_stride;
01694 mot_val = s->current_picture.motion_val[dir] + s->block_index[block];
01695
01696 A = mot_val[ - 1];
01697
01698 if (s->first_slice_line && block<3) {
01699
01700
01701 if(block==0){
01702 if(s->mb_x == s->resync_mb_x){
01703 *px= *py = 0;
01704 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){
01705 C = mot_val[off[block] - wrap];
01706 if(s->mb_x==0){
01707 *px = C[0];
01708 *py = C[1];
01709 }else{
01710 *px = mid_pred(A[0], 0, C[0]);
01711 *py = mid_pred(A[1], 0, C[1]);
01712 }
01713 }else{
01714 *px = A[0];
01715 *py = A[1];
01716 }
01717 }else if(block==1){
01718 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){
01719 C = mot_val[off[block] - wrap];
01720 *px = mid_pred(A[0], 0, C[0]);
01721 *py = mid_pred(A[1], 0, C[1]);
01722 }else{
01723 *px = A[0];
01724 *py = A[1];
01725 }
01726 }else{
01727 B = mot_val[ - wrap];
01728 C = mot_val[off[block] - wrap];
01729 if(s->mb_x == s->resync_mb_x)
01730 A[0]=A[1]=0;
01731
01732 *px = mid_pred(A[0], B[0], C[0]);
01733 *py = mid_pred(A[1], B[1], C[1]);
01734 }
01735 } else {
01736 B = mot_val[ - wrap];
01737 C = mot_val[off[block] - wrap];
01738 *px = mid_pred(A[0], B[0], C[0]);
01739 *py = mid_pred(A[1], B[1], C[1]);
01740 }
01741 return *mot_val;
01742 }
01743
01744 #ifdef CONFIG_ENCODERS
01745 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
01746 {
01747 int range, l, bit_size, sign, code, bits;
01748
01749 if (val == 0) {
01750
01751 code = 0;
01752 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
01753 } else {
01754 bit_size = f_code - 1;
01755 range = 1 << bit_size;
01756
01757 l= INT_BIT - 6 - bit_size;
01758 val = (val<<l)>>l;
01759 sign = val>>31;
01760 val= (val^sign)-sign;
01761 sign&=1;
01762
01763 val--;
01764 code = (val >> bit_size) + 1;
01765 bits = val & (range - 1);
01766
01767 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
01768 if (bit_size > 0) {
01769 put_bits(&s->pb, bit_size, bits);
01770 }
01771 }
01772 }
01773
01774
01775 static void h263p_encode_umotion(MpegEncContext * s, int val)
01776 {
01777 short sval = 0;
01778 short i = 0;
01779 short n_bits = 0;
01780 short temp_val;
01781 int code = 0;
01782 int tcode;
01783
01784 if ( val == 0)
01785 put_bits(&s->pb, 1, 1);
01786 else if (val == 1)
01787 put_bits(&s->pb, 3, 0);
01788 else if (val == -1)
01789 put_bits(&s->pb, 3, 2);
01790 else {
01791
01792 sval = ((val < 0) ? (short)(-val):(short)val);
01793 temp_val = sval;
01794
01795 while (temp_val != 0) {
01796 temp_val = temp_val >> 1;
01797 n_bits++;
01798 }
01799
01800 i = n_bits - 1;
01801 while (i > 0) {
01802 tcode = (sval & (1 << (i-1))) >> (i-1);
01803 tcode = (tcode << 1) | 1;
01804 code = (code << 2) | tcode;
01805 i--;
01806 }
01807 code = ((code << 1) | (val < 0)) << 1;
01808 put_bits(&s->pb, (2*n_bits)+1, code);
01809
01810 }
01811 }
01812
01813 static void init_mv_penalty_and_fcode(MpegEncContext *s)
01814 {
01815 int f_code;
01816 int mv;
01817
01818 for(f_code=1; f_code<=MAX_FCODE; f_code++){
01819 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
01820 int len;
01821
01822 if(mv==0) len= mvtab[0][1];
01823 else{
01824 int val, bit_size, range, code;
01825
01826 bit_size = f_code - 1;
01827 range = 1 << bit_size;
01828
01829 val=mv;
01830 if (val < 0)
01831 val = -val;
01832 val--;
01833 code = (val >> bit_size) + 1;
01834 if(code<33){
01835 len= mvtab[code][1] + 1 + bit_size;
01836 }else{
01837 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
01838 }
01839 }
01840
01841 mv_penalty[f_code][mv+MAX_MV]= len;
01842 }
01843 }
01844
01845 for(f_code=MAX_FCODE; f_code>0; f_code--){
01846 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
01847 fcode_tab[mv+MAX_MV]= f_code;
01848 }
01849 }
01850
01851 for(mv=0; mv<MAX_MV*2+1; mv++){
01852 umv_fcode_tab[mv]= 1;
01853 }
01854 }
01855
01856 static void init_uni_dc_tab(void)
01857 {
01858 int level, uni_code, uni_len;
01859
01860 for(level=-256; level<256; level++){
01861 int size, v, l;
01862
01863 size = 0;
01864 v = abs(level);
01865 while (v) {
01866 v >>= 1;
01867 size++;
01868 }
01869
01870 if (level < 0)
01871 l= (-level) ^ ((1 << size) - 1);
01872 else
01873 l= level;
01874
01875
01876 uni_code= DCtab_lum[size][0];
01877 uni_len = DCtab_lum[size][1];
01878
01879 if (size > 0) {
01880 uni_code<<=size; uni_code|=l;
01881 uni_len+=size;
01882 if (size > 8){
01883 uni_code<<=1; uni_code|=1;
01884 uni_len++;
01885 }
01886 }
01887 uni_DCtab_lum_bits[level+256]= uni_code;
01888 uni_DCtab_lum_len [level+256]= uni_len;
01889
01890
01891 uni_code= DCtab_chrom[size][0];
01892 uni_len = DCtab_chrom[size][1];
01893
01894 if (size > 0) {
01895 uni_code<<=size; uni_code|=l;
01896 uni_len+=size;
01897 if (size > 8){
01898 uni_code<<=1; uni_code|=1;
01899 uni_len++;
01900 }
01901 }
01902 uni_DCtab_chrom_bits[level+256]= uni_code;
01903 uni_DCtab_chrom_len [level+256]= uni_len;
01904
01905 }
01906 }
01907
01908 static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
01909 int slevel, run, last;
01910
01911 assert(MAX_LEVEL >= 64);
01912 assert(MAX_RUN >= 63);
01913
01914 for(slevel=-64; slevel<64; slevel++){
01915 if(slevel==0) continue;
01916 for(run=0; run<64; run++){
01917 for(last=0; last<=1; last++){
01918 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
01919 int level= slevel < 0 ? -slevel : slevel;
01920 int sign= slevel < 0 ? 1 : 0;
01921 int bits, len, code;
01922 int level1, run1;
01923
01924 len_tab[index]= 100;
01925
01926
01927 code= get_rl_index(rl, last, run, level);
01928 bits= rl->table_vlc[code][0];
01929 len= rl->table_vlc[code][1];
01930 bits=bits*2+sign; len++;
01931
01932 if(code!=rl->n && len < len_tab[index]){
01933 bits_tab[index]= bits;
01934 len_tab [index]= len;
01935 }
01936 #if 1
01937
01938 bits= rl->table_vlc[rl->n][0];
01939 len= rl->table_vlc[rl->n][1];
01940 bits=bits*2; len++;
01941 level1= level - rl->max_level[last][run];
01942 if(level1>0){
01943 code= get_rl_index(rl, last, run, level1);
01944 bits<<= rl->table_vlc[code][1];
01945 len += rl->table_vlc[code][1];
01946 bits += rl->table_vlc[code][0];
01947 bits=bits*2+sign; len++;
01948
01949 if(code!=rl->n && len < len_tab[index]){
01950 bits_tab[index]= bits;
01951 len_tab [index]= len;
01952 }
01953 }
01954 #endif
01955 #if 1
01956
01957 bits= rl->table_vlc[rl->n][0];
01958 len= rl->table_vlc[rl->n][1];
01959 bits=bits*4+2; len+=2;
01960 run1 = run - rl->max_run[last][level] - 1;
01961 if(run1>=0){
01962 code= get_rl_index(rl, last, run1, level);
01963 bits<<= rl->table_vlc[code][1];
01964 len += rl->table_vlc[code][1];
01965 bits += rl->table_vlc[code][0];
01966 bits=bits*2+sign; len++;
01967
01968 if(code!=rl->n && len < len_tab[index]){
01969 bits_tab[index]= bits;
01970 len_tab [index]= len;
01971 }
01972 }
01973 #endif
01974
01975 bits= rl->table_vlc[rl->n][0];
01976 len = rl->table_vlc[rl->n][1];
01977 bits=bits*4+3; len+=2;
01978 bits=bits*2+last; len++;
01979 bits=bits*64+run; len+=6;
01980 bits=bits*2+1; len++;
01981 bits=bits*4096+(slevel&0xfff); len+=12;
01982 bits=bits*2+1; len++;
01983
01984 if(len < len_tab[index]){
01985 bits_tab[index]= bits;
01986 len_tab [index]= len;
01987 }
01988 }
01989 }
01990 }
01991 }
01992
01993 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
01994 int slevel, run, last;
01995
01996 assert(MAX_LEVEL >= 64);
01997 assert(MAX_RUN >= 63);
01998
01999 for(slevel=-64; slevel<64; slevel++){
02000 if(slevel==0) continue;
02001 for(run=0; run<64; run++){
02002 for(last=0; last<=1; last++){
02003 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
02004 int level= slevel < 0 ? -slevel : slevel;
02005 int sign= slevel < 0 ? 1 : 0;
02006 int bits, len, code;
02007
02008 len_tab[index]= 100;
02009
02010
02011 code= get_rl_index(rl, last, run, level);
02012 bits= rl->table_vlc[code][0];
02013 len= rl->table_vlc[code][1];
02014 bits=bits*2+sign; len++;
02015
02016 if(code!=rl->n && len < len_tab[index]){
02017 if(bits_tab) bits_tab[index]= bits;
02018 len_tab [index]= len;
02019 }
02020
02021 bits= rl->table_vlc[rl->n][0];
02022 len = rl->table_vlc[rl->n][1];
02023 bits=bits*2+last; len++;
02024 bits=bits*64+run; len+=6;
02025 bits=bits*256+(level&0xff); len+=8;
02026
02027 if(len < len_tab[index]){
02028 if(bits_tab) bits_tab[index]= bits;
02029 len_tab [index]= len;
02030 }
02031 }
02032 }
02033 }
02034 }
02035
02036 void h263_encode_init(MpegEncContext *s)
02037 {
02038 static int done = 0;
02039
02040 if (!done) {
02041 done = 1;
02042
02043 init_uni_dc_tab();
02044
02045 init_rl(&rl_inter, static_rl_table_store[0]);
02046 init_rl(&rl_intra, static_rl_table_store[1]);
02047 init_rl(&rl_intra_aic, static_rl_table_store[2]);
02048
02049 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len);
02050 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len);
02051
02052 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len);
02053 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len);
02054
02055 init_mv_penalty_and_fcode(s);
02056 }
02057 s->me.mv_penalty= mv_penalty;
02058
02059 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
02060 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
02061 if(s->h263_aic){
02062 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
02063 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
02064 }
02065 s->ac_esc_length= 7+1+6+8;
02066
02067
02068 switch(s->codec_id){
02069 case CODEC_ID_MPEG4:
02070 s->fcode_tab= fcode_tab;
02071 s->min_qcoeff= -2048;
02072 s->max_qcoeff= 2047;
02073 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len;
02074 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64;
02075 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len;
02076 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64;
02077 s->luma_dc_vlc_length= uni_DCtab_lum_len;
02078 s->chroma_dc_vlc_length= uni_DCtab_chrom_len;
02079 s->ac_esc_length= 7+2+1+6+1+12+1;
02080 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
02081 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
02082
02083 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){
02084
02085 s->avctx->extradata= av_malloc(1024);
02086 init_put_bits(&s->pb, s->avctx->extradata, 1024);
02087
02088 if(!(s->workaround_bugs & FF_BUG_MS))
02089 mpeg4_encode_visual_object_header(s);
02090 mpeg4_encode_vol_header(s, 0, 0);
02091
02092
02093 flush_put_bits(&s->pb);
02094 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3;
02095 }
02096
02097 break;
02098 case CODEC_ID_H263P:
02099 if(s->umvplus)
02100 s->fcode_tab= umv_fcode_tab;
02101 if(s->modified_quant){
02102 s->min_qcoeff= -2047;
02103 s->max_qcoeff= 2047;
02104 }else{
02105 s->min_qcoeff= -127;
02106 s->max_qcoeff= 127;
02107 }
02108 break;
02109
02110 case CODEC_ID_FLV1:
02111 if (s->h263_flv > 1) {
02112 s->min_qcoeff= -1023;
02113 s->max_qcoeff= 1023;
02114 } else {
02115 s->min_qcoeff= -127;
02116 s->max_qcoeff= 127;
02117 }
02118 s->y_dc_scale_table=
02119 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
02120 break;
02121 default:
02122 s->min_qcoeff= -127;
02123 s->max_qcoeff= 127;
02124 s->y_dc_scale_table=
02125 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
02126 }
02127 }
02128
02134 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
02135 {
02136 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
02137 RLTable *rl;
02138
02139 rl = &rl_inter;
02140 if (s->mb_intra && !s->h263_aic) {
02141
02142 level = block[0];
02143
02144 if (level > 254) {
02145 level = 254;
02146 block[0] = 254;
02147 }
02148
02149 else if (level < 1) {
02150 level = 1;
02151 block[0] = 1;
02152 }
02153 if (level == 128)
02154 put_bits(&s->pb, 8, 0xff);
02155 else
02156 put_bits(&s->pb, 8, level);
02157 i = 1;
02158 } else {
02159 i = 0;
02160 if (s->h263_aic && s->mb_intra)
02161 rl = &rl_intra_aic;
02162
02163 if(s->alt_inter_vlc && !s->mb_intra){
02164 int aic_vlc_bits=0;
02165 int inter_vlc_bits=0;
02166 int wrong_pos=-1;
02167 int aic_code;
02168
02169 last_index = s->block_last_index[n];
02170 last_non_zero = i - 1;
02171 for (; i <= last_index; i++) {
02172 j = s->intra_scantable.permutated[i];
02173 level = block[j];
02174 if (level) {
02175 run = i - last_non_zero - 1;
02176 last = (i == last_index);
02177
02178 if(level<0) level= -level;
02179
02180 code = get_rl_index(rl, last, run, level);
02181 aic_code = get_rl_index(&rl_intra_aic, last, run, level);
02182 inter_vlc_bits += rl->table_vlc[code][1]+1;
02183 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1;
02184
02185 if (code == rl->n) {
02186 inter_vlc_bits += 1+6+8-1;
02187 }
02188 if (aic_code == rl_intra_aic.n) {
02189 aic_vlc_bits += 1+6+8-1;
02190 wrong_pos += run + 1;
02191 }else
02192 wrong_pos += wrong_run[aic_code];
02193 last_non_zero = i;
02194 }
02195 }
02196 i = 0;
02197 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
02198 rl = &rl_intra_aic;
02199 }
02200 }
02201
02202
02203 last_index = s->block_last_index[n];
02204 last_non_zero = i - 1;
02205 for (; i <= last_index; i++) {
02206 j = s->intra_scantable.permutated[i];
02207 level = block[j];
02208 if (level) {
02209 run = i - last_non_zero - 1;
02210 last = (i == last_index);
02211 sign = 0;
02212 slevel = level;
02213 if (level < 0) {
02214 sign = 1;
02215 level = -level;
02216 }
02217 code = get_rl_index(rl, last, run, level);
02218 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
02219 if (code == rl->n) {
02220 if(s->h263_flv <= 1){
02221 put_bits(&s->pb, 1, last);
02222 put_bits(&s->pb, 6, run);
02223
02224 assert(slevel != 0);
02225
02226 if(level < 128)
02227 put_bits(&s->pb, 8, slevel & 0xff);
02228 else{
02229 put_bits(&s->pb, 8, 128);
02230 put_bits(&s->pb, 5, slevel & 0x1f);
02231 put_bits(&s->pb, 6, (slevel>>5)&0x3f);
02232 }
02233 }else{
02234 if(level < 64) {
02235 put_bits(&s->pb, 1, 0);
02236 put_bits(&s->pb, 1, last);
02237 put_bits(&s->pb, 6, run);
02238
02239 put_bits(&s->pb, 7, slevel & 0x7f);
02240 } else {
02241
02242 put_bits(&s->pb, 1, 1);
02243 put_bits(&s->pb, 1, last);
02244 put_bits(&s->pb, 6, run);
02245
02246 put_bits(&s->pb, 11, slevel & 0x7ff);
02247 }
02248 }
02249 } else {
02250 put_bits(&s->pb, 1, sign);
02251 }
02252 last_non_zero = i;
02253 }
02254 }
02255 }
02256
02257
02261 void ff_mpeg4_stuffing(PutBitContext * pbc)
02262 {
02263 int length;
02264 put_bits(pbc, 1, 0);
02265 length= (-put_bits_count(pbc))&7;
02266 if(length) put_bits(pbc, length, (1<<length)-1);
02267 }
02268
02269
02270 void ff_set_mpeg4_time(MpegEncContext * s){
02271 if(s->pict_type==B_TYPE){
02272 ff_mpeg4_init_direct_mv(s);
02273 }else{
02274 s->last_time_base= s->time_base;
02275 s->time_base= s->time/s->avctx->time_base.den;
02276 }
02277 }
02278
02279 static void mpeg4_encode_gop_header(MpegEncContext * s){
02280 int hours, minutes, seconds;
02281 int64_t time;
02282
02283 put_bits(&s->pb, 16, 0);
02284 put_bits(&s->pb, 16, GOP_STARTCODE);
02285
02286 time= s->current_picture_ptr->pts;
02287 if(s->reordered_input_picture[1])
02288 time= FFMIN(time, s->reordered_input_picture[1]->pts);
02289 time= time*s->avctx->time_base.num;
02290
02291 seconds= time/s->avctx->time_base.den;
02292 minutes= seconds/60; seconds %= 60;
02293 hours= minutes/60; minutes %= 60;
02294 hours%=24;
02295
02296 put_bits(&s->pb, 5, hours);
02297 put_bits(&s->pb, 6, minutes);
02298 put_bits(&s->pb, 1, 1);
02299 put_bits(&s->pb, 6, seconds);
02300
02301 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP));
02302 put_bits(&s->pb, 1, 0);
02303
02304 s->last_time_base= time / s->avctx->time_base.den;
02305
02306 ff_mpeg4_stuffing(&s->pb);
02307 }
02308
02309 static void mpeg4_encode_visual_object_header(MpegEncContext * s){
02310 int profile_and_level_indication;
02311 int vo_ver_id;
02312
02313 if(s->avctx->profile != FF_PROFILE_UNKNOWN){
02314 profile_and_level_indication = s->avctx->profile << 4;
02315 }else if(s->max_b_frames || s->quarter_sample){
02316 profile_and_level_indication= 0xF0;
02317 }else{
02318 profile_and_level_indication= 0x00;
02319 }
02320
02321 if(s->avctx->level != FF_LEVEL_UNKNOWN){
02322 profile_and_level_indication |= s->avctx->level;
02323 }else{
02324 profile_and_level_indication |= 1;
02325 }
02326
02327 if(profile_and_level_indication>>4 == 0xF){
02328 vo_ver_id= 5;
02329 }else{
02330 vo_ver_id= 1;
02331 }
02332
02333
02334
02335 put_bits(&s->pb, 16, 0);
02336 put_bits(&s->pb, 16, VOS_STARTCODE);
02337
02338 put_bits(&s->pb, 8, profile_and_level_indication);
02339
02340 put_bits(&s->pb, 16, 0);
02341 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
02342
02343 put_bits(&s->pb, 1, 1);
02344 put_bits(&s->pb, 4, vo_ver_id);
02345 put_bits(&s->pb, 3, 1);
02346
02347 put_bits(&s->pb, 4, 1);
02348
02349 put_bits(&s->pb, 1, 0);
02350
02351 ff_mpeg4_stuffing(&s->pb);
02352 }
02353
02354 static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number)
02355 {
02356 int vo_ver_id;
02357
02358 if (!ENABLE_MPEG4_ENCODER) return;
02359
02360 if(s->max_b_frames || s->quarter_sample){
02361 vo_ver_id= 5;
02362 s->vo_type= ADV_SIMPLE_VO_TYPE;
02363 }else{
02364 vo_ver_id= 1;
02365 s->vo_type= SIMPLE_VO_TYPE;
02366 }
02367
02368 put_bits(&s->pb, 16, 0);
02369 put_bits(&s->pb, 16, 0x100 + vo_number);
02370 put_bits(&s->pb, 16, 0);
02371 put_bits(&s->pb, 16, 0x120 + vol_number);
02372
02373 put_bits(&s->pb, 1, 0);
02374 put_bits(&s->pb, 8, s->vo_type);
02375 if(s->workaround_bugs & FF_BUG_MS) {
02376 put_bits(&s->pb, 1, 0);
02377 } else {
02378 put_bits(&s->pb, 1, 1);
02379 put_bits(&s->pb, 4, vo_ver_id);
02380 put_bits(&s->pb, 3, 1);
02381 }
02382
02383 aspect_to_info(s, s->avctx->sample_aspect_ratio);
02384
02385 put_bits(&s->pb, 4, s->aspect_ratio_info);
02386 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){
02387 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
02388 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
02389 }
02390
02391 if(s->workaround_bugs & FF_BUG_MS) {
02392 put_bits(&s->pb, 1, 0);
02393 } else {
02394 put_bits(&s->pb, 1, 1);
02395 put_bits(&s->pb, 2, 1);
02396 put_bits(&s->pb, 1, s->low_delay);
02397 put_bits(&s->pb, 1, 0);
02398 }
02399
02400 put_bits(&s->pb, 2, RECT_SHAPE);
02401 put_bits(&s->pb, 1, 1);
02402
02403 put_bits(&s->pb, 16, s->avctx->time_base.den);
02404 if (s->time_increment_bits < 1)
02405 s->time_increment_bits = 1;
02406 put_bits(&s->pb, 1, 1);
02407 put_bits(&s->pb, 1, 0);
02408 put_bits(&s->pb, 1, 1);
02409 put_bits(&s->pb, 13, s->width);
02410 put_bits(&s->pb, 1, 1);
02411 put_bits(&s->pb, 13, s->height);
02412 put_bits(&s->pb, 1, 1);
02413 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
02414 put_bits(&s->pb, 1, 1);
02415 if (vo_ver_id == 1) {
02416 put_bits(&s->pb, 1, s->vol_sprite_usage);
02417 }else{
02418 put_bits(&s->pb, 2, s->vol_sprite_usage);
02419 }
02420
02421 put_bits(&s->pb, 1, 0);
02422 put_bits(&s->pb, 1, s->mpeg_quant);
02423
02424 if(s->mpeg_quant){
02425 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
02426 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
02427 }
02428
02429 if (vo_ver_id != 1)
02430 put_bits(&s->pb, 1, s->quarter_sample);
02431 put_bits(&s->pb, 1, 1);
02432 s->resync_marker= s->rtp_mode;
02433 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);
02434 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
02435 if(s->data_partitioning){
02436 put_bits(&s->pb, 1, 0);
02437 }
02438
02439 if (vo_ver_id != 1){
02440 put_bits(&s->pb, 1, 0);
02441 put_bits(&s->pb, 1, 0);
02442 }
02443 put_bits(&s->pb, 1, 0);
02444
02445 ff_mpeg4_stuffing(&s->pb);
02446
02447
02448 if(!(s->flags & CODEC_FLAG_BITEXACT)){
02449 put_bits(&s->pb, 16, 0);
02450 put_bits(&s->pb, 16, 0x1B2);
02451 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0);
02452 }
02453 }
02454
02455
02456 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
02457 {
02458 int time_incr;
02459 int time_div, time_mod;
02460
02461 if(s->pict_type==I_TYPE){
02462 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){
02463 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT)
02464 mpeg4_encode_visual_object_header(s);
02465 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0)
02466 mpeg4_encode_vol_header(s, 0, 0);
02467 }
02468 if(!(s->workaround_bugs & FF_BUG_MS))
02469 mpeg4_encode_gop_header(s);
02470 }
02471
02472 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
02473
02474
02475
02476 put_bits(&s->pb, 16, 0);
02477 put_bits(&s->pb, 16, VOP_STARTCODE);
02478 put_bits(&s->pb, 2, s->pict_type - 1);
02479
02480 assert(s->time>=0);
02481 time_div= s->time/s->avctx->time_base.den;
02482 time_mod= s->time%s->avctx->time_base.den;
02483 time_incr= time_div - s->last_time_base;
02484 assert(time_incr >= 0);
02485 while(time_incr--)
02486 put_bits(&s->pb, 1, 1);
02487
02488 put_bits(&s->pb, 1, 0);
02489
02490 put_bits(&s->pb, 1, 1);
02491 put_bits(&s->pb, s->time_increment_bits, time_mod);
02492 put_bits(&s->pb, 1, 1);
02493 put_bits(&s->pb, 1, 1);
02494 if ( s->pict_type == P_TYPE
02495 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
02496 put_bits(&s->pb, 1, s->no_rounding);
02497 }
02498 put_bits(&s->pb, 3, 0);
02499 if(!s->progressive_sequence){
02500 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
02501 put_bits(&s->pb, 1, s->alternate_scan);
02502 }
02503
02504
02505 put_bits(&s->pb, 5, s->qscale);
02506
02507 if (s->pict_type != I_TYPE)
02508 put_bits(&s->pb, 3, s->f_code);
02509 if (s->pict_type == B_TYPE)
02510 put_bits(&s->pb, 3, s->b_code);
02511
02512 }
02513
02514 #endif //CONFIG_ENCODERS
02515
02523 static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding)
02524 {
02525 int a, b, c, wrap, pred, scale, ret;
02526 int16_t *dc_val;
02527
02528
02529 if (n < 4) {
02530 scale = s->y_dc_scale;
02531 } else {
02532 scale = s->c_dc_scale;
02533 }
02534 if(IS_3IV1)
02535 scale= 8;
02536
02537 wrap= s->block_wrap[n];
02538 dc_val = s->dc_val[0] + s->block_index[n];
02539
02540
02541
02542
02543 a = dc_val[ - 1];
02544 b = dc_val[ - 1 - wrap];
02545 c = dc_val[ - wrap];
02546
02547
02548 if(s->first_slice_line && n!=3){
02549 if(n!=2) b=c= 1024;
02550 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024;
02551 }
02552 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){
02553 if(n==0 || n==4 || n==5)
02554 b=1024;
02555 }
02556
02557 if (abs(a - b) < abs(b - c)) {
02558 pred = c;
02559 *dir_ptr = 1;
02560 } else {
02561 pred = a;
02562 *dir_ptr = 0;
02563 }
02564
02565 pred = FASTDIV((pred + (scale >> 1)), scale);
02566
02567 if(encoding){
02568 ret = level - pred;
02569 }else{
02570 level += pred;
02571 ret= level;
02572 if(s->error_resilience>=3){
02573 if(level<0){
02574 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
02575 return -1;
02576 }
02577 if(level*scale > 2048 + scale){
02578 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
02579 return -1;
02580 }
02581 }
02582 }
02583 level *=scale;
02584 if(level&(~2047)){
02585 if(level<0)
02586 level=0;
02587 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP))
02588 level=2047;
02589 }
02590 dc_val[0]= level;
02591
02592 return ret;
02593 }
02594
02600 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
02601 int dir)
02602 {
02603 int i;
02604 int16_t *ac_val, *ac_val1;
02605 int8_t * const qscale_table= s->current_picture.qscale_table;
02606
02607
02608 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
02609 ac_val1 = ac_val;
02610 if (s->ac_pred) {
02611 if (dir == 0) {
02612 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
02613
02614 ac_val -= 16;
02615
02616 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
02617
02618 for(i=1;i<8;i++) {
02619 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
02620 }
02621 }else{
02622
02623 for(i=1;i<8;i++) {
02624 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
02625 }
02626 }
02627 } else {
02628 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
02629
02630 ac_val -= 16 * s->block_wrap[n];
02631
02632 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
02633
02634 for(i=1;i<8;i++) {
02635 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
02636 }
02637 }else{
02638
02639 for(i=1;i<8;i++) {
02640 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
02641 }
02642 }
02643 }
02644 }
02645
02646 for(i=1;i<8;i++)
02647 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
02648
02649
02650 for(i=1;i<8;i++)
02651 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
02652
02653 }
02654
02655 #ifdef CONFIG_ENCODERS
02656
02661 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
02662 {
02663 #if 1
02664
02665 level+=256;
02666 if (n < 4) {
02667
02668 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
02669 } else {
02670
02671 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
02672 }
02673 #else
02674 int size, v;
02675
02676 size = 0;
02677 v = abs(level);
02678 while (v) {
02679 v >>= 1;
02680 size++;
02681 }
02682
02683 if (n < 4) {
02684
02685 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
02686 } else {
02687
02688 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
02689 }
02690
02691
02692 if (size > 0) {
02693 if (level < 0)
02694 level = (-level) ^ ((1 << size) - 1);
02695 put_bits(&s->pb, size, level);
02696 if (size > 8)
02697 put_bits(&s->pb, 1, 1);
02698 }
02699 #endif
02700 }
02701
02702 static inline int mpeg4_get_dc_length(int level, int n){
02703 if (n < 4) {
02704 return uni_DCtab_lum_len[level + 256];
02705 } else {
02706 return uni_DCtab_chrom_len[level + 256];
02707 }
02708 }
02709
02714 static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
02715 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
02716 {
02717 int i, last_non_zero;
02718 #if 0 //variables for the outcommented version
02719 int code, sign, last;
02720 #endif
02721 const RLTable *rl;
02722 uint32_t *bits_tab;
02723 uint8_t *len_tab;
02724 const int last_index = s->block_last_index[n];
02725
02726 if (s->mb_intra) {
02727
02728 mpeg4_encode_dc(dc_pb, intra_dc, n);
02729 if(last_index<1) return;
02730 i = 1;
02731 rl = &rl_intra;
02732 bits_tab= uni_mpeg4_intra_rl_bits;
02733 len_tab = uni_mpeg4_intra_rl_len;
02734 } else {
02735 if(last_index<0) return;
02736 i = 0;
02737 rl = &rl_inter;
02738 bits_tab= uni_mpeg4_inter_rl_bits;
02739 len_tab = uni_mpeg4_inter_rl_len;
02740 }
02741
02742
02743 last_non_zero = i - 1;
02744 #if 1
02745 for (; i < last_index; i++) {
02746 int level = block[ scan_table[i] ];
02747 if (level) {
02748 int run = i - last_non_zero - 1;
02749 level+=64;
02750 if((level&(~127)) == 0){
02751 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
02752 put_bits(ac_pb, len_tab[index], bits_tab[index]);
02753 }else{
02754 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);
02755 }
02756 last_non_zero = i;
02757 }
02758 }
02759 {
02760 int level = block[ scan_table[i] ];
02761 int run = i - last_non_zero - 1;
02762 level+=64;
02763 if((level&(~127)) == 0){
02764 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
02765 put_bits(ac_pb, len_tab[index], bits_tab[index]);
02766 }else{
02767 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);
02768 }
02769 }
02770 #else
02771 for (; i <= last_index; i++) {
02772 const int slevel = block[ scan_table[i] ];
02773 if (slevel) {
02774 int level;
02775 int run = i - last_non_zero - 1;
02776 last = (i == last_index);
02777 sign = 0;
02778 level = slevel;
02779 if (level < 0) {
02780 sign = 1;
02781 level = -level;
02782 }
02783 code = get_rl_index(rl, last, run, level);
02784 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
02785 if (code == rl->n) {
02786 int level1, run1;
02787 level1 = level - rl->max_level[last][run];
02788 if (level1 < 1)
02789 goto esc2;
02790 code = get_rl_index(rl, last, run, level1);
02791 if (code == rl->n) {
02792 esc2:
02793 put_bits(ac_pb, 1, 1);
02794 if (level > MAX_LEVEL)
02795 goto esc3;
02796 run1 = run - rl->max_run[last][level] - 1;
02797 if (run1 < 0)
02798 goto esc3;
02799 code = get_rl_index(rl, last, run1, level);
02800 if (code == rl->n) {
02801 esc3:
02802
02803 put_bits(ac_pb, 1, 1);
02804 put_bits(ac_pb, 1, last);
02805 put_bits(ac_pb, 6, run);
02806 put_bits(ac_pb, 1, 1);
02807 put_bits(ac_pb, 12, slevel & 0xfff);
02808 put_bits(ac_pb, 1, 1);
02809 } else {
02810
02811 put_bits(ac_pb, 1, 0);
02812 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
02813 put_bits(ac_pb, 1, sign);
02814 }
02815 } else {
02816
02817 put_bits(ac_pb, 1, 0);
02818 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
02819 put_bits(ac_pb, 1, sign);
02820 }
02821 } else {
02822 put_bits(ac_pb, 1, sign);
02823 }
02824 last_non_zero = i;
02825 }
02826 }
02827 #endif
02828 }
02829
02830 static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
02831 uint8_t *scan_table)
02832 {
02833 int i, last_non_zero;
02834 const RLTable *rl;
02835 uint8_t *len_tab;
02836 const int last_index = s->block_last_index[n];
02837 int len=0;
02838
02839 if (s->mb_intra) {
02840
02841 len += mpeg4_get_dc_length(intra_dc, n);
02842 if(last_index<1) return len;
02843 i = 1;
02844 rl = &rl_intra;
02845 len_tab = uni_mpeg4_intra_rl_len;
02846 } else {
02847 if(last_index<0) return 0;
02848 i = 0;
02849 rl = &rl_inter;
02850 len_tab = uni_mpeg4_inter_rl_len;
02851 }
02852
02853
02854 last_non_zero = i - 1;
02855 for (; i < last_index; i++) {
02856 int level = block[ scan_table[i] ];
02857 if (level) {
02858 int run = i - last_non_zero - 1;
02859 level+=64;
02860 if((level&(~127)) == 0){
02861 const int index= UNI_MPEG4_ENC_INDEX(0, run, level);
02862 len += len_tab[index];
02863 }else{
02864 len += 7+2+1+6+1+12+1;
02865 }
02866 last_non_zero = i;
02867 }
02868 }
02869 {
02870 int level = block[ scan_table[i] ];
02871 int run = i - last_non_zero - 1;
02872 level+=64;
02873 if((level&(~127)) == 0){
02874 const int index= UNI_MPEG4_ENC_INDEX(1, run, level);
02875 len += len_tab[index];
02876 }else{
02877 len += 7+2+1+6+1+12+1;
02878 }
02879 }
02880
02881 return len;
02882 }
02883
02884 #endif
02885
02886
02887
02888
02889
02890 static VLC intra_MCBPC_vlc;
02891 static VLC inter_MCBPC_vlc;
02892 static VLC cbpy_vlc;
02893 static VLC mv_vlc;
02894 static VLC dc_lum, dc_chrom;
02895 static VLC sprite_trajectory;
02896 static VLC mb_type_b_vlc;
02897 static VLC h263_mbtype_b_vlc;
02898 static VLC cbpc_b_vlc;
02899
02900
02901
02902
02903 void h263_decode_init_vlc(MpegEncContext *s)
02904 {
02905 static int done = 0;
02906
02907 if (!done) {
02908 done = 1;
02909
02910 init_vlc(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
02911 intra_MCBPC_bits, 1, 1,
02912 intra_MCBPC_code, 1, 1, 1);
02913 init_vlc(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,
02914 inter_MCBPC_bits, 1, 1,
02915 inter_MCBPC_code, 1, 1, 1);
02916 init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
02917 &cbpy_tab[0][1], 2, 1,
02918 &cbpy_tab[0][0], 2, 1, 1);
02919 init_vlc(&mv_vlc, MV_VLC_BITS, 33,
02920 &mvtab[0][1], 2, 1,
02921 &mvtab[0][0], 2, 1, 1);
02922 init_rl(&rl_inter, static_rl_table_store[0]);
02923 init_rl(&rl_intra, static_rl_table_store[1]);
02924 init_rl(&rvlc_rl_inter, static_rl_table_store[3]);
02925 init_rl(&rvlc_rl_intra, static_rl_table_store[4]);
02926 init_rl(&rl_intra_aic, static_rl_table_store[2]);
02927 init_vlc_rl(&rl_inter, 1);
02928 init_vlc_rl(&rl_intra, 1);
02929 init_vlc_rl(&rvlc_rl_inter, 1);
02930 init_vlc_rl(&rvlc_rl_intra, 1);
02931 init_vlc_rl(&rl_intra_aic, 1);
02932 init_vlc(&dc_lum, DC_VLC_BITS, 10 ,
02933 &DCtab_lum[0][1], 2, 1,
02934 &DCtab_lum[0][0], 2, 1, 1);
02935 init_vlc(&dc_chrom, DC_VLC_BITS, 10 ,
02936 &DCtab_chrom[0][1], 2, 1,
02937 &DCtab_chrom[0][0], 2, 1, 1);
02938 init_vlc(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
02939 &sprite_trajectory_tab[0][1], 4, 2,
02940 &sprite_trajectory_tab[0][0], 4, 2, 1);
02941 init_vlc(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
02942 &mb_type_b_tab[0][1], 2, 1,
02943 &mb_type_b_tab[0][0], 2, 1, 1);
02944 init_vlc(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,
02945 &h263_mbtype_b_tab[0][1], 2, 1,
02946 &h263_mbtype_b_tab[0][0], 2, 1, 1);
02947 init_vlc(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
02948 &cbpc_b_tab[0][1], 2, 1,
02949 &cbpc_b_tab[0][0], 2, 1, 1);
02950 }
02951 }
02952
02956 int ff_h263_get_gob_height(MpegEncContext *s){
02957 if (s->height <= 400)
02958 return 1;
02959 else if (s->height <= 800)
02960 return 2;
02961 else
02962 return 4;
02963 }
02964
02965 int ff_h263_decode_mba(MpegEncContext *s)
02966 {
02967 int i, mb_pos;
02968
02969 for(i=0; i<6; i++){
02970 if(s->mb_num-1 <= ff_mba_max[i]) break;
02971 }
02972 mb_pos= get_bits(&s->gb, ff_mba_length[i]);
02973 s->mb_x= mb_pos % s->mb_width;
02974 s->mb_y= mb_pos / s->mb_width;
02975
02976 return mb_pos;
02977 }
02978
02979 void ff_h263_encode_mba(MpegEncContext *s)
02980 {
02981 int i, mb_pos;
02982
02983 for(i=0; i<6; i++){
02984 if(s->mb_num-1 <= ff_mba_max[i]) break;
02985 }
02986 mb_pos= s->mb_x + s->mb_width*s->mb_y;
02987 put_bits(&s->pb, ff_mba_length[i], mb_pos);
02988 }
02989
02994 static int h263_decode_gob_header(MpegEncContext *s)
02995 {
02996 unsigned int val, gfid, gob_number;
02997 int left;
02998
02999
03000 val = show_bits(&s->gb, 16);
03001 if(val)
03002 return -1;
03003
03004
03005 skip_bits(&s->gb, 16);
03006 left= s->gb.size_in_bits - get_bits_count(&s->gb);
03007
03008 for(;left>13; left--){
03009 if(get_bits1(&s->gb)) break;
03010 }
03011 if(left<=13)
03012 return -1;
03013
03014 if(s->h263_slice_structured){
03015 if(get_bits1(&s->gb)==0)
03016 return -1;
03017
03018 ff_h263_decode_mba(s);
03019
03020 if(s->mb_num > 1583)
03021 if(get_bits1(&s->gb)==0)
03022 return -1;
03023
03024 s->qscale = get_bits(&s->gb, 5);
03025 if(get_bits1(&s->gb)==0)
03026 return -1;
03027 gfid = get_bits(&s->gb, 2);
03028 }else{
03029 gob_number = get_bits(&s->gb, 5);
03030 s->mb_x= 0;
03031 s->mb_y= s->gob_index* gob_number;
03032 gfid = get_bits(&s->gb, 2);
03033 s->qscale = get_bits(&s->gb, 5);
03034 }
03035
03036 if(s->mb_y >= s->mb_height)
03037 return -1;
03038
03039 if(s->qscale==0)
03040 return -1;
03041
03042 return 0;
03043 }
03044
03045 static inline void memsetw(short *tab, int val, int n)
03046 {
03047 int i;
03048 for(i=0;i<n;i++)
03049 tab[i] = val;
03050 }
03051
03052 #ifdef CONFIG_ENCODERS
03053
03054 void ff_mpeg4_init_partitions(MpegEncContext *s)
03055 {
03056 uint8_t *start= pbBufPtr(&s->pb);
03057 uint8_t *end= s->pb.buf_end;
03058 int size= end - start;
03059 int pb_size = (((long)start + size/3)&(~3)) - (long)start;
03060 int tex_size= (size - 2*pb_size)&(~3);
03061
03062 set_put_bits_buffer_size(&s->pb, pb_size);
03063 init_put_bits(&s->tex_pb, start + pb_size , tex_size);
03064 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size);
03065 }
03066
03067 void ff_mpeg4_merge_partitions(MpegEncContext *s)
03068 {
03069 const int pb2_len = put_bits_count(&s->pb2 );
03070 const int tex_pb_len= put_bits_count(&s->tex_pb);
03071 const int bits= put_bits_count(&s->pb);
03072
03073 if(s->pict_type==I_TYPE){
03074 put_bits(&s->pb, 19, DC_MARKER);
03075 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
03076 s->i_tex_bits+= tex_pb_len;
03077 }else{
03078 put_bits(&s->pb, 17, MOTION_MARKER);
03079 s->misc_bits+=17 + pb2_len;
03080 s->mv_bits+= bits - s->last_bits;
03081 s->p_tex_bits+= tex_pb_len;
03082 }
03083
03084 flush_put_bits(&s->pb2);
03085 flush_put_bits(&s->tex_pb);
03086
03087 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
03088 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len);
03089 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
03090 s->last_bits= put_bits_count(&s->pb);
03091 }
03092
03093 #endif //CONFIG_ENCODERS
03094
03095 int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){
03096 switch(s->pict_type){
03097 case I_TYPE:
03098 return 16;
03099 case P_TYPE:
03100 case S_TYPE:
03101 return s->f_code+15;
03102 case B_TYPE:
03103 return FFMAX(FFMAX(s->f_code, s->b_code)+15, 17);
03104 default:
03105 return -1;
03106 }
03107 }
03108
03109 #ifdef CONFIG_ENCODERS
03110
03111 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
03112 {
03113 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
03114
03115 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0);
03116 put_bits(&s->pb, 1, 1);
03117
03118 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
03119 put_bits(&s->pb, s->quant_precision, s->qscale);
03120 put_bits(&s->pb, 1, 0);
03121 }
03122
03123 #endif //CONFIG_ENCODERS
03124
03129 static inline int mpeg4_is_resync(MpegEncContext *s){
03130 int bits_count= get_bits_count(&s->gb);
03131 int v= show_bits(&s->gb, 16);
03132
03133 if(s->workaround_bugs&FF_BUG_NO_PADDING){
03134 return 0;
03135 }
03136
03137 while(v<=0xFF){
03138 if(s->pict_type==B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
03139 break;
03140 skip_bits(&s->gb, 8+s->pict_type);
03141 bits_count+= 8+s->pict_type;
03142 v= show_bits(&s->gb, 16);
03143 }
03144
03145 if(bits_count + 8 >= s->gb.size_in_bits){
03146 v>>=8;
03147 v|= 0x7F >> (7-(bits_count&7));
03148
03149 if(v==0x7F)
03150 return 1;
03151 }else{
03152 if(v == ff_mpeg4_resync_prefix[bits_count&7]){
03153 int len;
03154 GetBitContext gb= s->gb;
03155
03156 skip_bits(&s->gb, 1);
03157 align_get_bits(&s->gb);
03158
03159 for(len=0; len<32; len++){
03160 if(get_bits1(&s->gb)) break;
03161 }
03162
03163 s->gb= gb;
03164
03165 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
03166 return 1;
03167 }
03168 }
03169 return 0;
03170 }
03171
03176 static int mpeg4_decode_video_packet_header(MpegEncContext *s)
03177 {
03178 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
03179 int header_extension=0, mb_num, len;
03180
03181
03182 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
03183
03184 for(len=0; len<32; len++){
03185 if(get_bits1(&s->gb)) break;
03186 }
03187
03188 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
03189 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
03190 return -1;
03191 }
03192
03193 if(s->shape != RECT_SHAPE){
03194 header_extension= get_bits1(&s->gb);
03195
03196 }
03197
03198 mb_num= get_bits(&s->gb, mb_num_bits);
03199 if(mb_num>=s->mb_num){
03200 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
03201 return -1;
03202 }
03203 if(s->pict_type == B_TYPE){
03204 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++;
03205 if(mb_num >= s->mb_num) return -1;
03206 }
03207
03208 s->mb_x= mb_num % s->mb_width;
03209 s->mb_y= mb_num / s->mb_width;
03210
03211 if(s->shape != BIN_ONLY_SHAPE){
03212 int qscale= get_bits(&s->gb, s->quant_precision);
03213 if(qscale)
03214 s->chroma_qscale=s->qscale= qscale;
03215 }
03216
03217 if(s->shape == RECT_SHAPE){
03218 header_extension= get_bits1(&s->gb);
03219 }
03220 if(header_extension){
03221 int time_increment;
03222 int time_incr=0;
03223
03224 while (get_bits1(&s->gb) != 0)
03225 time_incr++;
03226
03227 check_marker(&s->gb, "before time_increment in video packed header");
03228 time_increment= get_bits(&s->gb, s->time_increment_bits);
03229 check_marker(&s->gb, "before vop_coding_type in video packed header");
03230
03231 skip_bits(&s->gb, 2);
03232
03233
03234 if(s->shape != BIN_ONLY_SHAPE){
03235 skip_bits(&s->gb, 3);
03236
03237 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
03238 mpeg4_decode_sprite_trajectory(s, &s->gb);
03239 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
03240 }
03241
03242
03243
03244 if (s->pict_type != I_TYPE) {
03245 int f_code = get_bits(&s->gb, 3);
03246 if(f_code==0){
03247 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
03248 }
03249 }
03250 if (s->pict_type == B_TYPE) {
03251 int b_code = get_bits(&s->gb, 3);
03252 if(b_code==0){
03253 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
03254 }
03255 }
03256 }
03257 }
03258
03259
03260
03261
03262 return 0;
03263 }
03264
03265 void ff_mpeg4_clean_buffers(MpegEncContext *s)
03266 {
03267 int c_wrap, c_xy, l_wrap, l_xy;
03268
03269 l_wrap= s->b8_stride;
03270 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1;
03271 c_wrap= s->mb_stride;
03272 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1;
03273
03274 #if 0
03275
03276 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
03277 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
03278 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
03279 #endif
03280
03281
03282 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t));
03283 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
03284 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t));
03285
03286
03287
03288
03289
03290 s->last_mv[0][0][0]=
03291 s->last_mv[0][0][1]=
03292 s->last_mv[1][0][0]=
03293 s->last_mv[1][0][1]= 0;
03294 }
03295
03300 int ff_h263_resync(MpegEncContext *s){
03301 int left, ret;
03302
03303 if(s->codec_id==CODEC_ID_MPEG4){
03304 skip_bits1(&s->gb);
03305 align_get_bits(&s->gb);
03306 }
03307
03308 if(show_bits(&s->gb, 16)==0){
03309 if(s->codec_id==CODEC_ID_MPEG4)
03310 ret= mpeg4_decode_video_packet_header(s);
03311 else
03312 ret= h263_decode_gob_header(s);
03313 if(ret>=0)
03314 return 0;
03315 }
03316
03317 s->gb= s->last_resync_gb;
03318 align_get_bits(&s->gb);
03319 left= s->gb.size_in_bits - get_bits_count(&s->gb);
03320
03321 for(;left>16+1+5+5; left-=8){
03322 if(show_bits(&s->gb, 16)==0){
03323 GetBitContext bak= s->gb;
03324
03325 if(s->codec_id==CODEC_ID_MPEG4)
03326 ret= mpeg4_decode_video_packet_header(s);
03327 else
03328 ret= h263_decode_gob_header(s);
03329 if(ret>=0)
03330 return 0;
03331
03332 s->gb= bak;
03333 }
03334 skip_bits(&s->gb, 8);
03335 }
03336
03337 return -1;
03338 }
03339
03345 static inline int get_amv(MpegEncContext *s, int n){
03346 int x, y, mb_v, sum, dx, dy, shift;
03347 int len = 1 << (s->f_code + 4);
03348 const int a= s->sprite_warping_accuracy;
03349
03350 if(s->workaround_bugs & FF_BUG_AMV)
03351 len >>= s->quarter_sample;
03352
03353 if(s->real_sprite_warping_points==1){
03354 if(s->divx_version==500 && s->divx_build==413)
03355 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
03356 else
03357 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
03358 }else{
03359 dx= s->sprite_delta[n][0];
03360 dy= s->sprite_delta[n][1];
03361 shift= s->sprite_shift[0];
03362 if(n) dy -= 1<<(shift + a + 1);
03363 else dx -= 1<<(shift + a + 1);
03364 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
03365
03366 sum=0;
03367 for(y=0; y<16; y++){
03368 int v;
03369
03370 v= mb_v + dy*y;
03371
03372 for(x=0; x<16; x++){
03373 sum+= v>>shift;
03374 v+= dx;
03375 }
03376 }
03377 sum= RSHIFT(sum, a+8-s->quarter_sample);
03378 }
03379
03380 if (sum < -len) sum= -len;
03381 else if (sum >= len) sum= len-1;
03382
03383 return sum;
03384 }
03385
03390 static int mpeg4_decode_partition_a(MpegEncContext *s){
03391 int mb_num;
03392 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
03393
03394
03395 mb_num=0;
03396 s->first_slice_line=1;
03397 for(; s->mb_y<s->mb_height; s->mb_y++){
03398 ff_init_block_index(s);
03399 for(; s->mb_x<s->mb_width; s->mb_x++){
03400 const int xy= s->mb_x + s->mb_y*s->mb_stride;
03401 int cbpc;
03402 int dir=0;
03403
03404 mb_num++;
03405 ff_update_block_index(s);
03406 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
03407 s->first_slice_line=0;
03408
03409 if(s->pict_type==I_TYPE){
03410 int i;
03411
03412 do{
03413 if(show_bits_long(&s->gb, 19)==DC_MARKER){
03414 return mb_num-1;
03415 }
03416
03417 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
03418 if (cbpc < 0){
03419 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
03420 return -1;
03421 }
03422 }while(cbpc == 8);
03423
03424 s->cbp_table[xy]= cbpc & 3;
03425 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
03426 s->mb_intra = 1;
03427
03428 if(cbpc & 4) {
03429 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
03430 }
03431 s->current_picture.qscale_table[xy]= s->qscale;
03432
03433 s->mbintra_table[xy]= 1;
03434 for(i=0; i<6; i++){
03435 int dc_pred_dir;
03436 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
03437 if(dc < 0){
03438 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
03439 return -1;
03440 }
03441 dir<<=1;
03442 if(dc_pred_dir) dir|=1;
03443 }
03444 s->pred_dir_table[xy]= dir;
03445 }else{
03446 int mx, my, pred_x, pred_y, bits;
03447 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]];
03448 const int stride= s->b8_stride*2;
03449
03450 try_again:
03451 bits= show_bits(&s->gb, 17);
03452 if(bits==MOTION_MARKER){
03453 return mb_num-1;
03454 }
03455 skip_bits1(&s->gb);
03456 if(bits&0x10000){
03457
03458 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
03459 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
03460 mx= get_amv(s, 0);
03461 my= get_amv(s, 1);
03462 }else{
03463 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
03464 mx=my=0;
03465 }
03466 mot_val[0 ]= mot_val[2 ]=
03467 mot_val[0+stride]= mot_val[2+stride]= mx;
03468 mot_val[1 ]= mot_val[3 ]=
03469 mot_val[1+stride]= mot_val[3+stride]= my;
03470
03471 if(s->mbintra_table[xy])
03472 ff_clean_intra_table_entries(s);
03473 continue;
03474 }
03475
03476 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
03477 if (cbpc < 0){
03478 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
03479 return -1;
03480 }
03481 if(cbpc == 20)
03482 goto try_again;
03483
03484 s->cbp_table[xy]= cbpc&(8+3);
03485
03486 s->mb_intra = ((cbpc & 4) != 0);
03487
03488 if(s->mb_intra){
03489 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
03490 s->mbintra_table[xy]= 1;
03491 mot_val[0 ]= mot_val[2 ]=
03492 mot_val[0+stride]= mot_val[2+stride]= 0;
03493 mot_val[1 ]= mot_val[3 ]=
03494 mot_val[1+stride]= mot_val[3+stride]= 0;
03495 }else{
03496 if(s->mbintra_table[xy])
03497 ff_clean_intra_table_entries(s);
03498
03499 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
03500 s->mcsel= get_bits1(&s->gb);
03501 else s->mcsel= 0;
03502
03503 if ((cbpc & 16) == 0) {
03504
03505
03506 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
03507 if(!s->mcsel){
03508 mx = h263_decode_motion(s, pred_x, s->f_code);
03509 if (mx >= 0xffff)
03510 return -1;
03511
03512 my = h263_decode_motion(s, pred_y, s->f_code);
03513 if (my >= 0xffff)
03514 return -1;
03515 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
03516 } else {
03517 mx = get_amv(s, 0);
03518 my = get_amv(s, 1);
03519 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
03520 }
03521
03522 mot_val[0 ]= mot_val[2 ] =
03523 mot_val[0+stride]= mot_val[2+stride]= mx;
03524 mot_val[1 ]= mot_val[3 ]=
03525 mot_val[1+stride]= mot_val[3+stride]= my;
03526 } else {
03527 int i;
03528 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
03529 for(i=0;i<4;i++) {
03530 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y);
03531 mx = h263_decode_motion(s, pred_x, s->f_code);
03532 if (mx >= 0xffff)
03533 return -1;
03534
03535 my = h263_decode_motion(s, pred_y, s->f_code);
03536 if (my >= 0xffff)
03537 return -1;
03538 mot_val[0] = mx;
03539 mot_val[1] = my;
03540 }
03541 }
03542 }
03543 }
03544 }
03545 s->mb_x= 0;
03546 }
03547
03548 return mb_num;
03549 }
03550
03555 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
03556 int mb_num=0;
03557 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
03558
03559 s->mb_x= s->resync_mb_x;
03560 s->first_slice_line=1;
03561 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
03562 ff_init_block_index(s);
03563 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
03564 const int xy= s->mb_x + s->mb_y*s->mb_stride;
03565
03566 mb_num++;
03567 ff_update_block_index(s);
03568 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
03569 s->first_slice_line=0;
03570
03571 if(s->pict_type==I_TYPE){
03572 int ac_pred= get_bits1(&s->gb);
03573 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
03574 if(cbpy<0){
03575 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
03576 return -1;
03577 }
03578
03579 s->cbp_table[xy]|= cbpy<<2;
03580 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
03581 }else{
03582 if(IS_INTRA(s->current_picture.mb_type[xy])){
03583 int dir=0,i;
03584 int ac_pred = get_bits1(&s->gb);
03585 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
03586
03587 if(cbpy<0){
03588 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
03589 return -1;
03590 }
03591
03592 if(s->cbp_table[xy] & 8) {
03593 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
03594 }
03595 s->current_picture.qscale_table[xy]= s->qscale;
03596
03597 for(i=0; i<6; i++){
03598 int dc_pred_dir;
03599 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
03600 if(dc < 0){
03601 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
03602 return -1;
03603 }
03604 dir<<=1;
03605 if(dc_pred_dir) dir|=1;
03606 }
03607 s->cbp_table[xy]&= 3;
03608 s->cbp_table[xy]|= cbpy<<2;
03609 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
03610 s->pred_dir_table[xy]= dir;
03611 }else if(IS_SKIP(s->current_picture.mb_type[xy])){
03612 s->current_picture.qscale_table[xy]= s->qscale;
03613 s->cbp_table[xy]= 0;
03614 }else{
03615 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
03616
03617 if(cbpy<0){
03618 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
03619 return -1;
03620 }
03621
03622 if(s->cbp_table[xy] & 8) {
03623 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
03624 }
03625 s->current_picture.qscale_table[xy]= s->qscale;
03626
03627 s->cbp_table[xy]&= 3;
03628 s->cbp_table[xy]|= (cbpy^0xf)<<2;
03629 }
03630 }
03631 }
03632 if(mb_num >= mb_count) return 0;
03633 s->mb_x= 0;
03634 }
03635 return 0;
03636 }
03637
03642 int ff_mpeg4_decode_partitions(MpegEncContext *s)
03643 {
03644 int mb_num;
03645 const int part_a_error= s->pict_type==I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR;
03646 const int part_a_end = s->pict_type==I_TYPE ? (DC_END |MV_END) : MV_END;
03647
03648 mb_num= mpeg4_decode_partition_a(s);
03649 if(mb_num<0){
03650 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
03651 return -1;
03652 }
03653
03654 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
03655 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
03656 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
03657 return -1;
03658 }
03659
03660 s->mb_num_left= mb_num;
03661
03662 if(s->pict_type==I_TYPE){
03663 while(show_bits(&s->gb, 9) == 1)
03664 skip_bits(&s->gb, 9);
03665 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
03666 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
03667 return -1;
03668 }
03669 }else{
03670 while(show_bits(&s->gb, 10) == 1)
03671 skip_bits(&s->gb, 10);
03672 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
03673 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
03674 return -1;
03675 }
03676 }
03677 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
03678
03679 if( mpeg4_decode_partition_b(s, mb_num) < 0){
03680 if(s->pict_type==P_TYPE)
03681 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR);
03682 return -1;
03683 }else{
03684 if(s->pict_type==P_TYPE)
03685 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END);
03686 }
03687
03688 return 0;
03689 }
03690
03695 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
03696 {
03697 int cbp, mb_type;
03698 const int xy= s->mb_x + s->mb_y*s->mb_stride;
03699
03700 mb_type= s->current_picture.mb_type[xy];
03701 cbp = s->cbp_table[xy];
03702
03703 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
03704
03705 if(s->current_picture.qscale_table[xy] != s->qscale){
03706 ff_set_qscale(s, s->current_picture.qscale_table[xy] );
03707 }
03708
03709 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
03710 int i;
03711 for(i=0; i<4; i++){
03712 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0];
03713 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1];
03714 }
03715 s->mb_intra = IS_INTRA(mb_type);
03716
03717 if (IS_SKIP(mb_type)) {
03718
03719 for(i=0;i<6;i++)
03720 s->block_last_index[i] = -1;
03721 s->mv_dir = MV_DIR_FORWARD;
03722 s->mv_type = MV_TYPE_16X16;
03723 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
03724 s->mcsel=1;
03725 s->mb_skipped = 0;
03726 }else{
03727 s->mcsel=0;
03728 s->mb_skipped = 1;
03729 }
03730 }else if(s->mb_intra){
03731 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
03732 }else if(!s->mb_intra){
03733
03734
03735 s->mv_dir = MV_DIR_FORWARD;
03736 if (IS_8X8(mb_type)) {
03737 s->mv_type = MV_TYPE_8X8;
03738 } else {
03739 s->mv_type = MV_TYPE_16X16;
03740 }
03741 }
03742 } else {
03743 s->mb_intra = 1;
03744 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]);
03745 }
03746
03747 if (!IS_SKIP(mb_type)) {
03748 int i;
03749 s->dsp.clear_blocks(s->block[0]);
03750
03751 for (i = 0; i < 6; i++) {
03752 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
03753 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
03754 return -1;
03755 }
03756 cbp+=cbp;
03757 }
03758 }
03759
03760
03761
03762 if(--s->mb_num_left <= 0){
03763
03764 if(mpeg4_is_resync(s))
03765 return SLICE_END;
03766 else
03767 return SLICE_NOEND;
03768 }else{
03769 if(mpeg4_is_resync(s)){
03770 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
03771 if(s->cbp_table[xy+delta])
03772 return SLICE_END;
03773 }
03774 return SLICE_OK;
03775 }
03776 }
03777
03781 static void preview_obmc(MpegEncContext *s){
03782 GetBitContext gb= s->gb;
03783
03784 int cbpc, i, pred_x, pred_y, mx, my;
03785 int16_t *mot_val;
03786 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
03787 const int stride= s->b8_stride*2;
03788
03789 for(i=0; i<4; i++)
03790 s->block_index[i]+= 2;
03791 for(i=4; i<6; i++)
03792 s->block_index[i]+= 1;
03793 s->mb_x++;
03794
03795 assert(s->pict_type == P_TYPE);
03796
03797 do{
03798 if (get_bits1(&s->gb)) {
03799
03800 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ];
03801 mot_val[0 ]= mot_val[2 ]=
03802 mot_val[0+stride]= mot_val[2+stride]= 0;
03803 mot_val[1 ]= mot_val[3 ]=
03804 mot_val[1+stride]= mot_val[3+stride]= 0;
03805
03806 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
03807 goto end;
03808 }
03809 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
03810 }while(cbpc == 20);
03811
03812 if(cbpc & 4){
03813 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
03814 }else{
03815 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
03816 if (cbpc & 8) {
03817 if(s->modified_quant){
03818 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
03819 else skip_bits(&s->gb, 5);
03820 }else
03821 skip_bits(&s->gb, 2);
03822 }
03823
03824 if ((cbpc & 16) == 0) {
03825 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
03826
03827 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
03828 if (s->umvplus)
03829 mx = h263p_decode_umotion(s, pred_x);
03830 else
03831 mx = h263_decode_motion(s, pred_x, 1);
03832
03833 if (s->umvplus)
03834 my = h263p_decode_umotion(s, pred_y);
03835 else
03836 my = h263_decode_motion(s, pred_y, 1);
03837
03838 mot_val[0 ]= mot_val[2 ]=
03839 mot_val[0+stride]= mot_val[2+stride]= mx;
03840 mot_val[1 ]= mot_val[3 ]=
03841 mot_val[1+stride]= mot_val[3+stride]= my;
03842 } else {
03843 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
03844 for(i=0;i<4;i++) {
03845 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
03846 if (s->umvplus)
03847 mx = h263p_decode_umotion(s, pred_x);
03848 else
03849 mx = h263_decode_motion(s, pred_x, 1);
03850
03851 if (s->umvplus)
03852 my = h263p_decode_umotion(s, pred_y);
03853 else
03854 my = h263_decode_motion(s, pred_y, 1);
03855 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
03856 skip_bits1(&s->gb);
03857 mot_val[0] = mx;
03858 mot_val[1] = my;
03859 }
03860 }
03861 }
03862 end:
03863
03864 for(i=0; i<4; i++)
03865 s->block_index[i]-= 2;
03866 for(i=4; i<6; i++)
03867 s->block_index[i]-= 1;
03868 s->mb_x--;
03869
03870 s->gb= gb;
03871 }
03872
03873 static void h263_decode_dquant(MpegEncContext *s){
03874 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
03875
03876 if(s->modified_quant){
03877 if(get_bits1(&s->gb))
03878 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];
03879 else
03880 s->qscale= get_bits(&s->gb, 5);
03881 }else
03882 s->qscale += quant_tab[get_bits(&s->gb, 2)];
03883 ff_set_qscale(s, s->qscale);
03884 }
03885
03886 int ff_h263_decode_mb(MpegEncContext *s,
03887 DCTELEM block[6][64])
03888 {
03889 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
03890 int16_t *mot_val;
03891 const int xy= s->mb_x + s->mb_y * s->mb_stride;
03892
03893 assert(!s->h263_pred);
03894
03895 if (s->pict_type == P_TYPE) {
03896 do{
03897 if (get_bits1(&s->gb)) {
03898
03899 s->mb_intra = 0;
03900 for(i=0;i<6;i++)
03901 s->block_last_index[i] = -1;
03902 s->mv_dir = MV_DIR_FORWARD;
03903 s->mv_type = MV_TYPE_16X16;
03904 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
03905 s->mv[0][0][0] = 0;
03906 s->mv[0][0][1] = 0;
03907 s->mb_skipped = !(s->obmc | s->loop_filter);
03908 goto end;
03909 }
03910 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
03911
03912 if (cbpc < 0){
03913 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
03914 return -1;
03915 }
03916 }while(cbpc == 20);
03917
03918 s->dsp.clear_blocks(s->block[0]);
03919
03920 dquant = cbpc & 8;
03921 s->mb_intra = ((cbpc & 4) != 0);
03922 if (s->mb_intra) goto intra;
03923
03924 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
03925
03926 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
03927 cbpy ^= 0xF;
03928
03929 cbp = (cbpc & 3) | (cbpy << 2);
03930 if (dquant) {
03931 h263_decode_dquant(s);
03932 }
03933
03934 s->mv_dir = MV_DIR_FORWARD;
03935 if ((cbpc & 16) == 0) {
03936 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
03937
03938 s->mv_type = MV_TYPE_16X16;
03939 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
03940 if (s->umvplus)
03941 mx = h263p_decode_umotion(s, pred_x);
03942 else
03943 mx = h263_decode_motion(s, pred_x, 1);
03944
03945 if (mx >= 0xffff)
03946 return -1;
03947
03948 if (s->umvplus)
03949 my = h263p_decode_umotion(s, pred_y);
03950 else
03951 my = h263_decode_motion(s, pred_y, 1);
03952
03953 if (my >= 0xffff)
03954 return -1;
03955 s->mv[0][0][0] = mx;
03956 s->mv[0][0][1] = my;
03957
03958 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
03959 skip_bits1(&s->gb);
03960 } else {
03961 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
03962 s->mv_type = MV_TYPE_8X8;
03963 for(i=0;i<4;i++) {
03964 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
03965 if (s->umvplus)
03966 mx = h263p_decode_umotion(s, pred_x);
03967 else
03968 mx = h263_decode_motion(s, pred_x, 1);
03969 if (mx >= 0xffff)
03970 return -1;
03971
03972 if (s->umvplus)
03973 my = h263p_decode_umotion(s, pred_y);
03974 else
03975 my = h263_decode_motion(s, pred_y, 1);
03976 if (my >= 0xffff)
03977 return -1;
03978 s->mv[0][i][0] = mx;
03979 s->mv[0][i][1] = my;
03980 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
03981 skip_bits1(&s->gb);
03982 mot_val[0] = mx;
03983 mot_val[1] = my;
03984 }
03985 }
03986
03987
03988 for (i = 0; i < 6; i++) {
03989 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
03990 return -1;
03991 cbp+=cbp;
03992 }
03993
03994 if(s->obmc){
03995 if(s->pict_type == P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1)
03996 preview_obmc(s);
03997 }
03998 } else if(s->pict_type==B_TYPE) {
03999 int mb_type;
04000 const int stride= s->b8_stride;
04001 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ];
04002 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ];
04003
04004
04005
04006 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=
04007 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=
04008 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=
04009 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;
04010
04011 do{
04012 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
04013 if (mb_type < 0){
04014 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
04015 return -1;
04016 }
04017
04018 mb_type= h263_mb_type_b_map[ mb_type ];
04019 }while(!mb_type);
04020
04021 s->mb_intra = IS_INTRA(mb_type);
04022 if(HAS_CBP(mb_type)){
04023 s->dsp.clear_blocks(s->block[0]);
04024 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);
04025 if(s->mb_intra){
04026 dquant = IS_QUANT(mb_type);
04027 goto intra;
04028 }
04029
04030 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
04031
04032 if (cbpy < 0){
04033 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
04034 return -1;
04035 }
04036
04037 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
04038 cbpy ^= 0xF;
04039
04040 cbp = (cbpc & 3) | (cbpy << 2);
04041 }else
04042 cbp=0;
04043
04044 assert(!s->mb_intra);
04045
04046 if(IS_QUANT(mb_type)){
04047 h263_decode_dquant(s);
04048 }
04049
04050 if(IS_DIRECT(mb_type)){
04051 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
04052 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
04053 }else{
04054 s->mv_dir = 0;
04055 s->mv_type= MV_TYPE_16X16;
04056
04057
04058 if(USES_LIST(mb_type, 0)){
04059 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my);
04060 s->mv_dir = MV_DIR_FORWARD;
04061
04062 mx = h263_decode_motion(s, mx, 1);
04063 my = h263_decode_motion(s, my, 1);
04064
04065 s->mv[0][0][0] = mx;
04066 s->mv[0][0][1] = my;
04067 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
04068 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
04069 }
04070
04071 if(USES_LIST(mb_type, 1)){
04072 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my);
04073 s->mv_dir |= MV_DIR_BACKWARD;
04074
04075 mx = h263_decode_motion(s, mx, 1);
04076 my = h263_decode_motion(s, my, 1);
04077
04078 s->mv[1][0][0] = mx;
04079 s->mv[1][0][1] = my;
04080 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;
04081 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;
04082 }
04083 }
04084
04085 s->current_picture.mb_type[xy]= mb_type;
04086
04087
04088 for (i = 0; i < 6; i++) {
04089 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
04090 return -1;
04091 cbp+=cbp;
04092 }
04093 } else {
04094 do{
04095 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
04096 if (cbpc < 0){
04097 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
04098 return -1;
04099 }
04100 }while(cbpc == 8);
04101
04102 s->dsp.clear_blocks(s->block[0]);
04103
04104 dquant = cbpc & 4;
04105 s->mb_intra = 1;
04106 intra:
04107 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
04108 if (s->h263_aic) {
04109 s->ac_pred = get_bits1(&s->gb);
04110 if(s->ac_pred){
04111 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
04112
04113 s->h263_aic_dir = get_bits1(&s->gb);
04114 }
04115 }else
04116 s->ac_pred = 0;
04117
04118 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
04119 if(cbpy<0){
04120 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
04121 return -1;
04122 }
04123 cbp = (cbpc & 3) | (cbpy << 2);
04124 if (dquant) {
04125 h263_decode_dquant(s);
04126 }
04127
04128
04129 for (i = 0; i < 6; i++) {
04130 if (h263_decode_block(s, block[i], i, cbp&32) < 0)
04131 return -1;
04132 cbp+=cbp;
04133 }
04134 }
04135 end:
04136
04137
04138 {
04139 int v= show_bits(&s->gb, 16);
04140
04141 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){
04142 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits;
04143 }
04144
04145 if(v==0)
04146 return SLICE_END;
04147 }
04148
04149 return SLICE_OK;
04150 }
04151
04152 int ff_mpeg4_decode_mb(MpegEncContext *s,
04153 DCTELEM block[6][64])
04154 {
04155 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
04156 int16_t *mot_val;
04157 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
04158 const int xy= s->mb_x + s->mb_y * s->mb_stride;
04159
04160 assert(s->h263_pred);
04161
04162 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
04163 do{
04164 if (get_bits1(&s->gb)) {
04165
04166 s->mb_intra = 0;
04167 for(i=0;i<6;i++)
04168 s->block_last_index[i] = -1;
04169 s->mv_dir = MV_DIR_FORWARD;
04170 s->mv_type = MV_TYPE_16X16;
04171 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
04172 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
04173 s->mcsel=1;
04174 s->mv[0][0][0]= get_amv(s, 0);
04175 s->mv[0][0][1]= get_amv(s, 1);
04176
04177 s->mb_skipped = 0;
04178 }else{
04179 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
04180 s->mcsel=0;
04181 s->mv[0][0][0] = 0;
04182 s->mv[0][0][1] = 0;
04183 s->mb_skipped = 1;
04184 }
04185 goto end;
04186 }
04187 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
04188
04189 if (cbpc < 0){
04190 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
04191 return -1;
04192 }
04193 }while(cbpc == 20);
04194
04195 s->dsp.clear_blocks(s->block[0]);
04196 dquant = cbpc & 8;
04197 s->mb_intra = ((cbpc & 4) != 0);
04198 if (s->mb_intra) goto intra;
04199
04200 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
04201 s->mcsel= get_bits1(&s->gb);
04202 else s->mcsel= 0;
04203 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
04204
04205 cbp = (cbpc & 3) | (cbpy << 2);
04206 if (dquant) {
04207 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
04208 }
04209 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
04210 s->interlaced_dct= get_bits1(&s->gb);
04211
04212 s->mv_dir = MV_DIR_FORWARD;
04213 if ((cbpc & 16) == 0) {
04214 if(s->mcsel){
04215 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
04216
04217 s->mv_type = MV_TYPE_16X16;
04218 mx= get_amv(s, 0);
04219 my= get_amv(s, 1);
04220 s->mv[0][0][0] = mx;
04221 s->mv[0][0][1] = my;
04222 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
04223 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
04224
04225 s->mv_type= MV_TYPE_FIELD;
04226
04227 s->field_select[0][0]= get_bits1(&s->gb);
04228 s->field_select[0][1]= get_bits1(&s->gb);
04229
04230 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
04231
04232 for(i=0; i<2; i++){
04233 mx = h263_decode_motion(s, pred_x, s->f_code);
04234 if (mx >= 0xffff)
04235 return -1;
04236
04237 my = h263_decode_motion(s, pred_y/2, s->f_code);
04238 if (my >= 0xffff)
04239 return -1;
04240
04241 s->mv[0][i][0] = mx;
04242 s->mv[0][i][1] = my;
04243 }
04244 }else{
04245 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
04246
04247 s->mv_type = MV_TYPE_16X16;
04248 h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
04249 mx = h263_decode_motion(s, pred_x, s->f_code);
04250
04251 if (mx >= 0xffff)
04252 return -1;
04253
04254 my = h263_decode_motion(s, pred_y, s->f_code);
04255
04256 if (my >= 0xffff)
04257 return -1;
04258 s->mv[0][0][0] = mx;
04259 s->mv[0][0][1] = my;
04260 }
04261 } else {
04262 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0;
04263 s->mv_type = MV_TYPE_8X8;
04264 for(i=0;i<4;i++) {
04265 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y);
04266 mx = h263_decode_motion(s, pred_x, s->f_code);
04267 if (mx >= 0xffff)
04268 return -1;
04269
04270 my = h263_decode_motion(s, pred_y, s->f_code);
04271 if (my >= 0xffff)
04272 return -1;
04273 s->mv[0][i][0] = mx;
04274 s->mv[0][i][1] = my;
04275 mot_val[0] = mx;
04276 mot_val[1] = my;
04277 }
04278 }
04279 } else if(s->pict_type==B_TYPE) {
04280 int modb1;
04281 int modb2;
04282 int mb_type;
04283
04284 s->mb_intra = 0;
04285 s->mcsel=0;
04286
04287 if(s->mb_x==0){
04288 for(i=0; i<2; i++){
04289 s->last_mv[i][0][0]=
04290 s->last_mv[i][0][1]=
04291 s->last_mv[i][1][0]=
04292 s->last_mv[i][1][1]= 0;
04293 }
04294 }
04295
04296
04297 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x];
04298
04299 if(s->mb_skipped){
04300
04301 for(i=0;i<6;i++)
04302 s->block_last_index[i] = -1;
04303
04304 s->mv_dir = MV_DIR_FORWARD;
04305 s->mv_type = MV_TYPE_16X16;
04306 s->mv[0][0][0] = 0;
04307 s->mv[0][0][1] = 0;
04308 s->mv[1][0][0] = 0;
04309 s->mv[1][0][1] = 0;
04310 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
04311 goto end;
04312 }
04313
04314 modb1= get_bits1(&s->gb);
04315 if(modb1){
04316 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1;
04317 cbp=0;
04318 }else{
04319 modb2= get_bits1(&s->gb);
04320 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
04321 if(mb_type<0){
04322 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
04323 return -1;
04324 }
04325 mb_type= mb_type_b_map[ mb_type ];
04326 if(modb2) cbp= 0;
04327 else{
04328 s->dsp.clear_blocks(s->block[0]);
04329 cbp= get_bits(&s->gb, 6);
04330 }
04331
04332 if ((!IS_DIRECT(mb_type)) && cbp) {
04333 if(get_bits1(&s->gb)){
04334 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
04335 }
04336 }
04337
04338 if(!s->progressive_sequence){
04339 if(cbp)
04340 s->interlaced_dct= get_bits1(&s->gb);
04341
04342 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
04343 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
04344 mb_type &= ~MB_TYPE_16x16;
04345
04346 if(USES_LIST(mb_type, 0)){
04347 s->field_select[0][0]= get_bits1(&s->gb);
04348 s->field_select[0][1]= get_bits1(&s->gb);
04349 }
04350 if(USES_LIST(mb_type, 1)){
04351 s->field_select[1][0]= get_bits1(&s->gb);
04352 s->field_select[1][1]= get_bits1(&s->gb);
04353 }
04354 }
04355 }
04356
04357 s->mv_dir = 0;
04358 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
04359 s->mv_type= MV_TYPE_16X16;
04360
04361 if(USES_LIST(mb_type, 0)){
04362 s->mv_dir = MV_DIR_FORWARD;
04363
04364 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
04365 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
04366 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
04367 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
04368 }
04369
04370 if(USES_LIST(mb_type, 1)){
04371 s->mv_dir |= MV_DIR_BACKWARD;
04372
04373 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
04374 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
04375 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
04376 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
04377 }
04378 }else if(!IS_DIRECT(mb_type)){
04379 s->mv_type= MV_TYPE_FIELD;
04380
04381 if(USES_LIST(mb_type, 0)){
04382 s->mv_dir = MV_DIR_FORWARD;
04383
04384 for(i=0; i<2; i++){
04385 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
04386 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
04387 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
04388 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
04389 }
04390 }
04391
04392 if(USES_LIST(mb_type, 1)){
04393 s->mv_dir |= MV_DIR_BACKWARD;
04394
04395 for(i=0; i<2; i++){
04396 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
04397 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
04398 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
04399 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
04400 }
04401 }
04402 }
04403 }
04404
04405 if(IS_DIRECT(mb_type)){
04406 if(IS_SKIP(mb_type))
04407 mx=my=0;
04408 else{
04409 mx = h263_decode_motion(s, 0, 1);
04410 my = h263_decode_motion(s, 0, 1);
04411 }
04412
04413 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
04414 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
04415 }
04416 s->current_picture.mb_type[xy]= mb_type;
04417 } else {
04418 do{
04419 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
04420 if (cbpc < 0){
04421 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
04422 return -1;
04423 }
04424 }while(cbpc == 8);
04425
04426 dquant = cbpc & 4;
04427 s->mb_intra = 1;
04428 intra:
04429 s->ac_pred = get_bits1(&s->gb);
04430 if(s->ac_pred)
04431 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED;
04432 else
04433 s->current_picture.mb_type[xy]= MB_TYPE_INTRA;
04434
04435 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
04436 if(cbpy<0){
04437 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
04438 return -1;
04439 }
04440 cbp = (cbpc & 3) | (cbpy << 2);
04441
04442 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
04443
04444 if (dquant) {
04445 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
04446 }
04447
04448 if(!s->progressive_sequence)
04449 s->interlaced_dct= get_bits1(&s->gb);
04450
04451 s->dsp.clear_blocks(s->block[0]);
04452
04453 for (i = 0; i < 6; i++) {
04454 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
04455 return -1;
04456 cbp+=cbp;
04457 }
04458 goto end;
04459 }
04460
04461
04462 for (i = 0; i < 6; i++) {
04463 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
04464 return -1;
04465 cbp+=cbp;
04466 }
04467 end:
04468
04469
04470 if(s->codec_id==CODEC_ID_MPEG4){
04471 if(mpeg4_is_resync(s)){
04472 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
04473 if(s->pict_type==B_TYPE && s->next_picture.mbskip_table[xy + delta])
04474 return SLICE_OK;
04475 return SLICE_END;
04476 }
04477 }
04478
04479 return SLICE_OK;
04480 }
04481
04482 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
04483 {
04484 int code, val, sign, shift, l;
04485 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
04486
04487 if (code == 0)
04488 return pred;
04489 if (code < 0)
04490 return 0xffff;
04491
04492 sign = get_bits1(&s->gb);
04493 shift = f_code - 1;
04494 val = code;
04495 if (shift) {
04496 val = (val - 1) << shift;
04497 val |= get_bits(&s->gb, shift);
04498 val++;
04499 }
04500 if (sign)
04501 val = -val;
04502 val += pred;
04503
04504
04505 if (!s->h263_long_vectors) {
04506 l = INT_BIT - 5 - f_code;
04507 val = (val<<l)>>l;
04508 } else {
04509
04510 if (pred < -31 && val < -63)
04511 val += 64;
04512 if (pred > 32 && val > 63)
04513 val -= 64;
04514
04515 }
04516 return val;
04517 }
04518
04519
04520 static int h263p_decode_umotion(MpegEncContext * s, int pred)
04521 {
04522 int code = 0, sign;
04523
04524 if (get_bits1(&s->gb))
04525 return pred;
04526
04527 code = 2 + get_bits1(&s->gb);
04528
04529 while (get_bits1(&s->gb))
04530 {
04531 code <<= 1;
04532 code += get_bits1(&s->gb);
04533 }
04534 sign = code & 1;
04535 code >>= 1;
04536
04537 code = (sign) ? (pred - code) : (pred + code);
04538 #ifdef DEBUG
04539 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code);
04540 #endif
04541 return code;
04542
04543 }
04544
04545 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
04546 int n, int coded)
04547 {
04548 int code, level, i, j, last, run;
04549 RLTable *rl = &rl_inter;
04550 const uint8_t *scan_table;
04551 GetBitContext gb= s->gb;
04552
04553 scan_table = s->intra_scantable.permutated;
04554 if (s->h263_aic && s->mb_intra) {
04555 rl = &rl_intra_aic;
04556 i = 0;
04557 if (s->ac_pred) {
04558 if (s->h263_aic_dir)
04559 scan_table = s->intra_v_scantable.permutated;
04560 else
04561 scan_table = s->intra_h_scantable.permutated;
04562 }
04563 } else if (s->mb_intra) {
04564
04565 if(s->codec_id == CODEC_ID_RV10){
04566 #ifdef CONFIG_RV10_DECODER
04567 if (s->rv10_version == 3 && s->pict_type == I_TYPE) {
04568 int component, diff;
04569 component = (n <= 3 ? 0 : n - 4 + 1);
04570 level = s->last_dc[component];
04571 if (s->rv10_first_dc_coded[component]) {
04572 diff = rv_decode_dc(s, n);
04573 if (diff == 0xffff)
04574 return -1;
04575 level += diff;
04576 level = level & 0xff;
04577 s->last_dc[component] = level;
04578 } else {
04579 s->rv10_first_dc_coded[component] = 1;
04580 }
04581 } else {
04582 level = get_bits(&s->gb, 8);
04583 if (level == 255)
04584 level = 128;
04585 }
04586 #endif
04587 }else{
04588 level = get_bits(&s->gb, 8);
04589 if((level&0x7F) == 0){
04590 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
04591 if(s->error_resilience >= FF_ER_COMPLIANT)
04592 return -1;
04593 }
04594 if (level == 255)
04595 level = 128;
04596 }
04597 block[0] = level;
04598 i = 1;
04599 } else {
04600 i = 0;
04601 }
04602 if (!coded) {
04603 if (s->mb_intra && s->h263_aic)
04604 goto not_coded;
04605 s->block_last_index[n] = i - 1;
04606 return 0;
04607 }
04608 retry:
04609 for(;;) {
04610 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2);
04611 if (code < 0){
04612 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
04613 return -1;
04614 }
04615 if (code == rl->n) {
04616
04617 if (s->h263_flv > 1) {
04618 int is11 = get_bits1(&s->gb);
04619 last = get_bits1(&s->gb);
04620 run = get_bits(&s->gb, 6);
04621 if(is11){
04622 level = get_sbits(&s->gb, 11);
04623 } else {
04624 level = get_sbits(&s->gb, 7);
04625 }
04626 } else {
04627 last = get_bits1(&s->gb);
04628 run = get_bits(&s->gb, 6);
04629 level = (int8_t)get_bits(&s->gb, 8);
04630 if(level == -128){
04631 if (s->codec_id == CODEC_ID_RV10) {
04632
04633 level = get_sbits(&s->gb, 12);
04634 }else{
04635 level = get_bits(&s->gb, 5);
04636 level |= get_sbits(&s->gb, 6)<<5;
04637 }
04638 }
04639 }
04640 } else {
04641 run = rl->table_run[code];
04642 level = rl->table_level[code];
04643 last = code >= rl->last;
04644 if (get_bits1(&s->gb))
04645 level = -level;
04646 }
04647 i += run;
04648 if (i >= 64){
04649 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){
04650
04651 rl = &rl_intra_aic;
04652 i = 0;
04653 s->gb= gb;
04654 memset(block, 0, sizeof(DCTELEM)*64);
04655 goto retry;
04656 }
04657 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);
04658 return -1;
04659 }
04660 j = scan_table[i];
04661 block[j] = level;
04662 if (last)
04663 break;
04664 i++;
04665 }
04666 not_coded:
04667 if (s->mb_intra && s->h263_aic) {
04668 h263_pred_acdc(s, block, n);
04669 i = 63;
04670 }
04671 s->block_last_index[n] = i;
04672 return 0;
04673 }
04674
04681 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
04682 {
04683 int level, code;
04684
04685 if (n < 4)
04686 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
04687 else
04688 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
04689 if (code < 0 || code > 9 ){
04690 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
04691 return -1;
04692 }
04693 if (code == 0) {
04694 level = 0;
04695 } else {
04696 if(IS_3IV1){
04697 if(code==1)
04698 level= 2*get_bits1(&s->gb)-1;
04699 else{
04700 if(get_bits1(&s->gb))
04701 level = get_bits(&s->gb, code-1) + (1<<(code-1));
04702 else
04703 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
04704 }
04705 }else{
04706 level = get_xbits(&s->gb, code);
04707 }
04708
04709 if (code > 8){
04710 if(get_bits1(&s->gb)==0){
04711 if(s->error_resilience>=2){
04712 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
04713 return -1;
04714 }
04715 }
04716 }
04717 }
04718
04719 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
04720 }
04721
04726 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
04727 int n, int coded, int intra, int rvlc)
04728 {
04729 int level, i, last, run;
04730 int dc_pred_dir;
04731 RLTable * rl;
04732 RL_VLC_ELEM * rl_vlc;
04733 const uint8_t * scan_table;
04734 int qmul, qadd;
04735
04736
04737
04738 if(intra) {
04739 if(s->use_intra_dc_vlc){
04740
04741 if(s->partitioned_frame){
04742 level = s->dc_val[0][ s->block_index[n] ];
04743 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
04744 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
04745 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
04746 }else{
04747 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
04748 if (level < 0)
04749 return -1;
04750 }
04751 block[0] = level;
04752 i = 0;
04753 }else{
04754 i = -1;
04755 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
04756 }
04757 if (!coded)
04758 goto not_coded;
04759
04760 if(rvlc){
04761 rl = &rvlc_rl_intra;
04762 rl_vlc = rvlc_rl_intra.rl_vlc[0];
04763 }else{
04764 rl = &rl_intra;
04765 rl_vlc = rl_intra.rl_vlc[0];
04766 }
04767 if (s->ac_pred) {
04768 if (dc_pred_dir == 0)
04769 scan_table = s->intra_v_scantable.permutated;
04770 else
04771 scan_table = s->intra_h_scantable.permutated;
04772 } else {
04773 scan_table = s->intra_scantable.permutated;
04774 }
04775 qmul=1;
04776 qadd=0;
04777 } else {
04778 i = -1;
04779 if (!coded) {
04780 s->block_last_index[n] = i;
04781 return 0;
04782 }
04783 if(rvlc) rl = &rvlc_rl_inter;
04784 else rl = &rl_inter;
04785
04786 scan_table = s->intra_scantable.permutated;
04787
04788 if(s->mpeg_quant){
04789 qmul=1;
04790 qadd=0;
04791 if(rvlc){
04792 rl_vlc = rvlc_rl_inter.rl_vlc[0];
04793 }else{
04794 rl_vlc = rl_inter.rl_vlc[0];
04795 }
04796 }else{
04797 qmul = s->qscale << 1;
04798 qadd = (s->qscale - 1) | 1;
04799 if(rvlc){
04800 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
04801 }else{
04802 rl_vlc = rl_inter.rl_vlc[s->qscale];
04803 }
04804 }
04805 }
04806 {
04807 OPEN_READER(re, &s->gb);
04808 for(;;) {
04809 UPDATE_CACHE(re, &s->gb);
04810 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
04811 if (level==0) {
04812
04813 if(rvlc){
04814 if(SHOW_UBITS(re, &s->gb, 1)==0){
04815 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
04816 return -1;
04817 }; SKIP_CACHE(re, &s->gb, 1);
04818
04819 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
04820 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
04821 SKIP_COUNTER(re, &s->gb, 1+1+6);
04822 UPDATE_CACHE(re, &s->gb);
04823
04824 if(SHOW_UBITS(re, &s->gb, 1)==0){
04825 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
04826 return -1;
04827 }; SKIP_CACHE(re, &s->gb, 1);
04828
04829 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
04830
04831 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
04832 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
04833 return -1;
04834 }; SKIP_CACHE(re, &s->gb, 5);
04835
04836 level= level * qmul + qadd;
04837 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1);
04838 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
04839
04840 i+= run + 1;
04841 if(last) i+=192;
04842 }else{
04843 int cache;
04844 cache= GET_CACHE(re, &s->gb);
04845
04846 if(IS_3IV1)
04847 cache ^= 0xC0000000;
04848
04849 if (cache&0x80000000) {
04850 if (cache&0x40000000) {
04851
04852 SKIP_CACHE(re, &s->gb, 2);
04853 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
04854 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6);
04855 SKIP_COUNTER(re, &s->gb, 2+1+6);
04856 UPDATE_CACHE(re, &s->gb);
04857
04858 if(IS_3IV1){
04859 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
04860 }else{
04861 if(SHOW_UBITS(re, &s->gb, 1)==0){
04862 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
04863 return -1;
04864 }; SKIP_CACHE(re, &s->gb, 1);
04865
04866 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
04867
04868 if(SHOW_UBITS(re, &s->gb, 1)==0){
04869 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
04870 return -1;
04871 }; LAST_SKIP_CACHE(re, &s->gb, 1);
04872
04873 SKIP_COUNTER(re, &s->gb, 1+12+1);
04874 }
04875
04876 #if 0
04877 if(s->error_resilience >= FF_ER_COMPLIANT){
04878 const int abs_level= FFABS(level);
04879 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
04880 const int run1= run - rl->max_run[last][abs_level] - 1;
04881 if(abs_level <= rl->max_level[last][run]){
04882 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
04883 return -1;
04884 }
04885 if(s->error_resilience > FF_ER_COMPLIANT){
04886 if(abs_level <= rl->max_level[last][run]*2){
04887 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
04888 return -1;
04889 }
04890 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
04891 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
04892 return -1;
04893 }
04894 }
04895 }
04896 }
04897 #endif
04898 if (level>0) level= level * qmul + qadd;
04899 else level= level * qmul - qadd;
04900
04901 if((unsigned)(level + 2048) > 4095){
04902 if(s->error_resilience > FF_ER_COMPLIANT){
04903 if(level > 2560 || level<-2560){
04904 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
04905 return -1;
04906 }
04907 }
04908 level= level<0 ? -2048 : 2047;
04909 }
04910
04911 i+= run + 1;
04912 if(last) i+=192;
04913 } else {
04914
04915 #if MIN_CACHE_BITS < 20
04916 LAST_SKIP_BITS(re, &s->gb, 2);
04917 UPDATE_CACHE(re, &s->gb);
04918 #else
04919 SKIP_BITS(re, &s->gb, 2);
04920 #endif
04921 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
04922 i+= run + rl->max_run[run>>7][level/qmul] +1;
04923 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
04924 LAST_SKIP_BITS(re, &s->gb, 1);
04925 }
04926 } else {
04927
04928 #if MIN_CACHE_BITS < 19
04929 LAST_SKIP_BITS(re, &s->gb, 1);
04930 UPDATE_CACHE(re, &s->gb);
04931 #else
04932 SKIP_BITS(re, &s->gb, 1);
04933 #endif
04934 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
04935 i+= run;
04936 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;
04937 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
04938 LAST_SKIP_BITS(re, &s->gb, 1);
04939 }
04940 }
04941 } else {
04942 i+= run;
04943 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
04944 LAST_SKIP_BITS(re, &s->gb, 1);
04945 }
04946 if (i > 62){
04947 i-= 192;
04948 if(i&(~63)){
04949 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
04950 return -1;
04951 }
04952
04953 block[scan_table[i]] = level;
04954 break;
04955 }
04956
04957 block[scan_table[i]] = level;
04958 }
04959 CLOSE_READER(re, &s->gb);
04960 }
04961 not_coded:
04962 if (intra) {
04963 if(!s->use_intra_dc_vlc){
04964 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
04965
04966 i -= i>>31;
04967 }
04968
04969 mpeg4_pred_ac(s, block, n, dc_pred_dir);
04970 if (s->ac_pred) {
04971 i = 63;
04972 }
04973 }
04974 s->block_last_index[n] = i;
04975 return 0;
04976 }
04977
04978
04979 int h263_decode_picture_header(MpegEncContext *s)
04980 {
04981 int format, width, height, i;
04982 uint32_t startcode;
04983
04984 align_get_bits(&s->gb);
04985
04986 startcode= get_bits(&s->gb, 22-8);
04987
04988 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) {
04989 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
04990
04991 if(startcode == 0x20)
04992 break;
04993 }
04994
04995 if (startcode != 0x20) {
04996 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
04997 return -1;
04998 }
04999
05000 i = get_bits(&s->gb, 8);
05001 if( (s->picture_number&~0xFF)+i < s->picture_number)
05002 i+= 256;
05003 s->current_picture_ptr->pts=
05004 s->picture_number= (s->picture_number&~0xFF) + i;
05005
05006
05007 if (get_bits1(&s->gb) != 1) {
05008
05009 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
05010 return -1;
05011 }
05012 if (get_bits1(&s->gb) != 0) {
05013 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
05014 return -1;
05015 }
05016 skip_bits1(&s->gb);
05017 skip_bits1(&s->gb);
05018 skip_bits1(&s->gb);
05019
05020 format = get_bits(&s->gb, 3);
05021
05022
05023
05024
05025
05026
05027
05028 if (format != 7 && format != 6) {
05029 s->h263_plus = 0;
05030
05031 width = h263_format[format][0];
05032 height = h263_format[format][1];
05033 if (!width)
05034 return -1;
05035
05036 s->pict_type = I_TYPE + get_bits1(&s->gb);
05037
05038 s->h263_long_vectors = get_bits1(&s->gb);
05039
05040 if (get_bits1(&s->gb) != 0) {
05041 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n");
05042 return -1;
05043 }
05044 s->obmc= get_bits1(&s->gb);
05045 s->unrestricted_mv = s->h263_long_vectors || s->obmc;
05046
05047 if (get_bits1(&s->gb) != 0) {
05048 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n");
05049 return -1;
05050 }
05051 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
05052 skip_bits1(&s->gb);
05053
05054 s->width = width;
05055 s->height = height;
05056 s->avctx->sample_aspect_ratio= (AVRational){12,11};
05057 s->avctx->time_base= (AVRational){1001, 30000};
05058 } else {
05059 int ufep;
05060
05061
05062 s->h263_plus = 1;
05063 ufep = get_bits(&s->gb, 3);
05064
05065
05066 if (ufep == 1) {
05067
05068 format = get_bits(&s->gb, 3);
05069 dprintf(s->avctx, "ufep=1, format: %d\n", format);
05070 s->custom_pcf= get_bits1(&s->gb);
05071 s->umvplus = get_bits1(&s->gb);
05072 if (get_bits1(&s->gb) != 0) {
05073 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");
05074 }
05075 s->obmc= get_bits1(&s->gb);
05076 s->h263_aic = get_bits1(&s->gb);
05077 s->loop_filter= get_bits1(&s->gb);
05078 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
05079
05080 s->h263_slice_structured= get_bits1(&s->gb);
05081 if (get_bits1(&s->gb) != 0) {
05082 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");
05083 }
05084 if (get_bits1(&s->gb) != 0) {
05085 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");
05086 }
05087 s->alt_inter_vlc= get_bits1(&s->gb);
05088 s->modified_quant= get_bits1(&s->gb);
05089 if(s->modified_quant)
05090 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
05091
05092 skip_bits(&s->gb, 1);
05093
05094 skip_bits(&s->gb, 3);
05095 } else if (ufep != 0) {
05096 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);
05097 return -1;
05098 }
05099
05100
05101 s->pict_type = get_bits(&s->gb, 3);
05102 switch(s->pict_type){
05103 case 0: s->pict_type= I_TYPE;break;
05104 case 1: s->pict_type= P_TYPE;break;
05105 case 3: s->pict_type= B_TYPE;break;
05106 case 7: s->pict_type= I_TYPE;break;
05107 default:
05108 return -1;
05109 }
05110 skip_bits(&s->gb, 2);
05111 s->no_rounding = get_bits1(&s->gb);
05112 skip_bits(&s->gb, 4);
05113
05114
05115 if (ufep) {
05116 if (format == 6) {
05117
05118 s->aspect_ratio_info = get_bits(&s->gb, 4);
05119 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info);
05120
05121
05122
05123
05124
05125
05126
05127
05128
05129 width = (get_bits(&s->gb, 9) + 1) * 4;
05130 skip_bits1(&s->gb);
05131 height = get_bits(&s->gb, 9) * 4;
05132 dprintf(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);
05133 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) {
05134
05135 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);
05136 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);
05137 }else{
05138 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
05139 }
05140 } else {
05141 width = h263_format[format][0];
05142 height = h263_format[format][1];
05143 s->avctx->sample_aspect_ratio= (AVRational){12,11};
05144 }
05145 if ((width == 0) || (height == 0))
05146 return -1;
05147 s->width = width;
05148 s->height = height;
05149
05150 if(s->custom_pcf){
05151 int gcd;
05152 s->avctx->time_base.den= 1800000;
05153 s->avctx->time_base.num= 1000 + get_bits1(&s->gb);
05154 s->avctx->time_base.num*= get_bits(&s->gb, 7);
05155 if(s->avctx->time_base.num == 0){
05156 av_log(s, AV_LOG_ERROR, "zero framerate\n");
05157 return -1;
05158 }
05159 gcd= ff_gcd(s->avctx->time_base.den, s->avctx->time_base.num);
05160 s->avctx->time_base.den /= gcd;
05161 s->avctx->time_base.num /= gcd;
05162
05163 }else{
05164 s->avctx->time_base= (AVRational){1001, 30000};
05165 }
05166 }
05167
05168 if(s->custom_pcf){
05169 skip_bits(&s->gb, 2);
05170 }
05171
05172 if (ufep) {
05173 if (s->umvplus) {
05174 if(get_bits1(&s->gb)==0)
05175 skip_bits1(&s->gb);
05176 }
05177 if(s->h263_slice_structured){
05178 if (get_bits1(&s->gb) != 0) {
05179 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");
05180 }
05181 if (get_bits1(&s->gb) != 0) {
05182 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
05183 }
05184 }
05185 }
05186
05187 s->qscale = get_bits(&s->gb, 5);
05188 }
05189
05190 s->mb_width = (s->width + 15) / 16;
05191 s->mb_height = (s->height + 15) / 16;
05192 s->mb_num = s->mb_width * s->mb_height;
05193
05194
05195 while (get_bits1(&s->gb) != 0) {
05196 skip_bits(&s->gb, 8);
05197 }
05198
05199 if(s->h263_slice_structured){
05200 if (get_bits1(&s->gb) != 1) {
05201 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n");
05202 return -1;
05203 }
05204
05205 ff_h263_decode_mba(s);
05206
05207 if (get_bits1(&s->gb) != 1) {
05208 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n");
05209 return -1;
05210 }
05211 }
05212 s->f_code = 1;
05213
05214 if(s->h263_aic){
05215 s->y_dc_scale_table=
05216 s->c_dc_scale_table= ff_aic_dc_scale_table;
05217 }else{
05218 s->y_dc_scale_table=
05219 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
05220 }
05221
05222 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
05223 show_pict_info(s);
05224 }
05225 #if 1
05226 if (s->pict_type == I_TYPE && s->codec_tag == ff_get_fourcc("ZYGO")){
05227 int i,j;
05228 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
05229 av_log(s->avctx, AV_LOG_DEBUG, "\n");
05230 for(i=0; i<13; i++){
05231 for(j=0; j<3; j++){
05232 int v= get_bits(&s->gb, 8);
05233 v |= get_sbits(&s->gb, 8)<<8;
05234 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);
05235 }
05236 av_log(s->avctx, AV_LOG_DEBUG, "\n");
05237 }
05238 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
05239 }
05240 #endif
05241
05242 return 0;
05243 }
05244
05245 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb)
05246 {
05247 int i;
05248 int a= 2<<s->sprite_warping_accuracy;
05249 int rho= 3-s->sprite_warping_accuracy;
05250 int r=16/a;
05251 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}};
05252 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
05253 int sprite_ref[4][2];
05254 int virtual_ref[2][2];
05255 int w2, h2, w3, h3;
05256 int alpha=0, beta=0;
05257 int w= s->width;
05258 int h= s->height;
05259 int min_ab;
05260
05261 for(i=0; i<s->num_sprite_warping_points; i++){
05262 int length;
05263 int x=0, y=0;
05264
05265 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
05266 if(length){
05267 x= get_xbits(gb, length);
05268 }
05269 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb);
05270
05271 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
05272 if(length){
05273 y=get_xbits(gb, length);
05274 }
05275 skip_bits1(gb);
05276
05277 d[i][0]= x;
05278 d[i][1]= y;
05279 }
05280
05281 while((1<<alpha)<w) alpha++;
05282 while((1<<beta )<h) beta++;
05283 w2= 1<<alpha;
05284 h2= 1<<beta;
05285
05286
05287 if(s->divx_version==500 && s->divx_build==413){
05288 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
05289 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
05290 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
05291 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
05292 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
05293 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
05294 } else {
05295 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
05296 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
05297 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
05298 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
05299 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
05300 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
05301 }
05302
05303
05304
05305
05306
05307
05308
05309 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
05310 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
05311 virtual_ref[0][1]= 16*vop_ref[0][1]
05312 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
05313 virtual_ref[1][0]= 16*vop_ref[0][0]
05314 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
05315 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
05316 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
05317
05318 switch(s->num_sprite_warping_points)
05319 {
05320 case 0:
05321 s->sprite_offset[0][0]= 0;
05322 s->sprite_offset[0][1]= 0;
05323 s->sprite_offset[1][0]= 0;
05324 s->sprite_offset[1][1]= 0;
05325 s->sprite_delta[0][0]= a;
05326 s->sprite_delta[0][1]= 0;
05327 s->sprite_delta[1][0]= 0;
05328 s->sprite_delta[1][1]= a;
05329 s->sprite_shift[0]= 0;
05330 s->sprite_shift[1]= 0;
05331 break;
05332 case 1:
05333 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
05334 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
05335 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
05336 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
05337 s->sprite_delta[0][0]= a;
05338 s->sprite_delta[0][1]= 0;
05339 s->sprite_delta[1][0]= 0;
05340 s->sprite_delta[1][1]= a;
05341 s->sprite_shift[0]= 0;
05342 s->sprite_shift[1]= 0;
05343 break;
05344 case 2:
05345 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
05346 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
05347 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
05348 + (1<<(alpha+rho-1));
05349 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
05350 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
05351 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
05352 + (1<<(alpha+rho-1));
05353 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
05354 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
05355 +2*w2*r*sprite_ref[0][0]
05356 - 16*w2
05357 + (1<<(alpha+rho+1)));
05358 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
05359 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
05360 +2*w2*r*sprite_ref[0][1]
05361 - 16*w2
05362 + (1<<(alpha+rho+1)));
05363 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
05364 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
05365 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
05366 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
05367
05368 s->sprite_shift[0]= alpha+rho;
05369 s->sprite_shift[1]= alpha+rho+2;
05370 break;
05371 case 3:
05372 min_ab= FFMIN(alpha, beta);
05373 w3= w2>>min_ab;
05374 h3= h2>>min_ab;
05375 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
05376 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
05377 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
05378 + (1<<(alpha+beta+rho-min_ab-1));
05379 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
05380 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
05381 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
05382 + (1<<(alpha+beta+rho-min_ab-1));
05383 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
05384 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
05385 + 2*w2*h3*r*sprite_ref[0][0]
05386 - 16*w2*h3
05387 + (1<<(alpha+beta+rho-min_ab+1));
05388 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
05389 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
05390 + 2*w2*h3*r*sprite_ref[0][1]
05391 - 16*w2*h3
05392 + (1<<(alpha+beta+rho-min_ab+1));
05393 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
05394 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
05395 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
05396 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
05397
05398 s->sprite_shift[0]= alpha + beta + rho - min_ab;
05399 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
05400 break;
05401 }
05402
05403 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
05404 && s->sprite_delta[0][1] == 0
05405 && s->sprite_delta[1][0] == 0
05406 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
05407 {
05408 s->sprite_offset[0][0]>>=s->sprite_shift[0];
05409 s->sprite_offset[0][1]>>=s->sprite_shift[0];
05410 s->sprite_offset[1][0]>>=s->sprite_shift[1];
05411 s->sprite_offset[1][1]>>=s->sprite_shift[1];
05412 s->sprite_delta[0][0]= a;
05413 s->sprite_delta[0][1]= 0;
05414 s->sprite_delta[1][0]= 0;
05415 s->sprite_delta[1][1]= a;
05416 s->sprite_shift[0]= 0;
05417 s->sprite_shift[1]= 0;
05418 s->real_sprite_warping_points=1;
05419 }
05420 else{
05421 int shift_y= 16 - s->sprite_shift[0];
05422 int shift_c= 16 - s->sprite_shift[1];
05423
05424 for(i=0; i<2; i++){
05425 s->sprite_offset[0][i]<<= shift_y;
05426 s->sprite_offset[1][i]<<= shift_c;
05427 s->sprite_delta[0][i]<<= shift_y;
05428 s->sprite_delta[1][i]<<= shift_y;
05429 s->sprite_shift[i]= 16;
05430 }
05431 s->real_sprite_warping_points= s->num_sprite_warping_points;
05432 }
05433 #if 0
05434 printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n",
05435 vop_ref[0][0], vop_ref[0][1],
05436 vop_ref[1][0], vop_ref[1][1],
05437 vop_ref[2][0], vop_ref[2][1],
05438 sprite_ref[0][0], sprite_ref[0][1],
05439 sprite_ref[1][0], sprite_ref[1][1],
05440 sprite_ref[2][0], sprite_ref[2][1],
05441 virtual_ref[0][0], virtual_ref[0][1],
05442 virtual_ref[1][0], virtual_ref[1][1]
05443 );
05444
05445 printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n",
05446 s->sprite_offset[0][0], s->sprite_offset[0][1],
05447 s->sprite_delta[0][0], s->sprite_delta[0][1],
05448 s->sprite_delta[1][0], s->sprite_delta[1][1],
05449 s->sprite_shift[0]
05450 );
05451 #endif
05452 }
05453
05454 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
05455 int hours, minutes, seconds;
05456
05457 hours= get_bits(gb, 5);
05458 minutes= get_bits(gb, 6);
05459 skip_bits1(gb);
05460 seconds= get_bits(gb, 6);
05461
05462 s->time_base= seconds + 60*(minutes + 60*hours);
05463
05464 skip_bits1(gb);
05465 skip_bits1(gb);
05466
05467 return 0;
05468 }
05469
05470 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
05471 int width, height, vo_ver_id;
05472
05473
05474 skip_bits(gb, 1);
05475 s->vo_type= get_bits(gb, 8);
05476 if (get_bits1(gb) != 0) {
05477 vo_ver_id = get_bits(gb, 4);
05478 skip_bits(gb, 3);
05479 } else {
05480 vo_ver_id = 1;
05481 }
05482
05483 s->aspect_ratio_info= get_bits(gb, 4);
05484 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
05485 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8);
05486 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8);
05487 }else{
05488 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info];
05489 }
05490
05491 if ((s->vol_control_parameters=get_bits1(gb))) {
05492 int chroma_format= get_bits(gb, 2);
05493 if(chroma_format!=1){
05494 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
05495 }
05496 s->low_delay= get_bits1(gb);
05497 if(get_bits1(gb)){
05498 get_bits(gb, 15);
05499 skip_bits1(gb);
05500 get_bits(gb, 15);
05501 skip_bits1(gb);
05502 get_bits(gb, 15);
05503 skip_bits1(gb);
05504 get_bits(gb, 3);
05505 get_bits(gb, 11);
05506 skip_bits1(gb);
05507 get_bits(gb, 15);
05508 skip_bits1(gb);
05509 }
05510 }else{
05511
05512 if(s->picture_number==0)
05513 s->low_delay=0;
05514 }
05515
05516 s->shape = get_bits(gb, 2);
05517 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
05518 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
05519 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
05520 skip_bits(gb, 4);
05521 }
05522
05523 check_marker(gb, "before time_increment_resolution");
05524
05525 s->avctx->time_base.den = get_bits(gb, 16);
05526 if(!s->avctx->time_base.den){
05527 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
05528 return -1;
05529 }
05530
05531 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
05532 if (s->time_increment_bits < 1)
05533 s->time_increment_bits = 1;
05534
05535 check_marker(gb, "before fixed_vop_rate");
05536
05537 if (get_bits1(gb) != 0) {
05538 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
05539 }else
05540 s->avctx->time_base.num = 1;
05541
05542 s->t_frame=0;
05543
05544 if (s->shape != BIN_ONLY_SHAPE) {
05545 if (s->shape == RECT_SHAPE) {
05546 skip_bits1(gb);
05547 width = get_bits(gb, 13);
05548 skip_bits1(gb);
05549 height = get_bits(gb, 13);
05550 skip_bits1(gb);
05551 if(width && height && !(s->width && s->codec_tag == ff_get_fourcc("MP4S"))){
05552 s->width = width;
05553 s->height = height;
05554
05555 }
05556 }
05557
05558 s->progressive_sequence=
05559 s->progressive_frame= get_bits1(gb)^1;
05560 s->interlaced_dct=0;
05561 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
05562 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n");
05563 if (vo_ver_id == 1) {
05564 s->vol_sprite_usage = get_bits1(gb);
05565 } else {
05566 s->vol_sprite_usage = get_bits(gb, 2);
05567 }
05568 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
05569 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
05570 if(s->vol_sprite_usage==STATIC_SPRITE){
05571 s->sprite_width = get_bits(gb, 13);
05572 skip_bits1(gb);
05573 s->sprite_height= get_bits(gb, 13);
05574 skip_bits1(gb);
05575 s->sprite_left = get_bits(gb, 13);
05576 skip_bits1(gb);
05577 s->sprite_top = get_bits(gb, 13);
05578 skip_bits1(gb);
05579 }
05580 s->num_sprite_warping_points= get_bits(gb, 6);
05581 if(s->num_sprite_warping_points > 3){
05582 av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points);
05583 s->num_sprite_warping_points= 0;
05584 return -1;
05585 }
05586 s->sprite_warping_accuracy = get_bits(gb, 2);
05587 s->sprite_brightness_change= get_bits1(gb);
05588 if(s->vol_sprite_usage==STATIC_SPRITE)
05589 s->low_latency_sprite= get_bits1(gb);
05590 }
05591
05592
05593 if (get_bits1(gb) == 1) {
05594 s->quant_precision = get_bits(gb, 4);
05595 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n");
05596 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
05597 } else {
05598 s->quant_precision = 5;
05599 }
05600
05601
05602
05603 if((s->mpeg_quant=get_bits1(gb))){
05604 int i, v;
05605
05606
05607 for(i=0; i<64; i++){
05608 int j= s->dsp.idct_permutation[i];
05609 v= ff_mpeg4_default_intra_matrix[i];
05610 s->intra_matrix[j]= v;
05611 s->chroma_intra_matrix[j]= v;
05612
05613 v= ff_mpeg4_default_non_intra_matrix[i];
05614 s->inter_matrix[j]= v;
05615 s->chroma_inter_matrix[j]= v;
05616 }
05617
05618
05619 if(get_bits1(gb)){
05620 int last=0;
05621 for(i=0; i<64; i++){
05622 int j;
05623 v= get_bits(gb, 8);
05624 if(v==0) break;
05625
05626 last= v;
05627 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
05628 s->intra_matrix[j]= v;
05629 s->chroma_intra_matrix[j]= v;
05630 }
05631
05632
05633 for(; i<64; i++){
05634 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
05635 s->intra_matrix[j]= last;
05636 s->chroma_intra_matrix[j]= last;
05637 }
05638 }
05639
05640
05641 if(get_bits1(gb)){
05642 int last=0;
05643 for(i=0; i<64; i++){
05644 int j;
05645 v= get_bits(gb, 8);
05646 if(v==0) break;
05647
05648 last= v;
05649 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
05650 s->inter_matrix[j]= v;
05651 s->chroma_inter_matrix[j]= v;
05652 }
05653
05654
05655 for(; i<64; i++){
05656 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
05657 s->inter_matrix[j]= last;
05658 s->chroma_inter_matrix[j]= last;
05659 }
05660 }
05661
05662
05663 }
05664
05665 if(vo_ver_id != 1)
05666 s->quarter_sample= get_bits1(gb);
05667 else s->quarter_sample=0;
05668
05669 if(!get_bits1(gb)) av_log(s->avctx, AV_LOG_ERROR, "Complexity estimation not supported\n");
05670
05671 s->resync_marker= !get_bits1(gb);
05672
05673 s->data_partitioning= get_bits1(gb);
05674 if(s->data_partitioning){
05675 s->rvlc= get_bits1(gb);
05676 }
05677
05678 if(vo_ver_id != 1) {
05679 s->new_pred= get_bits1(gb);
05680 if(s->new_pred){
05681 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
05682 skip_bits(gb, 2);
05683 skip_bits1(gb);
05684 }
05685 s->reduced_res_vop= get_bits1(gb);
05686 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
05687 }
05688 else{
05689 s->new_pred=0;
05690 s->reduced_res_vop= 0;
05691 }
05692
05693 s->scalability= get_bits1(gb);
05694
05695 if (s->scalability) {
05696 GetBitContext bak= *gb;
05697 int ref_layer_id;
05698 int ref_layer_sampling_dir;
05699 int h_sampling_factor_n;
05700 int h_sampling_factor_m;
05701 int v_sampling_factor_n;
05702 int v_sampling_factor_m;
05703
05704 s->hierachy_type= get_bits1(gb);
05705 ref_layer_id= get_bits(gb, 4);
05706 ref_layer_sampling_dir= get_bits1(gb);
05707 h_sampling_factor_n= get_bits(gb, 5);
05708 h_sampling_factor_m= get_bits(gb, 5);
05709 v_sampling_factor_n= get_bits(gb, 5);
05710 v_sampling_factor_m= get_bits(gb, 5);
05711 s->enhancement_type= get_bits1(gb);
05712
05713 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
05714 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
05715
05716
05717 s->scalability=0;
05718
05719 *gb= bak;
05720 }else
05721 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
05722
05723
05724 }
05725 }
05726 return 0;
05727 }
05728
05733 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
05734 char buf[256];
05735 int i;
05736 int e;
05737 int ver = 0, build = 0, ver2 = 0, ver3 = 0;
05738 char last;
05739
05740 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
05741 if(show_bits(gb, 23) == 0) break;
05742 buf[i]= get_bits(gb, 8);
05743 }
05744 buf[i]=0;
05745
05746
05747 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
05748 if(e<2)
05749 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
05750 if(e>=2){
05751 s->divx_version= ver;
05752 s->divx_build= build;
05753 s->divx_packed= e==3 && last=='p';
05754 }
05755
05756
05757 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
05758 if(e!=4)
05759 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
05760 if(e!=4){
05761 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
05762 if (e>1)
05763 build= (ver<<16) + (ver2<<8) + ver3;
05764 }
05765 if(e!=4){
05766 if(strcmp(buf, "ffmpeg")==0){
05767 s->lavc_build= 4600;
05768 }
05769 }
05770 if(e==4){
05771 s->lavc_build= build;
05772 }
05773
05774
05775 e=sscanf(buf, "XviD%d", &build);
05776 if(e==1){
05777 s->xvid_build= build;
05778 }
05779
05780
05781 return 0;
05782 }
05783
05784 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
05785 int time_incr, time_increment;
05786
05787 s->pict_type = get_bits(gb, 2) + I_TYPE;
05788 if(s->pict_type==B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
05789 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
05790 s->low_delay=0;
05791 }
05792
05793 s->partitioned_frame= s->data_partitioning && s->pict_type!=B_TYPE;
05794 if(s->partitioned_frame)
05795 s->decode_mb= mpeg4_decode_partitioned_mb;
05796 else
05797 s->decode_mb= ff_mpeg4_decode_mb;
05798
05799 time_incr=0;
05800 while (get_bits1(gb) != 0)
05801 time_incr++;
05802
05803 check_marker(gb, "before time_increment");
05804
05805 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
05806 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
05807
05808 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
05809 if(show_bits(gb, s->time_increment_bits+1)&1) break;
05810 }
05811
05812 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
05813 }
05814
05815 if(IS_3IV1) time_increment= get_bits1(gb);
05816 else time_increment= get_bits(gb, s->time_increment_bits);
05817
05818
05819
05820 if(s->pict_type!=B_TYPE){
05821 s->last_time_base= s->time_base;
05822 s->time_base+= time_incr;
05823 s->time= s->time_base*s->avctx->time_base.den + time_increment;
05824 if(s->workaround_bugs&FF_BUG_UMP4){
05825 if(s->time < s->last_non_b_time){
05826
05827 s->time_base++;
05828 s->time+= s->avctx->time_base.den;
05829 }
05830 }
05831 s->pp_time= s->time - s->last_non_b_time;
05832 s->last_non_b_time= s->time;
05833 }else{
05834 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
05835 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
05836 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
05837
05838 return FRAME_SKIPPED;
05839 }
05840 ff_mpeg4_init_direct_mv(s);
05841
05842 if(s->t_frame==0) s->t_frame= s->pb_time;
05843 if(s->t_frame==0) s->t_frame=1;
05844 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
05845 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
05846 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
05847 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
05848 if(!s->progressive_sequence){
05849 if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1)
05850 return FRAME_SKIPPED;
05851 }
05852 }
05853
05854
05855 if(s->avctx->time_base.num)
05856 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num;
05857 else
05858 s->current_picture_ptr->pts= AV_NOPTS_VALUE;
05859 if(s->avctx->debug&FF_DEBUG_PTS)
05860 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts);
05861
05862 check_marker(gb, "before vop_coded");
05863
05864
05865 if (get_bits1(gb) != 1){
05866 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
05867 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
05868 return FRAME_SKIPPED;
05869 }
05870
05871
05872 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == P_TYPE
05873 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) {
05874
05875 s->no_rounding = get_bits1(gb);
05876 } else {
05877 s->no_rounding = 0;
05878 }
05879
05880
05881 if (s->shape != RECT_SHAPE) {
05882 if (s->vol_sprite_usage != 1 || s->pict_type != I_TYPE) {
05883 int width, height, hor_spat_ref, ver_spat_ref;
05884
05885 width = get_bits(gb, 13);
05886 skip_bits1(gb);
05887 height = get_bits(gb, 13);
05888 skip_bits1(gb);
05889 hor_spat_ref = get_bits(gb, 13);
05890 skip_bits1(gb);
05891 ver_spat_ref = get_bits(gb, 13);
05892 }
05893 skip_bits1(gb);
05894
05895 if (get_bits1(gb) != 0) {
05896 skip_bits(gb, 8);
05897 }
05898 }
05899
05900
05901 if (s->shape != BIN_ONLY_SHAPE) {
05902 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
05903 if(!s->progressive_sequence){
05904 s->top_field_first= get_bits1(gb);
05905 s->alternate_scan= get_bits1(gb);
05906 }else
05907 s->alternate_scan= 0;
05908 }
05909
05910 if(s->alternate_scan){
05911 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
05912 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
05913 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
05914 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
05915 } else{
05916 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
05917 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
05918 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
05919 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
05920 }
05921
05922 if(s->pict_type == S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
05923 mpeg4_decode_sprite_trajectory(s, gb);
05924 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
05925 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
05926 }
05927
05928 if (s->shape != BIN_ONLY_SHAPE) {
05929 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
05930 if(s->qscale==0){
05931 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
05932 return -1;
05933 }
05934
05935 if (s->pict_type != I_TYPE) {
05936 s->f_code = get_bits(gb, 3);
05937 if(s->f_code==0){
05938 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
05939 return -1;
05940 }
05941 }else
05942 s->f_code=1;
05943
05944 if (s->pict_type == B_TYPE) {
05945 s->b_code = get_bits(gb, 3);
05946 }else
05947 s->b_code=1;
05948
05949 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
05950 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d\n",
05951 s->qscale, s->f_code, s->b_code,
05952 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
05953 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
05954 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
05955 s->sprite_warping_accuracy, 1-s->no_rounding, s->vo_type, s->vol_control_parameters ? " VOLC" : " ", s->intra_dc_threshold);
05956 }
05957
05958 if(!s->scalability){
05959 if (s->shape!=RECT_SHAPE && s->pict_type!=I_TYPE) {
05960 skip_bits1(gb);
05961 }
05962 }else{
05963 if(s->enhancement_type){
05964 int load_backward_shape= get_bits1(gb);
05965 if(load_backward_shape){
05966 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
05967 }
05968 }
05969 skip_bits(gb, 2);
05970 }
05971 }
05972
05973
05974 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){
05975 av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
05976 s->low_delay=1;
05977 }
05978
05979 s->picture_number++;
05980
05981 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
05982 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
05983
05984 if(s->workaround_bugs&FF_BUG_EDGE){
05985 s->h_edge_pos= s->width;
05986 s->v_edge_pos= s->height;
05987 }
05988 return 0;
05989 }
05990
05997 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
05998 {
05999 int startcode, v;
06000
06001
06002 align_get_bits(gb);
06003
06004 if(s->codec_tag == ff_get_fourcc("WV1F") && show_bits(gb, 24) == 0x575630){
06005 skip_bits(gb, 24);
06006 if(get_bits(gb, 8) == 0xF0)
06007 return decode_vop_header(s, gb);
06008 }
06009
06010 startcode = 0xff;
06011 for(;;) {
06012 if(get_bits_count(gb) >= gb->size_in_bits){
06013 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){
06014 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits);
06015 return FRAME_SKIPPED;
06016 }else
06017 return -1;
06018 }
06019
06020
06021 v = get_bits(gb, 8);
06022 startcode = ((startcode << 8) | v) & 0xffffffff;
06023
06024 if((startcode&0xFFFFFF00) != 0x100)
06025 continue;
06026
06027 if(s->avctx->debug&FF_DEBUG_STARTCODE){
06028 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
06029 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
06030 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
06031 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
06032 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
06033 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
06034 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
06035 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
06036 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
06037 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
06038 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
06039 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
06040 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
06041 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
06042 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
06043 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
06044 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
06045 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
06046 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
06047 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
06048 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
06049 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
06050 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
06051 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
06052 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
06053 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
06054 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
06055 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
06056 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
06057 }
06058
06059 if(startcode >= 0x120 && startcode <= 0x12F){
06060 if(decode_vol_header(s, gb) < 0)
06061 return -1;
06062 }
06063 else if(startcode == USER_DATA_STARTCODE){
06064 decode_user_data(s, gb);
06065 }
06066 else if(startcode == GOP_STARTCODE){
06067 mpeg4_decode_gop_header(s, gb);
06068 }
06069 else if(startcode == VOP_STARTCODE){
06070 return decode_vop_header(s, gb);
06071 }
06072
06073 align_get_bits(gb);
06074 startcode = 0xff;
06075 }
06076 }
06077
06078
06079 int intel_h263_decode_picture_header(MpegEncContext *s)
06080 {
06081 int format;
06082
06083
06084 if (get_bits_long(&s->gb, 22) != 0x20) {
06085 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
06086 return -1;
06087 }
06088 s->picture_number = get_bits(&s->gb, 8);
06089
06090 if (get_bits1(&s->gb) != 1) {
06091 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
06092 return -1;
06093 }
06094 if (get_bits1(&s->gb) != 0) {
06095 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
06096 return -1;
06097 }
06098 skip_bits1(&s->gb);
06099 skip_bits1(&s->gb);
06100 skip_bits1(&s->gb);
06101
06102 format = get_bits(&s->gb, 3);
06103 if (format != 7) {
06104 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
06105 return -1;
06106 }
06107 s->h263_plus = 0;
06108
06109 s->pict_type = I_TYPE + get_bits1(&s->gb);
06110
06111 s->unrestricted_mv = get_bits1(&s->gb);
06112 s->h263_long_vectors = s->unrestricted_mv;
06113
06114 if (get_bits1(&s->gb) != 0) {
06115 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
06116 return -1;
06117 }
06118 s->obmc= get_bits1(&s->gb);
06119 if (get_bits1(&s->gb) != 0) {
06120 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n");
06121 return -1;
06122 }
06123
06124
06125 skip_bits(&s->gb, 41);
06126
06127 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
06128 skip_bits1(&s->gb);
06129
06130
06131 while (get_bits1(&s->gb) != 0) {
06132 skip_bits(&s->gb, 8);
06133 }
06134 s->f_code = 1;
06135
06136 s->y_dc_scale_table=
06137 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
06138
06139 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
06140 show_pict_info(s);
06141
06142 return 0;
06143 }
06144
06145 int flv_h263_decode_picture_header(MpegEncContext *s)
06146 {
06147 int format, width, height;
06148
06149
06150 if (get_bits_long(&s->gb, 17) != 1) {
06151 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
06152 return -1;
06153 }
06154 format = get_bits(&s->gb, 5);
06155 if (format != 0 && format != 1) {
06156 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
06157 return -1;
06158 }
06159 s->h263_flv = format+1;
06160 s->picture_number = get_bits(&s->gb, 8);
06161 format = get_bits(&s->gb, 3);
06162 switch (format) {
06163 case 0:
06164 width = get_bits(&s->gb, 8);
06165 height = get_bits(&s->gb, 8);
06166 break;
06167 case 1:
06168 width = get_bits(&s->gb, 16);
06169 height = get_bits(&s->gb, 16);
06170 break;
06171 case 2:
06172 width = 352;
06173 height = 288;
06174 break;
06175 case 3:
06176 width = 176;
06177 height = 144;
06178 break;
06179 case 4:
06180 width = 128;
06181 height = 96;
06182 break;
06183 case 5:
06184 width = 320;
06185 height = 240;
06186 break;
06187 case 6:
06188 width = 160;
06189 height = 120;
06190 break;
06191 default:
06192 width = height = 0;
06193 break;
06194 }
06195 if(avcodec_check_dimensions(s->avctx, width, height))
06196 return -1;
06197 s->width = width;
06198 s->height = height;
06199
06200 s->pict_type = I_TYPE + get_bits(&s->gb, 2);
06201 s->dropable= s->pict_type > P_TYPE;
06202 if (s->dropable)
06203 s->pict_type = P_TYPE;
06204
06205 skip_bits1(&s->gb);
06206 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
06207
06208 s->h263_plus = 0;
06209
06210 s->unrestricted_mv = 1;
06211 s->h263_long_vectors = 0;
06212
06213
06214 while (get_bits1(&s->gb) != 0) {
06215 skip_bits(&s->gb, 8);
06216 }
06217 s->f_code = 1;
06218
06219 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
06220 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
06221 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
06222 }
06223
06224 s->y_dc_scale_table=
06225 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
06226
06227 return 0;
06228 }