Mercurial > libavcodec.hg

comparison mjpeg.c @ 1359:4c2febfefd78 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
cleanup
author michaelni
date Sat, 12 Jul 2003 20:21:34 +0000
parents a6b92de6a9fc
children e68194195c92
comparison
equal deleted inserted replaced
1358:a6b92de6a9fc 1359:4c2febfefd78
819 int rct; /* standard rct */ 819 int rct; /* standard rct */
820 int pegasus_rct; /* pegasus reversible colorspace transform */ 820 int pegasus_rct; /* pegasus reversible colorspace transform */
821 int bits; /* bits per component */ 821 int bits; /* bits per component */
822 822
823 int width, height; 823 int width, height;
824 int mb_width, mb_height;
824 int nb_components; 825 int nb_components;
825 int component_id[MAX_COMPONENTS]; 826 int component_id[MAX_COMPONENTS];
826 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */ 827 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
827 int v_count[MAX_COMPONENTS]; 828 int v_count[MAX_COMPONENTS];
829 int comp_index[MAX_COMPONENTS];
830 int dc_index[MAX_COMPONENTS];
831 int ac_index[MAX_COMPONENTS];
832 int nb_blocks[MAX_COMPONENTS];
833 int h_scount[MAX_COMPONENTS];
834 int v_scount[MAX_COMPONENTS];
828 int h_max, v_max; /* maximum h and v counts */ 835 int h_max, v_max; /* maximum h and v counts */
829 int quant_index[4]; /* quant table index for each component */ 836 int quant_index[4]; /* quant table index for each component */
830 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */ 837 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
831 uint8_t *current_picture[MAX_COMPONENTS]; /* picture structure */ 838 uint8_t *current_picture[MAX_COMPONENTS]; /* picture structure */
832 int linesize[MAX_COMPONENTS]; 839 int linesize[MAX_COMPONENTS];
1153 } 1160 }
1154 } 1161 }
1155 return 0; 1162 return 0;
1156 } 1163 }
1157 1164
1165 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1166 int i, mb_x, mb_y;
1167 uint16_t buffer[2048][4];
1168 int left[3], top[3], topleft[3];
1169 const int linesize= s->linesize[0];
1170 const int mask= (1<<s->bits)-1;
1171
1172 for(i=0; i<3; i++){
1173 buffer[0][i]= 1 << (s->bits + point_transform - 1);
1174 }
1175 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1176 const int modified_predictor= mb_y ? 1 : predictor;
1177 uint8_t *ptr = s->current_picture[0] + (linesize * mb_y);
1178
1179 if (s->interlaced && s->bottom_field)
1180 ptr += linesize >> 1;
1181
1182 for(i=0; i<3; i++){
1183 top[i]= left[i]= topleft[i]= buffer[0][i];
1184 }
1185 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1186 if (s->restart_interval && !s->restart_count)
1187 s->restart_count = s->restart_interval;
1188
1189 for(i=0;i<3;i++) {
1190 int pred;
1191
1192 topleft[i]= top[i];
1193 top[i]= buffer[mb_x][i];
1194
1195 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1196
1197 left[i]=
1198 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1199 }
1200
1201 if (s->restart_interval && !--s->restart_count) {
1202 align_get_bits(&s->gb);
1203 skip_bits(&s->gb, 16); /* skip RSTn */
1204 }
1205 }
1206
1207 if(s->rct){
1208 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1209 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1210 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1211 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1212 }
1213 }else if(s->pegasus_rct){
1214 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1215 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1216 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1217 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1218 }
1219 }else{
1220 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1221 ptr[4*mb_x+0] = buffer[mb_x][0];
1222 ptr[4*mb_x+1] = buffer[mb_x][1];
1223 ptr[4*mb_x+2] = buffer[mb_x][2];
1224 }
1225 }
1226 }
1227 return 0;
1228 }
1229
1230 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1231 int i, mb_x, mb_y;
1232 const int nb_components=3;
1233
1234 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1235 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1236 if (s->restart_interval && !s->restart_count)
1237 s->restart_count = s->restart_interval;
1238
1239 if(mb_x==0 || mb_y==0 || s->interlaced){
1240 for(i=0;i<nb_components;i++) {
1241 uint8_t *ptr;
1242 int n, h, v, x, y, c, j, linesize;
1243 n = s->nb_blocks[i];
1244 c = s->comp_index[i];
1245 h = s->h_scount[i];
1246 v = s->v_scount[i];
1247 x = 0;
1248 y = 0;
1249 linesize= s->linesize[c];
1250
1251 for(j=0; j<n; j++) {
1252 int pred;
1253
1254 ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1255 if(y==0 && mb_y==0){
1256 if(x==0 && mb_x==0){
1257 pred= 128 << point_transform;
1258 }else{
1259 pred= ptr[-1];
1260 }
1261 }else{
1262 if(x==0 && mb_x==0){
1263 pred= ptr[-linesize];
1264 }else{
1265 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1266 }
1267 }
1268
1269 if (s->interlaced && s->bottom_field)
1270 ptr += linesize >> 1;
1271 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1272
1273 if (++x == h) {
1274 x = 0;
1275 y++;
1276 }
1277 }
1278 }
1279 }else{
1280 for(i=0;i<nb_components;i++) {
1281 uint8_t *ptr;
1282 int n, h, v, x, y, c, j, linesize;
1283 n = s->nb_blocks[i];
1284 c = s->comp_index[i];
1285 h = s->h_scount[i];
1286 v = s->v_scount[i];
1287 x = 0;
1288 y = 0;
1289 linesize= s->linesize[c];
1290
1291 for(j=0; j<n; j++) {
1292 int pred;
1293
1294 ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1295 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1296 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1297 if (++x == h) {
1298 x = 0;
1299 y++;
1300 }
1301 }
1302 }
1303 }
1304 if (s->restart_interval && !--s->restart_count) {
1305 align_get_bits(&s->gb);
1306 skip_bits(&s->gb, 16); /* skip RSTn */
1307 }
1308 }
1309 }
1310 return 0;
1311 }
1312
1313 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1314 int i, mb_x, mb_y;
1315 const int nb_components=3;
1316
1317 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1318 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1319 if (s->restart_interval && !s->restart_count)
1320 s->restart_count = s->restart_interval;
1321
1322 for(i=0;i<nb_components;i++) {
1323 uint8_t *ptr;
1324 int n, h, v, x, y, c, j;
1325 n = s->nb_blocks[i];
1326 c = s->comp_index[i];
1327 h = s->h_scount[i];
1328 v = s->v_scount[i];
1329 x = 0;
1330 y = 0;
1331 for(j=0;j<n;j++) {
1332 memset(s->block, 0, sizeof(s->block));
1333 if (decode_block(s, s->block, i,
1334 s->dc_index[i], s->ac_index[i],
1335 s->quant_index[c]) < 0) {
1336 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1337 return -1;
1338 }
1339 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1340 ptr = s->current_picture[c] +
1341 (s->linesize[c] * (v * mb_y + y) * 8) +
1342 (h * mb_x + x) * 8;
1343 if (s->interlaced && s->bottom_field)
1344 ptr += s->linesize[c] >> 1;
1345 s->idct_put(ptr, s->linesize[c], s->block);
1346 if (++x == h) {
1347 x = 0;
1348 y++;
1349 }
1350 }
1351 }
1352 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1353 if (s->restart_interval && (s->restart_interval < 1350) &&
1354 !--s->restart_count) {
1355 align_get_bits(&s->gb);
1356 skip_bits(&s->gb, 16); /* skip RSTn */
1357 for (i=0; i<nb_components; i++) /* reset dc */
1358 s->last_dc[i] = 1024;
1359 }
1360 }
1361 }
1362 return 0;
1363 }
1364
1158 static int mjpeg_decode_sos(MJpegDecodeContext *s) 1365 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1159 { 1366 {
1160 int len, nb_components, i, j, n, h, v, ret, point_transform, predictor; 1367 int len, nb_components, i, h, v, predictor, point_transform, ilv;
1161 int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id; 1368 int vmax, hmax, index, id;
1162 int comp_index[4];
1163 int dc_index[4];
1164 int ac_index[4];
1165 int nb_blocks[4];
1166 int h_count[4];
1167 int v_count[4];
1168 const int block_size= s->lossless ? 1 : 8; 1369 const int block_size= s->lossless ? 1 : 8;
1169 1370
1170 /* XXX: verify len field validity */ 1371 /* XXX: verify len field validity */
1171 len = get_bits(&s->gb, 16); 1372 len = get_bits(&s->gb, 16);
1172 nb_components = get_bits(&s->gb, 8); 1373 nb_components = get_bits(&s->gb, 8);
1194 { 1395 {
1195 dprintf("decode_sos: index(%d) out of components\n", index); 1396 dprintf("decode_sos: index(%d) out of components\n", index);
1196 return -1; 1397 return -1;
1197 } 1398 }
1198 1399
1199 comp_index[i] = index; 1400 s->comp_index[i] = index;
1200 1401
1201 nb_blocks[i] = s->h_count[index] * s->v_count[index]; 1402 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1202 h_count[i] = s->h_count[index]; 1403 s->h_scount[i] = s->h_count[index];
1203 v_count[i] = s->v_count[index]; 1404 s->v_scount[i] = s->v_count[index];
1204 1405
1205 dc_index[i] = get_bits(&s->gb, 4); 1406 s->dc_index[i] = get_bits(&s->gb, 4);
1206 ac_index[i] = get_bits(&s->gb, 4); 1407 s->ac_index[i] = get_bits(&s->gb, 4);
1207 1408
1208 if (dc_index[i] < 0 || ac_index[i] < 0 || 1409 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1209 dc_index[i] >= 4 || ac_index[i] >= 4) 1410 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1210 goto out_of_range; 1411 goto out_of_range;
1412 #if 0 //buggy
1211 switch(s->start_code) 1413 switch(s->start_code)
1212 { 1414 {
1213 case SOF0: 1415 case SOF0:
1214 if (dc_index[i] > 1 || ac_index[i] > 1) 1416 if (dc_index[i] > 1 || ac_index[i] > 1)
1215 goto out_of_range; 1417 goto out_of_range;
1222 case SOF3: 1424 case SOF3:
1223 if (dc_index[i] > 3 || ac_index[i] != 0) 1425 if (dc_index[i] > 3 || ac_index[i] != 0)
1224 goto out_of_range; 1426 goto out_of_range;
1225 break; 1427 break;
1226 } 1428 }
1429 #endif
1227 } 1430 }
1228 1431
1229 predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */ 1432 predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1230 skip_bits(&s->gb, 8); /* Se */ 1433 skip_bits(&s->gb, 8); /* Se */
1231 skip_bits(&s->gb, 4); /* Ah */ 1434 skip_bits(&s->gb, 4); /* Ah */
1234 for(i=0;i<nb_components;i++) 1437 for(i=0;i<nb_components;i++)
1235 s->last_dc[i] = 1024; 1438 s->last_dc[i] = 1024;
1236 1439
1237 if (nb_components > 1) { 1440 if (nb_components > 1) {
1238 /* interleaved stream */ 1441 /* interleaved stream */
1239 mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size); 1442 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1240 mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size); 1443 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1241 } else { 1444 } else {
1242 h = s->h_max / s->h_count[comp_index[0]]; 1445 h = s->h_max / s->h_scount[s->comp_index[0]];
1243 v = s->v_max / s->v_count[comp_index[0]]; 1446 v = s->v_max / s->v_scount[s->comp_index[0]];
1244 mb_width = (s->width + h * block_size - 1) / (h * block_size); 1447 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1245 mb_height = (s->height + v * block_size - 1) / (v * block_size); 1448 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1246 nb_blocks[0] = 1; 1449 s->nb_blocks[0] = 1;
1247 h_count[0] = 1; 1450 s->h_scount[0] = 1;
1248 v_count[0] = 1; 1451 s->v_scount[0] = 1;
1249 } 1452 }
1250 1453
1251 if(s->avctx->debug & FF_DEBUG_PICT_INFO) 1454 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1252 printf("%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform); 1455 printf("%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1253 1456
1254 if(s->lossless){ 1457 if(s->lossless){
1255 if(s->rgb){ 1458 if(s->rgb){
1256 uint16_t buffer[2048][4]; 1459 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1257 int left[3], top[3], topleft[3]; 1460 return -1;
1258 const int linesize= s->linesize[0]; 1461 }else{
1259 const int mask= (1<<s->bits)-1; 1462 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1260 1463 return -1;
1261 for(i=0; i<3; i++){
1262 buffer[0][i]= 1 << (s->bits + point_transform - 1);
1263 } 1464 }
1264 for(mb_y = 0; mb_y < mb_height; mb_y++) {
1265 const int modified_predictor= mb_y ? 1 : predictor;
1266 uint8_t *ptr = s->current_picture[0] + (linesize * mb_y);
1267
1268 if (s->interlaced && s->bottom_field)
1269 ptr += linesize >> 1;
1270
1271 for(i=0; i<3; i++){
1272 top[i]= left[i]= topleft[i]= buffer[0][i];
1273 }
1274 for(mb_x = 0; mb_x < mb_width; mb_x++) {
1275 if (s->restart_interval && !s->restart_count)
1276 s->restart_count = s->restart_interval;
1277
1278 for(i=0;i<3;i++) {
1279 int pred;
1280
1281 topleft[i]= top[i];
1282 top[i]= buffer[mb_x][i];
1283
1284 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1285
1286 left[i]=
1287 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, dc_index[i]) << point_transform));
1288 }
1289
1290 if (s->restart_interval && !--s->restart_count) {
1291 align_get_bits(&s->gb);
1292 skip_bits(&s->gb, 16); /* skip RSTn */
1293 }
1294 }
1295
1296 if(s->rct){
1297 for(mb_x = 0; mb_x < mb_width; mb_x++) {
1298 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1299 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1300 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1301 }
1302 }else if(s->pegasus_rct){
1303 for(mb_x = 0; mb_x < mb_width; mb_x++) {
1304 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1305 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1306 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1307 }
1308 }else{
1309 for(mb_x = 0; mb_x < mb_width; mb_x++) {
1310 ptr[4*mb_x+0] = buffer[mb_x][0];
1311 ptr[4*mb_x+1] = buffer[mb_x][1];
1312 ptr[4*mb_x+2] = buffer[mb_x][2];
1313 }
1314 }
1315 }
1316 }else{
1317 for(mb_y = 0; mb_y < mb_height; mb_y++) {
1318 for(mb_x = 0; mb_x < mb_width; mb_x++) {
1319 if (s->restart_interval && !s->restart_count)
1320 s->restart_count = s->restart_interval;
1321
1322 if(mb_x==0 || mb_y==0 || s->interlaced){
1323 for(i=0;i<nb_components;i++) {
1324 uint8_t *ptr;
1325 int x, y, c, linesize;
1326 n = nb_blocks[i];
1327 c = comp_index[i];
1328 h = h_count[i];
1329 v = v_count[i];
1330 x = 0;
1331 y = 0;
1332 linesize= s->linesize[c];
1333
1334 for(j=0; j<n; j++) {
1335 int pred;
1336
1337 ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1338 if(y==0 && mb_y==0){
1339 if(x==0 && mb_x==0){
1340 pred= 128 << point_transform;
1341 }else{
1342 pred= ptr[-1];
1343 }
1344 }else{
1345 if(x==0 && mb_x==0){
1346 pred= ptr[-linesize];
1347 }else{
1348 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1349 }
1350 }
1351
1352 if (s->interlaced && s->bottom_field)
1353 ptr += linesize >> 1;
1354 *ptr= pred + (mjpeg_decode_dc(s, dc_index[i]) << point_transform);
1355
1356 if (++x == h) {
1357 x = 0;
1358 y++;
1359 }
1360 }
1361 }
1362 }else{
1363 for(i=0;i<nb_components;i++) {
1364 uint8_t *ptr;
1365 int x, y, c, linesize;
1366 n = nb_blocks[i];
1367 c = comp_index[i];
1368 h = h_count[i];
1369 v = v_count[i];
1370 x = 0;
1371 y = 0;
1372 linesize= s->linesize[c];
1373
1374 for(j=0; j<n; j++) {
1375 int pred;
1376
1377 ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1378 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1379 *ptr= pred + (mjpeg_decode_dc(s, dc_index[i]) << point_transform);
1380 if (++x == h) {
1381 x = 0;
1382 y++;
1383 }
1384 }
1385 }
1386 }
1387 if (s->restart_interval && !--s->restart_count) {
1388 align_get_bits(&s->gb);
1389 skip_bits(&s->gb, 16); /* skip RSTn */
1390 }
1391 }
1392 }
1393 }
1394 }else{ 1465 }else{
1395 for(mb_y = 0; mb_y < mb_height; mb_y++) { 1466 if(mjpeg_decode_scan(s) < 0)
1396 for(mb_x = 0; mb_x < mb_width; mb_x++) { 1467 return -1;
1397 if (s->restart_interval && !s->restart_count) 1468 }
1398 s->restart_count = s->restart_interval;
1399
1400 for(i=0;i<nb_components;i++) {
1401 uint8_t *ptr;
1402 int x, y, c;
1403 n = nb_blocks[i];
1404 c = comp_index[i];
1405 h = h_count[i];
1406 v = v_count[i];
1407 x = 0;
1408 y = 0;
1409 for(j=0;j<n;j++) {
1410 memset(s->block, 0, sizeof(s->block));
1411 if (decode_block(s, s->block, i,
1412 dc_index[i], ac_index[i],
1413 s->quant_index[c]) < 0) {
1414 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1415 ret = -1;
1416 goto the_end;
1417 }
1418 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1419 ptr = s->current_picture[c] +
1420 (s->linesize[c] * (v * mb_y + y) * 8) +
1421 (h * mb_x + x) * 8;
1422 if (s->interlaced && s->bottom_field)
1423 ptr += s->linesize[c] >> 1;
1424 s->idct_put(ptr, s->linesize[c], s->block);
1425 if (++x == h) {
1426 x = 0;
1427 y++;
1428 }
1429 }
1430 }
1431 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1432 if (s->restart_interval && (s->restart_interval < 1350) &&
1433 !--s->restart_count) {
1434 align_get_bits(&s->gb);
1435 skip_bits(&s->gb, 16); /* skip RSTn */
1436 for (j=0; j<nb_components; j++) /* reset dc */
1437 s->last_dc[j] = 1024;
1438 }
1439 }
1440 }
1441 }
1442 ret = 0;
1443 the_end:
1444 emms_c(); 1469 emms_c();
1445 return ret; 1470 return 0;
1446 out_of_range: 1471 out_of_range:
1447 dprintf("decode_sos: ac/dc index out of range\n"); 1472 dprintf("decode_sos: ac/dc index out of range\n");
1448 return -1; 1473 return -1;
1449 } 1474 }
1450 1475
2024 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 2049 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2025 picture->qstride= 0; 2050 picture->qstride= 0;
2026 picture->qscale_table= s->qscale_table; 2051 picture->qscale_table= s->qscale_table;
2027 memset(picture->qscale_table, picture->quality, (s->width+15)/16); 2052 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2028 if(avctx->debug & FF_DEBUG_QP) 2053 if(avctx->debug & FF_DEBUG_QP)
2029 printf("QP: %d\n", picture->quality); 2054 printf("QP: %f\n", picture->quality);
2030 } 2055 }
2031 2056
2032 return buf_ptr - buf; 2057 return buf_ptr - buf;
2033 } 2058 }
2034 2059