Mercurial > libavcodec.hg

comparison h263.c @ 21:20e680e7a490 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
get_bits() specialization, gives 4\speedup
author arpi_esp
date Sat, 04 Aug 2001 00:46:50 +0000
parents 1d3ac9654178
children 8e2d8dbf89a5
comparison
equal deleted inserted replaced
20:907b67420d84 21:20e680e7a490
727 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; 727 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
728 INT16 *mot_val; 728 INT16 *mot_val;
729 static UINT8 quant_tab[4] = { -1, -2, 1, 2 }; 729 static UINT8 quant_tab[4] = { -1, -2, 1, 2 };
730 730
731 if (s->pict_type == P_TYPE) { 731 if (s->pict_type == P_TYPE) {
732 if (get_bits(&s->gb, 1)) { 732 if (get_bits1(&s->gb)) {
733 /* skip mb */ 733 /* skip mb */
734 s->mb_intra = 0; 734 s->mb_intra = 0;
735 for(i=0;i<6;i++) 735 for(i=0;i<6;i++)
736 s->block_last_index[i] = -1; 736 s->block_last_index[i] = -1;
737 s->mv_dir = MV_DIR_FORWARD; 737 s->mv_dir = MV_DIR_FORWARD;
794 } 794 }
795 } 795 }
796 } else { 796 } else {
797 s->ac_pred = 0; 797 s->ac_pred = 0;
798 if (s->h263_pred) { 798 if (s->h263_pred) {
799 s->ac_pred = get_bits(&s->gb, 1); 799 s->ac_pred = get_bits1(&s->gb);
800 } 800 }
801 cbpy = get_vlc(&s->gb, &cbpy_vlc); 801 cbpy = get_vlc(&s->gb, &cbpy_vlc);
802 cbp = (cbpc & 3) | (cbpy << 2); 802 cbp = (cbpc & 3) | (cbpy << 2);
803 if (dquant) { 803 if (dquant) {
804 s->qscale += quant_tab[get_bits(&s->gb, 2)]; 804 s->qscale += quant_tab[get_bits(&s->gb, 2)];
832 if (code < 0) 832 if (code < 0)
833 return 0xffff; 833 return 0xffff;
834 834
835 if (code == 0) 835 if (code == 0)
836 return pred; 836 return pred;
837 sign = get_bits(&s->gb, 1); 837 sign = get_bits1(&s->gb);
838 shift = s->f_code - 1; 838 shift = s->f_code - 1;
839 val = (code - 1) << shift; 839 val = (code - 1) << shift;
840 if (shift > 0) 840 if (shift > 0)
841 val |= get_bits(&s->gb, shift); 841 val |= get_bits(&s->gb, shift);
842 val++; 842 val++;
904 code = get_vlc(&s->gb, &rl->vlc); 904 code = get_vlc(&s->gb, &rl->vlc);
905 if (code < 0) 905 if (code < 0)
906 return -1; 906 return -1;
907 if (code == rl->n) { 907 if (code == rl->n) {
908 /* escape */ 908 /* escape */
909 last = get_bits(&s->gb, 1); 909 last = get_bits1(&s->gb);
910 run = get_bits(&s->gb, 6); 910 run = get_bits(&s->gb, 6);
911 level = (INT8)get_bits(&s->gb, 8); 911 level = (INT8)get_bits(&s->gb, 8);
912 if (s->h263_rv10 && level == -128) { 912 if (s->h263_rv10 && level == -128) {
913 /* XXX: should patch encoder too */ 913 /* XXX: should patch encoder too */
914 level = get_bits(&s->gb, 12); 914 level = get_bits(&s->gb, 12);
916 } 916 }
917 } else { 917 } else {
918 run = rl->table_run[code]; 918 run = rl->table_run[code];
919 level = rl->table_level[code]; 919 level = rl->table_level[code];
920 last = code >= rl->last; 920 last = code >= rl->last;
921 if (get_bits(&s->gb, 1)) 921 if (get_bits1(&s->gb))
922 level = -level; 922 level = -level;
923 } 923 }
924 i += run; 924 i += run;
925 if (i >= 64) 925 if (i >= 64)
926 return -1; 926 return -1;
950 } else { 950 } else {
951 level = get_bits(&s->gb, code); 951 level = get_bits(&s->gb, code);
952 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/ 952 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
953 level = - (level ^ ((1 << code) - 1)); 953 level = - (level ^ ((1 << code) - 1));
954 if (code > 8) 954 if (code > 8)
955 get_bits(&s->gb, 1); /* marker */ 955 skip_bits1(&s->gb); /* marker */
956 } 956 }
957 957
958 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr); 958 pred = mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
959 level += pred; 959 level += pred;
960 if (level < 0) 960 if (level < 0)
1007 code = get_vlc(&s->gb, &rl->vlc); 1007 code = get_vlc(&s->gb, &rl->vlc);
1008 if (code < 0) 1008 if (code < 0)
1009 return -1; 1009 return -1;
1010 if (code == rl->n) { 1010 if (code == rl->n) {
1011 /* escape */ 1011 /* escape */
1012 if (get_bits(&s->gb, 1) != 0) { 1012 if (get_bits1(&s->gb) != 0) {
1013 if (get_bits(&s->gb, 1) != 0) { 1013 if (get_bits1(&s->gb) != 0) {
1014 /* third escape */ 1014 /* third escape */
1015 last = get_bits(&s->gb, 1); 1015 last = get_bits1(&s->gb);
1016 run = get_bits(&s->gb, 6); 1016 run = get_bits(&s->gb, 6);
1017 get_bits(&s->gb, 1); /* marker */ 1017 get_bits1(&s->gb); /* marker */
1018 level = get_bits(&s->gb, 12); 1018 level = get_bits(&s->gb, 12);
1019 level = (level << 20) >> 20; /* sign extend */ 1019 level = (level << 20) >> 20; /* sign extend */
1020 get_bits(&s->gb, 1); /* marker */ 1020 skip_bits1(&s->gb); /* marker */
1021 } else { 1021 } else {
1022 /* second escape */ 1022 /* second escape */
1023 code = get_vlc(&s->gb, &rl->vlc); 1023 code = get_vlc(&s->gb, &rl->vlc);
1024 if (code < 0 || code >= rl->n) 1024 if (code < 0 || code >= rl->n)
1025 return -1; 1025 return -1;
1026 run = rl->table_run[code]; 1026 run = rl->table_run[code];
1027 level = rl->table_level[code]; 1027 level = rl->table_level[code];
1028 last = code >= rl->last; 1028 last = code >= rl->last;
1029 run += rl->max_run[last][level] + 1; 1029 run += rl->max_run[last][level] + 1;
1030 if (get_bits(&s->gb, 1)) 1030 if (get_bits1(&s->gb))
1031 level = -level; 1031 level = -level;
1032 } 1032 }
1033 } else { 1033 } else {
1034 /* first escape */ 1034 /* first escape */
1035 code = get_vlc(&s->gb, &rl->vlc); 1035 code = get_vlc(&s->gb, &rl->vlc);
1037 return -1; 1037 return -1;
1038 run = rl->table_run[code]; 1038 run = rl->table_run[code];
1039 level = rl->table_level[code]; 1039 level = rl->table_level[code];
1040 last = code >= rl->last; 1040 last = code >= rl->last;
1041 level += rl->max_level[last][run]; 1041 level += rl->max_level[last][run];
1042 if (get_bits(&s->gb, 1)) 1042 if (get_bits1(&s->gb))
1043 level = -level; 1043 level = -level;
1044 } 1044 }
1045 } else { 1045 } else {
1046 run = rl->table_run[code]; 1046 run = rl->table_run[code];
1047 level = rl->table_level[code]; 1047 level = rl->table_level[code];
1048 last = code >= rl->last; 1048 last = code >= rl->last;
1049 if (get_bits(&s->gb, 1)) 1049 if (get_bits1(&s->gb))
1050 level = -level; 1050 level = -level;
1051 } 1051 }
1052 i += run; 1052 i += run;
1053 if (i >= 64) 1053 if (i >= 64)
1054 return -1; 1054 return -1;
1075 int format, width, height; 1075 int format, width, height;
1076 1076
1077 /* picture header */ 1077 /* picture header */
1078 if (get_bits(&s->gb, 22) != 0x20) 1078 if (get_bits(&s->gb, 22) != 0x20)
1079 return -1; 1079 return -1;
1080 get_bits(&s->gb, 8); /* picture timestamp */ 1080 skip_bits(&s->gb, 8); /* picture timestamp */
1081 1081
1082 if (get_bits(&s->gb, 1) != 1) 1082 if (get_bits1(&s->gb) != 1)
1083 return -1; /* marker */ 1083 return -1; /* marker */
1084 if (get_bits(&s->gb, 1) != 0) 1084 if (get_bits1(&s->gb) != 0)
1085 return -1; /* h263 id */ 1085 return -1; /* h263 id */
1086 get_bits(&s->gb, 1); /* split screen off */ 1086 skip_bits1(&s->gb); /* split screen off */
1087 get_bits(&s->gb, 1); /* camera off */ 1087 skip_bits1(&s->gb); /* camera off */
1088 get_bits(&s->gb, 1); /* freeze picture release off */ 1088 skip_bits1(&s->gb); /* freeze picture release off */
1089 1089
1090 format = get_bits(&s->gb, 3); 1090 format = get_bits(&s->gb, 3);
1091 1091
1092 if (format != 7) { 1092 if (format != 7) {
1093 s->h263_plus = 0; 1093 s->h263_plus = 0;
1095 width = h263_format[format][0]; 1095 width = h263_format[format][0];
1096 height = h263_format[format][1]; 1096 height = h263_format[format][1];
1097 if (!width) 1097 if (!width)
1098 return -1; 1098 return -1;
1099 1099
1100 s->pict_type = I_TYPE + get_bits(&s->gb, 1); 1100 s->pict_type = I_TYPE + get_bits1(&s->gb);
1101 1101
1102 s->unrestricted_mv = get_bits(&s->gb, 1); 1102 s->unrestricted_mv = get_bits1(&s->gb);
1103 s->h263_long_vectors = s->unrestricted_mv; 1103 s->h263_long_vectors = s->unrestricted_mv;
1104 1104
1105 if (get_bits(&s->gb, 1) != 0) 1105 if (get_bits1(&s->gb) != 0)
1106 return -1; /* SAC: off */ 1106 return -1; /* SAC: off */
1107 if (get_bits(&s->gb, 1) != 0) 1107 if (get_bits1(&s->gb) != 0)
1108 return -1; /* advanced prediction mode: off */ 1108 return -1; /* advanced prediction mode: off */
1109 if (get_bits(&s->gb, 1) != 0) 1109 if (get_bits1(&s->gb) != 0)
1110 return -1; /* not PB frame */ 1110 return -1; /* not PB frame */
1111 1111
1112 s->qscale = get_bits(&s->gb, 5); 1112 s->qscale = get_bits(&s->gb, 5);
1113 get_bits(&s->gb, 1); /* Continuous Presence Multipoint mode: off */ 1113 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1114 } else { 1114 } else {
1115 s->h263_plus = 1; 1115 s->h263_plus = 1;
1116 /* H.263v2 */ 1116 /* H.263v2 */
1117 if (get_bits(&s->gb, 3) != 1) 1117 if (get_bits(&s->gb, 3) != 1)
1118 return -1; 1118 return -1;
1119 if (get_bits(&s->gb, 3) != 6) /* custom source format */ 1119 if (get_bits(&s->gb, 3) != 6) /* custom source format */
1120 return -1; 1120 return -1;
1121 get_bits(&s->gb, 12); 1121 skip_bits(&s->gb, 12);
1122 get_bits(&s->gb, 3); 1122 skip_bits(&s->gb, 3);
1123 s->pict_type = get_bits(&s->gb, 3) + 1; 1123 s->pict_type = get_bits(&s->gb, 3) + 1;
1124 if (s->pict_type != I_TYPE && 1124 if (s->pict_type != I_TYPE &&
1125 s->pict_type != P_TYPE) 1125 s->pict_type != P_TYPE)
1126 return -1; 1126 return -1;
1127 get_bits(&s->gb, 7); 1127 skip_bits(&s->gb, 7);
1128 get_bits(&s->gb, 4); /* aspect ratio */ 1128 skip_bits(&s->gb, 4); /* aspect ratio */
1129 width = (get_bits(&s->gb, 9) + 1) * 4; 1129 width = (get_bits(&s->gb, 9) + 1) * 4;
1130 get_bits(&s->gb, 1); 1130 skip_bits1(&s->gb);
1131 height = get_bits(&s->gb, 9) * 4; 1131 height = get_bits(&s->gb, 9) * 4;
1132 if (height == 0) 1132 if (height == 0)
1133 return -1; 1133 return -1;
1134 s->qscale = get_bits(&s->gb, 5); 1134 s->qscale = get_bits(&s->gb, 5);
1135 } 1135 }
1136 /* PEI */ 1136 /* PEI */
1137 while (get_bits(&s->gb, 1) != 0) { 1137 while (get_bits1(&s->gb) != 0) {
1138 get_bits(&s->gb, 8); 1138 skip_bits(&s->gb, 8);
1139 } 1139 }
1140 s->f_code = 1; 1140 s->f_code = 1;
1141 s->width = width; 1141 s->width = width;
1142 s->height = height; 1142 s->height = height;
1143 return 0; 1143 return 0;
1167 1167
1168 if (startcode == 0x120) { 1168 if (startcode == 0x120) {
1169 int time_increment_resolution, width, height; 1169 int time_increment_resolution, width, height;
1170 1170
1171 /* vol header */ 1171 /* vol header */
1172 get_bits(&s->gb, 1); /* random access */ 1172 skip_bits(&s->gb, 1); /* random access */
1173 get_bits(&s->gb, 8); /* vo_type */ 1173 skip_bits(&s->gb, 8); /* vo_type */
1174 get_bits(&s->gb, 1); /* is_ol_id */ 1174 skip_bits(&s->gb, 1); /* is_ol_id */
1175 get_bits(&s->gb, 4); /* vo_ver_id */ 1175 skip_bits(&s->gb, 4); /* vo_ver_id */
1176 get_bits(&s->gb, 3); /* vo_priority */ 1176 skip_bits(&s->gb, 3); /* vo_priority */
1177 1177
1178 get_bits(&s->gb, 4); /* aspect_ratio_info */ 1178 skip_bits(&s->gb, 4); /* aspect_ratio_info */
1179 get_bits(&s->gb, 1); /* vol control parameter */ 1179 skip_bits(&s->gb, 1); /* vol control parameter */
1180 get_bits(&s->gb, 2); /* vol shape */ 1180 skip_bits(&s->gb, 2); /* vol shape */
1181 get_bits(&s->gb, 1); /* marker */ 1181 skip_bits1(&s->gb); /* marker */
1182 1182
1183 time_increment_resolution = get_bits(&s->gb, 16); 1183 time_increment_resolution = get_bits(&s->gb, 16);
1184 s->time_increment_bits = log2(time_increment_resolution - 1) + 1; 1184 s->time_increment_bits = log2(time_increment_resolution - 1) + 1;
1185 get_bits(&s->gb, 1); /* marker */ 1185 skip_bits1(&s->gb); /* marker */
1186 1186
1187 get_bits(&s->gb, 1); /* vop rate */ 1187 skip_bits1(&s->gb); /* vop rate */
1188 get_bits(&s->gb, s->time_increment_bits); 1188 skip_bits(&s->gb, s->time_increment_bits);
1189 get_bits(&s->gb, 1); /* marker */ 1189 skip_bits1(&s->gb); /* marker */
1190 1190
1191 width = get_bits(&s->gb, 13); 1191 width = get_bits(&s->gb, 13);
1192 get_bits(&s->gb, 1); /* marker */ 1192 skip_bits1(&s->gb); /* marker */
1193 height = get_bits(&s->gb, 13); 1193 height = get_bits(&s->gb, 13);
1194 get_bits(&s->gb, 1); /* marker */ 1194 skip_bits1(&s->gb); /* marker */
1195 1195
1196 get_bits(&s->gb, 1); /* interfaced */ 1196 skip_bits1(&s->gb); /* interfaced */
1197 get_bits(&s->gb, 1); /* OBMC */ 1197 skip_bits1(&s->gb); /* OBMC */
1198 get_bits(&s->gb, 2); /* vol_sprite_usage */ 1198 skip_bits(&s->gb, 2); /* vol_sprite_usage */
1199 get_bits(&s->gb, 1); /* not_8_bit */ 1199 skip_bits1(&s->gb); /* not_8_bit */
1200 1200
1201 get_bits(&s->gb, 1); /* vol_quant_type */ 1201 skip_bits1(&s->gb); /* vol_quant_type */
1202 get_bits(&s->gb, 1); /* vol_quarter_pixel */ 1202 skip_bits1(&s->gb); /* vol_quarter_pixel */
1203 get_bits(&s->gb, 1); /* complexity_estimation_disabled */ 1203 skip_bits1(&s->gb); /* complexity_estimation_disabled */
1204 get_bits(&s->gb, 1); /* resync_marker_disabled */ 1204 skip_bits1(&s->gb); /* resync_marker_disabled */
1205 get_bits(&s->gb, 1); /* data_partioning_enabled */ 1205 skip_bits1(&s->gb); /* data_partioning_enabled */
1206 goto redo; 1206 goto redo;
1207 } else if (startcode != 0x1b6) { 1207 } else if (startcode != 0x1b6) {
1208 goto redo; 1208 goto redo;
1209 } 1209 }
1210 1210
1213 s->pict_type != P_TYPE) 1213 s->pict_type != P_TYPE)
1214 return -1; 1214 return -1;
1215 1215
1216 /* XXX: parse time base */ 1216 /* XXX: parse time base */
1217 time_incr = 0; 1217 time_incr = 0;
1218 while (get_bits(&s->gb, 1) != 0) 1218 while (get_bits1(&s->gb) != 0)
1219 time_incr++; 1219 time_incr++;
1220 1220
1221 get_bits(&s->gb, 1); /* marker */ 1221 skip_bits1(&s->gb); /* marker */
1222 get_bits(&s->gb, s->time_increment_bits); 1222 skip_bits(&s->gb, s->time_increment_bits);
1223 get_bits(&s->gb, 1); /* marker */ 1223 skip_bits1(&s->gb); /* marker */
1224 /* vop coded */ 1224 /* vop coded */
1225 if (get_bits(&s->gb, 1) != 1) 1225 if (get_bits1(&s->gb) != 1)
1226 return -1; 1226 return -1;
1227 1227
1228 if (s->pict_type == P_TYPE) { 1228 if (s->pict_type == P_TYPE) {
1229 /* rounding type for motion estimation */ 1229 /* rounding type for motion estimation */
1230 s->no_rounding = get_bits(&s->gb, 1); 1230 s->no_rounding = get_bits1(&s->gb);
1231 } 1231 }
1232 1232
1233 if (get_bits(&s->gb, 3) != 0) 1233 if (get_bits(&s->gb, 3) != 0)
1234 return -1; /* intra dc VLC threshold */ 1234 return -1; /* intra dc VLC threshold */
1235 1235
1247 int format; 1247 int format;
1248 1248
1249 /* picture header */ 1249 /* picture header */
1250 if (get_bits(&s->gb, 22) != 0x20) 1250 if (get_bits(&s->gb, 22) != 0x20)
1251 return -1; 1251 return -1;
1252 get_bits(&s->gb, 8); /* picture timestamp */ 1252 skip_bits(&s->gb, 8); /* picture timestamp */
1253 1253
1254 if (get_bits(&s->gb, 1) != 1) 1254 if (get_bits1(&s->gb) != 1)
1255 return -1; /* marker */ 1255 return -1; /* marker */
1256 if (get_bits(&s->gb, 1) != 0) 1256 if (get_bits1(&s->gb) != 0)
1257 return -1; /* h263 id */ 1257 return -1; /* h263 id */
1258 get_bits(&s->gb, 1); /* split screen off */ 1258 skip_bits1(&s->gb); /* split screen off */
1259 get_bits(&s->gb, 1); /* camera off */ 1259 skip_bits1(&s->gb); /* camera off */
1260 get_bits(&s->gb, 1); /* freeze picture release off */ 1260 skip_bits1(&s->gb); /* freeze picture release off */
1261 1261
1262 format = get_bits(&s->gb, 3); 1262 format = get_bits(&s->gb, 3);
1263 if (format != 7) 1263 if (format != 7)
1264 return -1; 1264 return -1;
1265 1265
1266 s->h263_plus = 0; 1266 s->h263_plus = 0;
1267 1267
1268 s->pict_type = I_TYPE + get_bits(&s->gb, 1); 1268 s->pict_type = I_TYPE + get_bits1(&s->gb);
1269 1269
1270 s->unrestricted_mv = get_bits(&s->gb, 1); 1270 s->unrestricted_mv = get_bits1(&s->gb);
1271 s->h263_long_vectors = s->unrestricted_mv; 1271 s->h263_long_vectors = s->unrestricted_mv;
1272 1272
1273 if (get_bits(&s->gb, 1) != 0) 1273 if (get_bits1(&s->gb) != 0)
1274 return -1; /* SAC: off */ 1274 return -1; /* SAC: off */
1275 if (get_bits(&s->gb, 1) != 0) 1275 if (get_bits1(&s->gb) != 0)
1276 return -1; /* advanced prediction mode: off */ 1276 return -1; /* advanced prediction mode: off */
1277 if (get_bits(&s->gb, 1) != 0) 1277 if (get_bits1(&s->gb) != 0)
1278 return -1; /* not PB frame */ 1278 return -1; /* not PB frame */
1279 1279
1280 /* skip unknown header garbage */ 1280 /* skip unknown header garbage */
1281 get_bits(&s->gb, 41); 1281 skip_bits(&s->gb, 41);
1282 1282
1283 s->qscale = get_bits(&s->gb, 5); 1283 s->qscale = get_bits(&s->gb, 5);
1284 get_bits(&s->gb, 1); /* Continuous Presence Multipoint mode: off */ 1284 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
1285 1285
1286 /* PEI */ 1286 /* PEI */
1287 while (get_bits(&s->gb, 1) != 0) { 1287 while (get_bits1(&s->gb) != 0) {
1288 get_bits(&s->gb, 8); 1288 skip_bits(&s->gb, 8);
1289 } 1289 }
1290 s->f_code = 1; 1290 s->f_code = 1;
1291 return 0; 1291 return 0;
1292 } 1292 }