Mercurial > libavcodec.hg

comparison xan.c @ 1476:72e115e94673 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
MACRO-ize a bunch of redundant code blocks; fix 16-bit RGB modes (it's RGB not RGG)
author tmmm
date Fri, 19 Sep 2003 04:00:32 +0000
parents 618b148f6b76
children 6b224ca24033
comparison
equal deleted inserted replaced
1475:26eb7678cb46 1476:72e115e94673
272 g = *palette_data++; 272 g = *palette_data++;
273 b = *palette_data++; 273 b = *palette_data++;
274 palette16[i] = 274 palette16[i] =
275 ((r >> 3) << 10) | 275 ((r >> 3) << 10) |
276 ((g >> 3) << 5) | 276 ((g >> 3) << 5) |
277 ((g >> 3) << 0); 277 ((b >> 3) << 0);
278 } 278 }
279 break; 279 break;
280 280
281 case PIX_FMT_RGB565: 281 case PIX_FMT_RGB565:
282 palette16 = (unsigned short *)s->palette; 282 palette16 = (unsigned short *)s->palette;
285 g = *palette_data++; 285 g = *palette_data++;
286 b = *palette_data++; 286 b = *palette_data++;
287 palette16[i] = 287 palette16[i] =
288 ((r >> 3) << 11) | 288 ((r >> 3) << 11) |
289 ((g >> 2) << 5) | 289 ((g >> 2) << 5) |
290 ((g >> 3) << 0); 290 ((b >> 3) << 0);
291 } 291 }
292 break; 292 break;
293 293
294 case PIX_FMT_RGB24: 294 case PIX_FMT_RGB24:
295 for (i = 0; i < PALETTE_COUNT; i++) { 295 for (i = 0; i < PALETTE_COUNT; i++) {
335 default: 335 default:
336 printf (" Xan WC3: Unhandled colorspace\n"); 336 printf (" Xan WC3: Unhandled colorspace\n");
337 break; 337 break;
338 } 338 }
339 } 339 }
340
341 /* advance current_x variable; reset accounting variables if current_x
342 * moves beyond width */
343 #define ADVANCE_CURRENT_X() \
344 current_x++; \
345 if (current_x >= width) { \
346 index += line_inc; \
347 current_x = 0; \
348 }
340 349
341 static void inline xan_wc3_output_pixel_run(XanContext *s, 350 static void inline xan_wc3_output_pixel_run(XanContext *s,
342 unsigned char *pixel_buffer, int x, int y, int pixel_count) 351 unsigned char *pixel_buffer, int x, int y, int pixel_count)
343 { 352 {
344 int stride; 353 int stride;
369 378
370 /* don't do a memcpy() here; keyframes generally copy an entire 379 /* don't do a memcpy() here; keyframes generally copy an entire
371 * frame of data and the stride needs to be accounted for */ 380 * frame of data and the stride needs to be accounted for */
372 palette_plane[index++] = *pixel_buffer++; 381 palette_plane[index++] = *pixel_buffer++;
373 382
374 current_x++; 383 ADVANCE_CURRENT_X();
375 if (current_x >= width) {
376 /* reset accounting variables */
377 index += line_inc;
378 current_x = 0;
379 }
380 } 384 }
381 break; 385 break;
382 386
383 case PIX_FMT_RGB555: 387 case PIX_FMT_RGB555:
384 case PIX_FMT_RGB565: 388 case PIX_FMT_RGB565:
390 current_x = x; 394 current_x = x;
391 while(pixel_count--) { 395 while(pixel_count--) {
392 396
393 rgb16_plane[index++] = palette16[*pixel_buffer++]; 397 rgb16_plane[index++] = palette16[*pixel_buffer++];
394 398
395 current_x++; 399 ADVANCE_CURRENT_X();
396 if (current_x >= width) {
397 /* reset accounting variables */
398 index += line_inc;
399 current_x = 0;
400 }
401 } 400 }
402 break; 401 break;
403 402
404 case PIX_FMT_RGB24: 403 case PIX_FMT_RGB24:
405 case PIX_FMT_BGR24: 404 case PIX_FMT_BGR24:
413 412
414 rgb_plane[index++] = s->palette[pix * 4 + 0]; 413 rgb_plane[index++] = s->palette[pix * 4 + 0];
415 rgb_plane[index++] = s->palette[pix * 4 + 1]; 414 rgb_plane[index++] = s->palette[pix * 4 + 1];
416 rgb_plane[index++] = s->palette[pix * 4 + 2]; 415 rgb_plane[index++] = s->palette[pix * 4 + 2];
417 416
418 current_x++; 417 ADVANCE_CURRENT_X();
419 if (current_x >= width) {
420 /* reset accounting variables */
421 index += line_inc;
422 current_x = 0;
423 }
424 } 418 }
425 break; 419 break;
426 420
427 case PIX_FMT_RGBA32: 421 case PIX_FMT_RGBA32:
428 rgb32_plane = (unsigned int *)s->current_frame.data[0]; 422 rgb32_plane = (unsigned int *)s->current_frame.data[0];
433 current_x = x; 427 current_x = x;
434 while(pixel_count--) { 428 while(pixel_count--) {
435 429
436 rgb32_plane[index++] = palette32[*pixel_buffer++]; 430 rgb32_plane[index++] = palette32[*pixel_buffer++];
437 431
438 current_x++; 432 ADVANCE_CURRENT_X();
439 if (current_x >= width) {
440 /* reset accounting variables */
441 index += line_inc;
442 current_x = 0;
443 }
444 } 433 }
445 break; 434 break;
446 435
447 case PIX_FMT_YUV444P: 436 case PIX_FMT_YUV444P:
448 y_plane = s->current_frame.data[0]; 437 y_plane = s->current_frame.data[0];
458 y_plane[index] = s->palette[pix * 4 + 0]; 447 y_plane[index] = s->palette[pix * 4 + 0];
459 u_plane[index] = s->palette[pix * 4 + 1]; 448 u_plane[index] = s->palette[pix * 4 + 1];
460 v_plane[index] = s->palette[pix * 4 + 2]; 449 v_plane[index] = s->palette[pix * 4 + 2];
461 450
462 index++; 451 index++;
463 current_x++; 452 ADVANCE_CURRENT_X();
464 if (current_x >= width) {
465 /* reset accounting variables */
466 index += line_inc;
467 current_x = 0;
468 }
469 } 453 }
470 break; 454 break;
471 455
472 default: 456 default:
473 printf (" Xan WC3: Unhandled colorspace\n"); 457 printf (" Xan WC3: Unhandled colorspace\n");
474 break; 458 break;
475 } 459 }
476 } 460 }
461
462 #define ADVANCE_CURFRAME_X() \
463 curframe_x++; \
464 if (curframe_x >= width) { \
465 curframe_index += line_inc; \
466 curframe_x = 0; \
467 }
468
469 #define ADVANCE_PREVFRAME_X() \
470 prevframe_x++; \
471 if (prevframe_x >= width) { \
472 prevframe_index += line_inc; \
473 prevframe_x = 0; \
474 }
477 475
478 static void inline xan_wc3_copy_pixel_run(XanContext *s, 476 static void inline xan_wc3_copy_pixel_run(XanContext *s,
479 int x, int y, int pixel_count, int motion_x, int motion_y) 477 int x, int y, int pixel_count, int motion_x, int motion_y)
480 { 478 {
481 int stride; 479 int stride;
504 while(pixel_count--) { 502 while(pixel_count--) {
505 503
506 palette_plane[curframe_index++] = 504 palette_plane[curframe_index++] =
507 prev_palette_plane[prevframe_index++]; 505 prev_palette_plane[prevframe_index++];
508 506
509 curframe_x++; 507 ADVANCE_CURFRAME_X();
510 if (curframe_x >= width) { 508 ADVANCE_PREVFRAME_X();
511 /* reset accounting variables */
512 curframe_index += line_inc;
513 curframe_x = 0;
514 }
515
516 prevframe_x++;
517 if (prevframe_x >= width) {
518 /* reset accounting variables */
519 prevframe_index += line_inc;
520 prevframe_x = 0;
521 }
522 } 509 }
523 break; 510 break;
524 511
525 case PIX_FMT_RGB555: 512 case PIX_FMT_RGB555:
526 case PIX_FMT_RGB565: 513 case PIX_FMT_RGB565:
535 while(pixel_count--) { 522 while(pixel_count--) {
536 523
537 rgb16_plane[curframe_index++] = 524 rgb16_plane[curframe_index++] =
538 prev_rgb16_plane[prevframe_index++]; 525 prev_rgb16_plane[prevframe_index++];
539 526
540 curframe_x++; 527 ADVANCE_CURFRAME_X();
541 if (curframe_x >= width) { 528 ADVANCE_PREVFRAME_X();
542 /* reset accounting variables */
543 curframe_index += line_inc;
544 curframe_x = 0;
545 }
546
547 prevframe_x++;
548 if (prevframe_x >= width) {
549 /* reset accounting variables */
550 prevframe_index += line_inc;
551 prevframe_x = 0;
552 }
553 } 529 }
554 break; 530 break;
555 531
556 case PIX_FMT_RGB24: 532 case PIX_FMT_RGB24:
557 case PIX_FMT_BGR24: 533 case PIX_FMT_BGR24:
568 544
569 rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++]; 545 rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++];
570 rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++]; 546 rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++];
571 rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++]; 547 rgb_plane[curframe_index++] = prev_rgb_plane[prevframe_index++];
572 548
573 curframe_x++; 549 ADVANCE_CURFRAME_X();
574 if (curframe_x >= width) { 550 ADVANCE_PREVFRAME_X();
575 /* reset accounting variables */
576 curframe_index += line_inc;
577 curframe_x = 0;
578 }
579
580 prevframe_x++;
581 if (prevframe_x >= width) {
582 /* reset accounting variables */
583 prevframe_index += line_inc;
584 prevframe_x = 0;
585 }
586 } 551 }
587 break; 552 break;
588 553
589 case PIX_FMT_RGBA32: 554 case PIX_FMT_RGBA32:
590 rgb32_plane = (unsigned int *)s->current_frame.data[0]; 555 rgb32_plane = (unsigned int *)s->current_frame.data[0];
598 while(pixel_count--) { 563 while(pixel_count--) {
599 564
600 rgb32_plane[curframe_index++] = 565 rgb32_plane[curframe_index++] =
601 prev_rgb32_plane[prevframe_index++]; 566 prev_rgb32_plane[prevframe_index++];
602 567
603 curframe_x++; 568 ADVANCE_CURFRAME_X();
604 if (curframe_x >= width) { 569 ADVANCE_PREVFRAME_X();
605 /* reset accounting variables */
606 curframe_index += line_inc;
607 curframe_x = 0;
608 }
609
610 prevframe_x++;
611 if (prevframe_x >= width) {
612 /* reset accounting variables */
613 prevframe_index += line_inc;
614 prevframe_x = 0;
615 }
616 } 570 }
617 break; 571 break;
618 572
619 case PIX_FMT_YUV444P: 573 case PIX_FMT_YUV444P:
620 y_plane = s->current_frame.data[0]; 574 y_plane = s->current_frame.data[0];
634 y_plane[curframe_index] = prev_y_plane[prevframe_index]; 588 y_plane[curframe_index] = prev_y_plane[prevframe_index];
635 u_plane[curframe_index] = prev_u_plane[prevframe_index]; 589 u_plane[curframe_index] = prev_u_plane[prevframe_index];
636 v_plane[curframe_index] = prev_v_plane[prevframe_index]; 590 v_plane[curframe_index] = prev_v_plane[prevframe_index];
637 591
638 curframe_index++; 592 curframe_index++;
639 curframe_x++; 593 ADVANCE_CURFRAME_X();
640 if (curframe_x >= width) {
641 /* reset accounting variables */
642 curframe_index += line_inc;
643 curframe_x = 0;
644 }
645
646 prevframe_index++; 594 prevframe_index++;
647 prevframe_x++; 595 ADVANCE_PREVFRAME_X();
648 if (prevframe_x >= width) {
649 /* reset accounting variables */
650 prevframe_index += line_inc;
651 prevframe_x = 0;
652 }
653 } 596 }
654 break; 597 break;
655 598
656 default: 599 default:
657 printf (" Xan WC3: Unhandled colorspace\n"); 600 printf (" Xan WC3: Unhandled colorspace\n");