Mercurial > libavcodec.hg

comparison mpegvideo.c @ 294:944632089814 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
4MV motion estimation (not finished yet) SAD functions rewritten (8x8 support & MMX2 optimizations) HQ inter/intra decission msmpeg4 encoding bugfix (MV where too long)
author michaelni
date Wed, 27 Mar 2002 21:25:22 +0000
parents 73a9ce3d9715
children 6622b0fd036c
comparison
equal deleted inserted replaced
293:6eaf5da091fa 294:944632089814
225 if (!s->encoding) { 225 if (!s->encoding) {
226 s->mbskip_table = av_mallocz(s->mb_num); 226 s->mbskip_table = av_mallocz(s->mb_num);
227 if (!s->mbskip_table) 227 if (!s->mbskip_table)
228 goto fail; 228 goto fail;
229 } 229 }
230
231 s->block= s->intra_block;
230 232
231 s->context_initialized = 1; 233 s->context_initialized = 1;
232 return 0; 234 return 0;
233 fail: 235 fail:
234 MPV_common_end(s); 236 MPV_common_end(s);
293 s->max_qdiff= avctx->max_qdiff; 295 s->max_qdiff= avctx->max_qdiff;
294 s->qcompress= avctx->qcompress; 296 s->qcompress= avctx->qcompress;
295 s->qblur= avctx->qblur; 297 s->qblur= avctx->qblur;
296 s->avctx = avctx; 298 s->avctx = avctx;
297 s->aspect_ratio_info= avctx->aspect_ratio_info; 299 s->aspect_ratio_info= avctx->aspect_ratio_info;
298 s->hq= (avctx->flags & CODEC_FLAG_HQ); 300 s->flags= avctx->flags;
299 301
300 if (s->gop_size <= 1) { 302 if (s->gop_size <= 1) {
301 s->intra_only = 1; 303 s->intra_only = 1;
302 s->gop_size = 12; 304 s->gop_size = 12;
303 } else { 305 } else {
1076 put_dct(s, block[4], 4, dest_cb, s->linesize >> 1); 1078 put_dct(s, block[4], 4, dest_cb, s->linesize >> 1);
1077 put_dct(s, block[5], 5, dest_cr, s->linesize >> 1); 1079 put_dct(s, block[5], 5, dest_cr, s->linesize >> 1);
1078 } 1080 }
1079 } 1081 }
1080 the_end: 1082 the_end:
1081 emms_c(); 1083 emms_c(); //FIXME remove
1084 }
1085
1086 static void encode_mb(MpegEncContext *s)
1087 {
1088 int wrap;
1089 const int mb_x= s->mb_x;
1090 const int mb_y= s->mb_y;
1091 UINT8 *ptr;
1092 const int motion_x= s->mv[0][0][0];
1093 const int motion_y= s->mv[0][0][1];
1094 int i;
1095
1096 /* get the pixels */
1097 wrap = s->linesize;
1098 ptr = s->new_picture[0] + (mb_y * 16 * wrap) + mb_x * 16;
1099 get_pixels(s->block[0], ptr, wrap);
1100 get_pixels(s->block[1], ptr + 8, wrap);
1101 get_pixels(s->block[2], ptr + 8 * wrap, wrap);
1102 get_pixels(s->block[3], ptr + 8 * wrap + 8, wrap);
1103 wrap = s->linesize >> 1;
1104 ptr = s->new_picture[1] + (mb_y * 8 * wrap) + mb_x * 8;
1105 get_pixels(s->block[4], ptr, wrap);
1106
1107 wrap = s->linesize >> 1;
1108 ptr = s->new_picture[2] + (mb_y * 8 * wrap) + mb_x * 8;
1109 get_pixels(s->block[5], ptr, wrap);
1110
1111 /* subtract previous frame if non intra */
1112 if (!s->mb_intra) {
1113 int dxy, offset, mx, my;
1114
1115 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1116 ptr = s->last_picture[0] +
1117 ((mb_y * 16 + (motion_y >> 1)) * s->linesize) +
1118 (mb_x * 16 + (motion_x >> 1));
1119
1120 sub_pixels_2(s->block[0], ptr, s->linesize, dxy);
1121 sub_pixels_2(s->block[1], ptr + 8, s->linesize, dxy);
1122 sub_pixels_2(s->block[2], ptr + s->linesize * 8, s->linesize, dxy);
1123 sub_pixels_2(s->block[3], ptr + 8 + s->linesize * 8, s->linesize ,dxy);
1124
1125 if (s->out_format == FMT_H263) {
1126 /* special rounding for h263 */
1127 dxy = 0;
1128 if ((motion_x & 3) != 0)
1129 dxy |= 1;
1130 if ((motion_y & 3) != 0)
1131 dxy |= 2;
1132 mx = motion_x >> 2;
1133 my = motion_y >> 2;
1134 } else {
1135 mx = motion_x / 2;
1136 my = motion_y / 2;
1137 dxy = ((my & 1) << 1) | (mx & 1);
1138 mx >>= 1;
1139 my >>= 1;
1140 }
1141 offset = ((mb_y * 8 + my) * (s->linesize >> 1)) + (mb_x * 8 + mx);
1142 ptr = s->last_picture[1] + offset;
1143 sub_pixels_2(s->block[4], ptr, s->linesize >> 1, dxy);
1144 ptr = s->last_picture[2] + offset;
1145 sub_pixels_2(s->block[5], ptr, s->linesize >> 1, dxy);
1146 }
1147
1148 #if 0
1149 {
1150 float adap_parm;
1151
1152 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
1153 ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
1154
1155 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d",
1156 (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P',
1157 s->qscale, adap_parm, s->qscale*adap_parm,
1158 s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
1159 }
1160 #endif
1161 /* DCT & quantize */
1162 if (s->h263_msmpeg4) {
1163 msmpeg4_dc_scale(s);
1164 } else if (s->h263_pred) {
1165 h263_dc_scale(s);
1166 } else {
1167 /* default quantization values */
1168 s->y_dc_scale = 8;
1169 s->c_dc_scale = 8;
1170 }
1171 for(i=0;i<6;i++) {
1172 s->block_last_index[i] = dct_quantize(s, s->block[i], i, s->qscale);
1173 }
1174
1175 /* huffman encode */
1176 switch(s->out_format) {
1177 case FMT_MPEG1:
1178 mpeg1_encode_mb(s, s->block, motion_x, motion_y);
1179 break;
1180 case FMT_H263:
1181 if (s->h263_msmpeg4)
1182 msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
1183 else if(s->h263_pred)
1184 mpeg4_encode_mb(s, s->block, motion_x, motion_y);
1185 else
1186 h263_encode_mb(s, s->block, motion_x, motion_y);
1187 break;
1188 case FMT_MJPEG:
1189 mjpeg_encode_mb(s, s->block);
1190 break;
1191 }
1192 }
1193
1194 static void copy_bits(PutBitContext *pb, UINT8 *src, int length)
1195 {
1196 int bytes= length>>3;
1197 int bits= length&7;
1198 int i;
1199
1200 for(i=0; i<bytes; i++) put_bits(pb, 8, src[i]);
1201 put_bits(pb, bits, src[i]>>(8-bits));
1082 } 1202 }
1083 1203
1084 static void encode_picture(MpegEncContext *s, int picture_number) 1204 static void encode_picture(MpegEncContext *s, int picture_number)
1085 { 1205 {
1086 int mb_x, mb_y, wrap, last_gob, pdif = 0; 1206 int mb_x, mb_y, last_gob, pdif = 0;
1087 UINT8 *ptr; 1207 int i;
1088 int i, motion_x, motion_y;
1089 int bits; 1208 int bits;
1209 MpegEncContext best_s;
1210 UINT8 bit_buf[4][3000]; //FIXME check that this is ALLWAYS large enogh for a MB
1090 1211
1091 s->picture_number = picture_number; 1212 s->picture_number = picture_number;
1092 1213
1214 s->block_wrap[0]=
1215 s->block_wrap[1]=
1216 s->block_wrap[2]=
1217 s->block_wrap[3]= s->mb_width*2 + 2;
1218 s->block_wrap[4]=
1219 s->block_wrap[5]= s->mb_width + 2;
1220
1093 s->last_mc_mb_var = s->mc_mb_var; 1221 s->last_mc_mb_var = s->mc_mb_var;
1094 /* Reset the average MB variance */ 1222 /* Reset the average MB variance */
1095 s->avg_mb_var = 0; 1223 s->avg_mb_var = 0;
1096 s->mc_mb_var = 0; 1224 s->mc_mb_var = 0;
1097 /* Estimate motion for every MB */ 1225 /* Estimate motion for every MB */
1098 for(mb_y=0; mb_y < s->mb_height; mb_y++) { 1226 if(s->pict_type == P_TYPE){
1099 for(mb_x=0; mb_x < s->mb_width; mb_x++) { 1227 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
1100 int xy= mb_y * s->mb_width + mb_x; 1228 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
1101 const int mot_stride = s->mb_width*2 + 2; 1229 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
1102 int mot_xy = (mb_y*2 + 1)*mot_stride + mb_x*2 + 1; 1230 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
1103 s->mb_x = mb_x; 1231 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
1104 s->mb_y = mb_y; 1232 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
1105 1233 s->mb_x = mb_x;
1106 /* compute motion vector and macro block type (intra or non intra) */ 1234 s->mb_y = mb_y;
1107 motion_x = 0; 1235 s->block_index[0]+=2;
1108 motion_y = 0; 1236 s->block_index[1]+=2;
1109 if (s->pict_type == P_TYPE) { 1237 s->block_index[2]+=2;
1110 s->mb_intra = estimate_motion(s, mb_x, mb_y, 1238 s->block_index[3]+=2;
1111 &motion_x, 1239
1112 &motion_y); 1240 /* compute motion vector & mb_type and store in context */
1113 } else { 1241 estimate_motion(s, mb_x, mb_y);
1114 s->mb_intra = 1; 1242 // s->mb_type[mb_y*s->mb_width + mb_x]=MB_TYPE_INTER;
1115 } 1243 }
1116 /* Store MB type and MV */ 1244 }
1117 s->mb_type[xy] = s->mb_intra; 1245 emms_c();
1118 s->mv_table[0][xy] = motion_x; 1246 }else{
1119 s->mv_table[1][xy] = motion_y; 1247 /* I-Frame */
1120 1248 //FIXME do we need to zero them?
1121 s->motion_val[mot_xy ][0]= motion_x; 1249 memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
1122 s->motion_val[mot_xy ][1]= motion_y; 1250 memset(s->mv_table[0] , 0, sizeof(INT16)*s->mb_width*s->mb_height);
1123 s->motion_val[mot_xy+1][0]= motion_x; 1251 memset(s->mv_table[1] , 0, sizeof(INT16)*s->mb_width*s->mb_height);
1124 s->motion_val[mot_xy+1][1]= motion_y; 1252 memset(s->mb_type , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
1125 mot_xy += mot_stride; 1253 }
1126 s->motion_val[mot_xy ][0]= motion_x;
1127 s->motion_val[mot_xy ][1]= motion_y;
1128 s->motion_val[mot_xy+1][0]= motion_x;
1129 s->motion_val[mot_xy+1][1]= motion_y;
1130 }
1131 }
1132 emms_c();
1133 1254
1134 if(s->avg_mb_var < s->mc_mb_var && s->pict_type != B_TYPE){ //FIXME subtract MV bits 1255 if(s->avg_mb_var < s->mc_mb_var && s->pict_type != B_TYPE){ //FIXME subtract MV bits
1135 int i;
1136 s->pict_type= I_TYPE; 1256 s->pict_type= I_TYPE;
1137 s->picture_in_gop_number=0; 1257 s->picture_in_gop_number=0;
1138 for(i=0; i<s->mb_num; i++){ 1258 memset(s->mb_type , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
1139 s->mb_type[i] = 1; 1259 //printf("Scene change detected, encoding as I Frame\n");
1140 s->mv_table[0][i] = 0;
1141 s->mv_table[1][i] = 0;
1142 }
1143 } 1260 }
1144 1261
1145 /* find best f_code for ME which do unlimited searches */ 1262 /* find best f_code for ME which do unlimited searches */
1146 if(s->pict_type==P_TYPE && s->full_search>3){ 1263 if(s->pict_type==P_TYPE && s->full_search>3){
1147 int mv_num[8]; 1264 int mv_num[8];
1150 UINT8 * fcode_tab= s->fcode_tab; 1267 UINT8 * fcode_tab= s->fcode_tab;
1151 1268
1152 for(i=0; i<8; i++) mv_num[i]=0; 1269 for(i=0; i<8; i++) mv_num[i]=0;
1153 1270
1154 for(i=0; i<s->mb_num; i++){ 1271 for(i=0; i<s->mb_num; i++){
1155 if(s->mb_type[i] == 0){ 1272 if(s->mb_type[i] & (MB_TYPE_INTER|MB_TYPE_INTER4V)){
1156 mv_num[ fcode_tab[s->mv_table[0][i] + MAX_MV] ]++; 1273 mv_num[ fcode_tab[s->mv_table[0][i] + MAX_MV] ]++;
1157 mv_num[ fcode_tab[s->mv_table[1][i] + MAX_MV] ]++; 1274 mv_num[ fcode_tab[s->mv_table[1][i] + MAX_MV] ]++;
1158 //printf("%d %d %d\n", s->mv_table[0][i], fcode_tab[s->mv_table[0][i] + MAX_MV], i); 1275 //printf("%d %d %d\n", s->mv_table[0][i], fcode_tab[s->mv_table[0][i] + MAX_MV], i);
1159 } 1276 }
1160 //else printf("I"); 1277 //else printf("I");
1179 int i; 1296 int i;
1180 const int f_code= s->f_code; 1297 const int f_code= s->f_code;
1181 UINT8 * fcode_tab= s->fcode_tab; 1298 UINT8 * fcode_tab= s->fcode_tab;
1182 1299
1183 for(i=0; i<s->mb_num; i++){ 1300 for(i=0; i<s->mb_num; i++){
1184 if(s->mb_type[i] == 0){ 1301 if(s->mb_type[i]&MB_TYPE_INTER){
1185 if( fcode_tab[s->mv_table[0][i] + MAX_MV] > f_code 1302 if( fcode_tab[s->mv_table[0][i] + MAX_MV] > f_code
1186 || fcode_tab[s->mv_table[0][i] + MAX_MV] == 0 1303 || fcode_tab[s->mv_table[0][i] + MAX_MV] == 0
1187 || fcode_tab[s->mv_table[1][i] + MAX_MV] > f_code 1304 || fcode_tab[s->mv_table[1][i] + MAX_MV] > f_code
1188 || fcode_tab[s->mv_table[1][i] + MAX_MV] == 0 ){ 1305 || fcode_tab[s->mv_table[1][i] + MAX_MV] == 0 ){
1189 s->mb_type[i] = 1; 1306 s->mb_type[i] &= ~MB_TYPE_INTER;
1307 s->mb_type[i] |= MB_TYPE_INTRA;
1190 s->mv_table[0][i] = 0; 1308 s->mv_table[0][i] = 0;
1191 s->mv_table[1][i] = 0; 1309 s->mv_table[1][i] = 0;
1192 } 1310 }
1311 }
1312 if(s->mb_type[i]&MB_TYPE_INTER4V){
1313 //FIXME
1193 } 1314 }
1194 } 1315 }
1195 } 1316 }
1196 1317
1197 // printf("%d %d\n", s->avg_mb_var, s->mc_mb_var); 1318 // printf("%d %d\n", s->avg_mb_var, s->mc_mb_var);
1247 s->last_dc[1] = 128; 1368 s->last_dc[1] = 128;
1248 s->last_dc[2] = 128; 1369 s->last_dc[2] = 128;
1249 s->mb_incr = 1; 1370 s->mb_incr = 1;
1250 s->last_mv[0][0][0] = 0; 1371 s->last_mv[0][0][0] = 0;
1251 s->last_mv[0][0][1] = 0; 1372 s->last_mv[0][0][1] = 0;
1252 s->mv_type = MV_TYPE_16X16;
1253 s->mv_dir = MV_DIR_FORWARD;
1254 1373
1255 /* Get the GOB height based on picture height */ 1374 /* Get the GOB height based on picture height */
1256 if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4) { 1375 if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4) {
1257 if (s->height <= 400) 1376 if (s->height <= 400)
1258 s->gob_index = 1; 1377 s->gob_index = 1;
1262 s->gob_index = 4; 1381 s->gob_index = 4;
1263 } 1382 }
1264 1383
1265 s->avg_mb_var = s->avg_mb_var / s->mb_num; 1384 s->avg_mb_var = s->avg_mb_var / s->mb_num;
1266 1385
1267 s->block_wrap[0]=
1268 s->block_wrap[1]=
1269 s->block_wrap[2]=
1270 s->block_wrap[3]= s->mb_width*2 + 2;
1271 s->block_wrap[4]=
1272 s->block_wrap[5]= s->mb_width + 2;
1273 for(mb_y=0; mb_y < s->mb_height; mb_y++) { 1386 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
1274 /* Put GOB header based on RTP MTU */ 1387 /* Put GOB header based on RTP MTU */
1275 /* TODO: Put all this stuff in a separate generic function */ 1388 /* TODO: Put all this stuff in a separate generic function */
1276 if (s->rtp_mode) { 1389 if (s->rtp_mode) {
1277 if (!mb_y) { 1390 if (!mb_y) {
1290 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1; 1403 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
1291 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2); 1404 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
1292 s->block_index[4]= s->block_wrap[4]*(mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2); 1405 s->block_index[4]= s->block_wrap[4]*(mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2);
1293 s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2); 1406 s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
1294 for(mb_x=0; mb_x < s->mb_width; mb_x++) { 1407 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
1408 const int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
1409 PutBitContext pb;
1410 int d;
1411 int dmin=10000000;
1412 int best=0;
1295 1413
1296 s->mb_x = mb_x; 1414 s->mb_x = mb_x;
1297 s->mb_y = mb_y; 1415 s->mb_y = mb_y;
1298 s->block_index[0]+=2; 1416 s->block_index[0]+=2;
1299 s->block_index[1]+=2; 1417 s->block_index[1]+=2;
1300 s->block_index[2]+=2; 1418 s->block_index[2]+=2;
1301 s->block_index[3]+=2; 1419 s->block_index[3]+=2;
1302 s->block_index[4]++; 1420 s->block_index[4]++;
1303 s->block_index[5]++; 1421 s->block_index[5]++;
1304 #if 0 1422
1305 /* compute motion vector and macro block type (intra or non intra) */ 1423 s->mv_type = MV_TYPE_16X16;
1306 motion_x = 0; 1424 s->mv_dir = MV_DIR_FORWARD;
1307 motion_y = 0; 1425 if(mb_type & (mb_type-1)){ // more than 1 MB type possible
1308 if (s->pict_type == P_TYPE) { 1426 pb= s->pb;
1309 s->mb_intra = estimate_motion(s, mb_x, mb_y, 1427 if(mb_type&MB_TYPE_INTER){
1310 &motion_x, 1428 s->mb_intra= 0;
1311 &motion_y); 1429 s->mv[0][0][0] = s->mv_table[0][mb_y * s->mb_width + mb_x];
1430 s->mv[0][0][1] = s->mv_table[1][mb_y * s->mb_width + mb_x];
1431 init_put_bits(&s->pb, bit_buf[1], 3000, NULL, NULL);
1432 s->block= s->inter_block;
1433
1434 encode_mb(s);
1435 d= get_bit_count(&s->pb);
1436 if(d<dmin){
1437 flush_put_bits(&s->pb);
1438 dmin=d;
1439 best_s.mv[0][0][0]= s->mv[0][0][0];
1440 best_s.mv[0][0][1]= s->mv[0][0][1];
1441 best_s.mb_intra= 0;
1442 best_s.pb=s->pb;
1443 best_s.block= s->block;
1444 best=1;
1445 for(i=0; i<6; i++)
1446 best_s.block_last_index[i]= s->block_last_index[i];
1447 }
1448 }
1449 if(mb_type&MB_TYPE_INTRA){
1450 s->mb_intra= 1;
1451 s->mv[0][0][0] = 0;
1452 s->mv[0][0][1] = 0;
1453 init_put_bits(&s->pb, bit_buf[0], 3000, NULL, NULL);
1454 s->block= s->intra_block;
1455
1456 encode_mb(s);
1457 d= get_bit_count(&s->pb);
1458 if(d<dmin){
1459 flush_put_bits(&s->pb);
1460 dmin=d;
1461 best_s.mv[0][0][0]= 0;
1462 best_s.mv[0][0][1]= 0;
1463 best_s.mb_intra= 1;
1464 best_s.pb=s->pb;
1465 best_s.block= s->block;
1466 for(i=0; i<6; i++)
1467 best_s.block_last_index[i]= s->block_last_index[i];
1468 best=0;
1469 }
1470 /* force cleaning of ac/dc if needed ... */
1471 s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
1472 }
1473 s->mv[0][0][0]= best_s.mv[0][0][0];
1474 s->mv[0][0][1]= best_s.mv[0][0][1];
1475 s->mb_intra= best_s.mb_intra;
1476 for(i=0; i<6; i++)
1477 s->block_last_index[i]= best_s.block_last_index[i];
1478 copy_bits(&pb, bit_buf[best], dmin);
1479 s->block= best_s.block;
1480 s->pb= pb;
1312 } else { 1481 } else {
1313 s->mb_intra = 1; 1482 // only one MB-Type possible
1483 if(mb_type&MB_TYPE_INTRA){
1484 s->mb_intra= 1;
1485 s->mv[0][0][0] = 0;
1486 s->mv[0][0][1] = 0;
1487 }else{
1488 s->mb_intra= 0;
1489 s->mv[0][0][0] = s->mv_table[0][mb_y * s->mb_width + mb_x];
1490 s->mv[0][0][1] = s->mv_table[1][mb_y * s->mb_width + mb_x];
1491 }
1492 encode_mb(s);
1314 } 1493 }
1315 #endif
1316
1317 s->mb_intra = s->mb_type[mb_y * s->mb_width + mb_x];
1318 motion_x = s->mv_table[0][mb_y * s->mb_width + mb_x];
1319 motion_y = s->mv_table[1][mb_y * s->mb_width + mb_x];
1320
1321 /* get the pixels */
1322 wrap = s->linesize;
1323 ptr = s->new_picture[0] + (mb_y * 16 * wrap) + mb_x * 16;
1324 get_pixels(s->block[0], ptr, wrap);
1325 get_pixels(s->block[1], ptr + 8, wrap);
1326 get_pixels(s->block[2], ptr + 8 * wrap, wrap);
1327 get_pixels(s->block[3], ptr + 8 * wrap + 8, wrap);
1328 wrap = s->linesize >> 1;
1329 ptr = s->new_picture[1] + (mb_y * 8 * wrap) + mb_x * 8;
1330 get_pixels(s->block[4], ptr, wrap);
1331
1332 wrap = s->linesize >> 1;
1333 ptr = s->new_picture[2] + (mb_y * 8 * wrap) + mb_x * 8;
1334 get_pixels(s->block[5], ptr, wrap);
1335
1336 /* subtract previous frame if non intra */
1337 if (!s->mb_intra) {
1338 int dxy, offset, mx, my;
1339
1340 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1341 ptr = s->last_picture[0] +
1342 ((mb_y * 16 + (motion_y >> 1)) * s->linesize) +
1343 (mb_x * 16 + (motion_x >> 1));
1344
1345 sub_pixels_2(s->block[0], ptr, s->linesize, dxy);
1346 sub_pixels_2(s->block[1], ptr + 8, s->linesize, dxy);
1347 sub_pixels_2(s->block[2], ptr + s->linesize * 8, s->linesize, dxy);
1348 sub_pixels_2(s->block[3], ptr + 8 + s->linesize * 8, s->linesize ,dxy);
1349
1350 if (s->out_format == FMT_H263) {
1351 /* special rounding for h263 */
1352 dxy = 0;
1353 if ((motion_x & 3) != 0)
1354 dxy |= 1;
1355 if ((motion_y & 3) != 0)
1356 dxy |= 2;
1357 mx = motion_x >> 2;
1358 my = motion_y >> 2;
1359 } else {
1360 mx = motion_x / 2;
1361 my = motion_y / 2;
1362 dxy = ((my & 1) << 1) | (mx & 1);
1363 mx >>= 1;
1364 my >>= 1;
1365 }
1366 offset = ((mb_y * 8 + my) * (s->linesize >> 1)) + (mb_x * 8 + mx);
1367 ptr = s->last_picture[1] + offset;
1368 sub_pixels_2(s->block[4], ptr, s->linesize >> 1, dxy);
1369 ptr = s->last_picture[2] + offset;
1370 sub_pixels_2(s->block[5], ptr, s->linesize >> 1, dxy);
1371 }
1372 emms_c();
1373
1374 #if 0
1375 {
1376 float adap_parm;
1377
1378 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
1379 ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
1380
1381 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d",
1382 (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P',
1383 s->qscale, adap_parm, s->qscale*adap_parm,
1384 s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
1385 }
1386 #endif
1387 /* DCT & quantize */
1388 if (s->h263_msmpeg4) {
1389 msmpeg4_dc_scale(s);
1390 } else if (s->h263_pred) {
1391 h263_dc_scale(s);
1392 } else {
1393 /* default quantization values */
1394 s->y_dc_scale = 8;
1395 s->c_dc_scale = 8;
1396 }
1397 for(i=0;i<6;i++) {
1398 s->block_last_index[i] = dct_quantize(s, s->block[i], i, s->qscale);
1399 }
1400
1401 /* huffman encode */
1402 switch(s->out_format) {
1403 case FMT_MPEG1:
1404 mpeg1_encode_mb(s, s->block, motion_x, motion_y);
1405 break;
1406 case FMT_H263:
1407 if (s->h263_msmpeg4)
1408 msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
1409 else if(s->h263_pred)
1410 mpeg4_encode_mb(s, s->block, motion_x, motion_y);
1411 else
1412 h263_encode_mb(s, s->block, motion_x, motion_y);
1413 break;
1414 case FMT_MJPEG:
1415 mjpeg_encode_mb(s, s->block);
1416 break;
1417 }
1418
1419 /* decompress blocks so that we keep the state of the decoder */
1420 s->mv[0][0][0] = motion_x;
1421 s->mv[0][0][1] = motion_y;
1422 1494
1423 MPV_decode_mb(s, s->block); 1495 MPV_decode_mb(s, s->block);
1424 } 1496 }
1425 1497
1426 1498
1435 //fprintf(stderr, "\nMB line: %d\tSize: %u\tAvg. Size: %u", s->mb_y, 1507 //fprintf(stderr, "\nMB line: %d\tSize: %u\tAvg. Size: %u", s->mb_y,
1436 // (s->pb.buf_ptr - s->ptr_last_mb_line), s->mb_line_avgsize); 1508 // (s->pb.buf_ptr - s->ptr_last_mb_line), s->mb_line_avgsize);
1437 s->first_gob_line = 0; 1509 s->first_gob_line = 0;
1438 } 1510 }
1439 } 1511 }
1512 emms_c();
1440 1513
1441 if (s->h263_msmpeg4 && s->pict_type == I_TYPE) 1514 if (s->h263_msmpeg4 && s->pict_type == I_TYPE)
1442 msmpeg4_encode_ext_header(s); 1515 msmpeg4_encode_ext_header(s);
1443 1516
1444 //if (s->gob_number) 1517 //if (s->gob_number)
1452 if (s->rtp_callback) 1525 if (s->rtp_callback)
1453 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number); 1526 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
1454 s->ptr_lastgob = pbBufPtr(&s->pb); 1527 s->ptr_lastgob = pbBufPtr(&s->pb);
1455 //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif); 1528 //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
1456 } 1529 }
1457
1458 } 1530 }
1459 1531
1460 static int dct_quantize_c(MpegEncContext *s, 1532 static int dct_quantize_c(MpegEncContext *s,
1461 DCTELEM *block, int n, 1533 DCTELEM *block, int n,
1462 int qscale) 1534 int qscale)