falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1384 Commits
32 Branches
2.4GB
Tree: b8a78f419d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b8a78f419d'
${ noResults }
FFmpeg/libavcodec/imgconvert.c

1000 lines
29KB
Raw Blame History 

  1. /*

  2.  * Misc image convertion routines

  3.  * Copyright (c) 2001, 2002 Fabrice Bellard.

  4.  *

  5.  * This library is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU Lesser General Public

  7.  * License as published by the Free Software Foundation; either

  8.  * version 2 of the License, or (at your option) any later version.

  9.  *

  10.  * This library is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  13.  * Lesser General Public License for more details.

  14.  *

  15.  * You should have received a copy of the GNU Lesser General Public

  16.  * License along with this library; if not, write to the Free Software

  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  18.  */

  19. #include "avcodec.h"

  20. #include "dsputil.h"

  21. 

  22. #ifdef USE_FASTMEMCPY

  23. #include "fastmemcpy.h"

  24. #endif

  25. 

  26. #ifdef HAVE_MMX

  27. #include "i386/mmx.h"

  28. #endif

  29. /* XXX: totally non optimized */

  30. 

  31. static void yuv422_to_yuv420p(UINT8 *lum, UINT8 *cb, UINT8 *cr,

  32.                               UINT8 *src, int width, int height)

  33. {

  34.     int x, y;

  35.     UINT8 *p = src;

  36. 

  37.     for(y=0;y<height;y+=2) {

  38.         for(x=0;x<width;x+=2) {

  39.             lum[0] = p[0];

  40.             cb[0] = p[1];

  41.             lum[1] = p[2];

  42.             cr[0] = p[3];

  43.             p += 4;

  44.             lum += 2;

  45.             cb++;

  46.             cr++;

  47.         }

  48.         for(x=0;x<width;x+=2) {

  49.             lum[0] = p[0];

  50.             lum[1] = p[2];

  51.             p += 4;

  52.             lum += 2;

  53.         }

  54.     }

  55. }

  56. 

  57. #define SCALEBITS 8

  58. #define ONE_HALF  (1 << (SCALEBITS - 1))

  59. #define FIX(x)		((int) ((x) * (1L<<SCALEBITS) + 0.5))

  60. 

  61. static void rgb24_to_yuv420p(UINT8 *lum, UINT8 *cb, UINT8 *cr,

  62.                               UINT8 *src, int width, int height)

  63. {

  64.     int wrap, wrap3, x, y;

  65.     int r, g, b, r1, g1, b1;

  66.     UINT8 *p;

  67. 

  68.     wrap = width;

  69.     wrap3 = width * 3;

  70.     p = src;

  71.     for(y=0;y<height;y+=2) {

  72.         for(x=0;x<width;x+=2) {

  73.             r = p[0];

  74.             g = p[1];

  75.             b = p[2];

  76.             r1 = r;

  77.             g1 = g;

  78.             b1 = b;

  79.             lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  80.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  81.             r = p[3];

  82.             g = p[4];

  83.             b = p[5];

  84.             r1 += r;

  85.             g1 += g;

  86.             b1 += b;

  87.             lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  88.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  89.             p += wrap3;

  90.             lum += wrap;

  91. 

  92.             r = p[0];

  93.             g = p[1];

  94.             b = p[2];

  95.             r1 += r;

  96.             g1 += g;

  97.             b1 += b;

  98.             lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  99.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  100.             r = p[3];

  101.             g = p[4];

  102.             b = p[5];

  103.             r1 += r;

  104.             g1 += g;

  105.             b1 += b;

  106.             lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  107.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  108.             

  109.             cb[0] = ((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + 

  110.                       FIX(0.50000) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;

  111.             cr[0] = ((FIX(0.50000) * r1 - FIX(0.41869) * g1 - 

  112.                      FIX(0.08131) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;

  113. 

  114.             cb++;

  115.             cr++;

  116.             p += -wrap3 + 2 * 3;

  117.             lum += -wrap + 2;

  118.         }

  119.         p += wrap3;

  120.         lum += wrap;

  121.     }

  122. }

  123. 

  124. static void rgba32_to_yuv420p(UINT8 *lum, UINT8 *cb, UINT8 *cr,

  125.                               UINT8 *src, int width, int height)

  126. {

  127.     int wrap, wrap4, x, y;

  128.     int r, g, b, r1, g1, b1;

  129.     UINT8 *p;

  130. 

  131.     wrap = width;

  132.     wrap4 = width * 4;

  133.     p = src;

  134.     for(y=0;y<height;y+=2) {

  135.         for(x=0;x<width;x+=2) {

  136.             r = p[0];

  137.             g = p[1];

  138.             b = p[2];

  139.             r1 = r;

  140.             g1 = g;

  141.             b1 = b;

  142.             lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  143.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  144.             r = p[4];

  145.             g = p[5];

  146.             b = p[6];

  147.             r1 += r;

  148.             g1 += g;

  149.             b1 += b;

  150.             lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  151.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  152.             p += wrap4;

  153.             lum += wrap;

  154. 

  155.             r = p[0];

  156.             g = p[1];

  157.             b = p[2];

  158.             r1 += r;

  159.             g1 += g;

  160.             b1 += b;

  161.             lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  162.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  163.             r = p[4];

  164.             g = p[5];

  165.             b = p[6];

  166.             r1 += r;

  167.             g1 += g;

  168.             b1 += b;

  169.             lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  170.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  171.             

  172.             cb[0] = ((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + 

  173.                       FIX(0.50000) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;

  174.             cr[0] = ((FIX(0.50000) * r1 - FIX(0.41869) * g1 - 

  175.                      FIX(0.08131) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;

  176. 

  177.             cb++;

  178.             cr++;

  179.             p += -wrap4 + 2 * 4;

  180.             lum += -wrap + 2;

  181.         }

  182.         p += wrap4;

  183.         lum += wrap;

  184.     }

  185. }

  186. 

  187. static void bgr24_to_yuv420p(UINT8 *lum, UINT8 *cb, UINT8 *cr,

  188.                               UINT8 *src, int width, int height)

  189. {

  190.     int wrap, wrap3, x, y;

  191.     int r, g, b, r1, g1, b1;

  192.     UINT8 *p;

  193. 

  194.     wrap = width;

  195.     wrap3 = width * 3;

  196.     p = src;

  197.     for(y=0;y<height;y+=2) {

  198.         for(x=0;x<width;x+=2) {

  199.             b = p[0];

  200.             g = p[1];

  201.             r = p[2];

  202.             r1 = r;

  203.             g1 = g;

  204.             b1 = b;

  205.             lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  206.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  207.             b = p[3];

  208.             g = p[4];

  209.             r = p[5];

  210.             r1 += r;

  211.             g1 += g;

  212.             b1 += b;

  213.             lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  214.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  215.             p += wrap3;

  216.             lum += wrap;

  217. 

  218.             b = p[0];

  219.             g = p[1];

  220.             r = p[2];

  221.             r1 += r;

  222.             g1 += g;

  223.             b1 += b;

  224.             lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  225.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  226.             b = p[3];

  227.             g = p[4];

  228.             r = p[5];

  229.             r1 += r;

  230.             g1 += g;

  231.             b1 += b;

  232.             lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  233.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  234.             

  235.             cb[0] = ((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + 

  236.                       FIX(0.50000) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;

  237.             cr[0] = ((FIX(0.50000) * r1 - FIX(0.41869) * g1 - 

  238.                      FIX(0.08131) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;

  239. 

  240.             cb++;

  241.             cr++;

  242.             p += -wrap3 + 2 * 3;

  243.             lum += -wrap + 2;

  244.         }

  245.         p += wrap3;

  246.         lum += wrap;

  247.     }

  248. }

  249. 

  250. static void bgra32_to_yuv420p(UINT8 *lum, UINT8 *cb, UINT8 *cr,

  251.                               UINT8 *src, int width, int height)

  252. {

  253.     int wrap, wrap4, x, y;

  254.     int r, g, b, r1, g1, b1;

  255.     UINT8 *p;

  256. 

  257.     wrap = width;

  258.     wrap4 = width * 4;

  259.     p = src;

  260.     for(y=0;y<height;y+=2) {

  261.         for(x=0;x<width;x+=2) {

  262.             b = p[0];

  263.             g = p[1];

  264.             r = p[2];

  265.             r1 = r;

  266.             g1 = g;

  267.             b1 = b;

  268.             lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  269.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  270.             b = p[4];

  271.             g = p[5];

  272.             r = p[6];

  273.             r1 += r;

  274.             g1 += g;

  275.             b1 += b;

  276.             lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  277.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  278.             p += wrap4;

  279.             lum += wrap;

  280. 

  281.             b = p[0];

  282.             g = p[1];

  283.             r = p[2];

  284.             r1 += r;

  285.             g1 += g;

  286.             b1 += b;

  287.             lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  288.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  289.             b = p[4];

  290.             g = p[5];

  291.             r = p[6];

  292.             r1 += r;

  293.             g1 += g;

  294.             b1 += b;

  295.             lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g + 

  296.                       FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

  297.             

  298.             cb[0] = ((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + 

  299.                       FIX(0.50000) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;

  300.             cr[0] = ((FIX(0.50000) * r1 - FIX(0.41869) * g1 - 

  301.                      FIX(0.08131) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128;

  302. 

  303.             cb++;

  304.             cr++;

  305.             p += -wrap4 + 2 * 4;

  306.             lum += -wrap + 2;

  307.         }

  308.         p += wrap4;

  309.         lum += wrap;

  310.     }

  311. }

  312. 

  313. /* XXX: use generic filter ? */

  314. /* 1x2 -> 1x1 */

  315. static void shrink2(UINT8 *dst, int dst_wrap, 

  316.                     UINT8 *src, int src_wrap,

  317.                     int width, int height)

  318. {

  319.     int w;

  320.     UINT8 *s1, *s2, *d;

  321. 

  322.     for(;height > 0; height--) {

  323.         s1 = src;

  324.         s2 = s1 + src_wrap;

  325.         d = dst;

  326.         for(w = width;w >= 4; w-=4) {

  327.             d[0] = (s1[0] + s2[0]) >> 1;

  328.             d[1] = (s1[1] + s2[1]) >> 1;

  329.             d[2] = (s1[2] + s2[2]) >> 1;

  330.             d[3] = (s1[3] + s2[3]) >> 1;

  331.             s1 += 4;

  332.             s2 += 4;

  333.             d += 4;

  334.         }

  335.         for(;w > 0; w--) {

  336.             d[0] = (s1[0] + s2[0]) >> 1;

  337.             s1++;

  338.             s2++;

  339.             d++;

  340.         }

  341.         src += 2 * src_wrap;

  342.         dst += dst_wrap;

  343.     }

  344. }

  345. 

  346. /* 2x2 -> 1x1 */

  347. static void shrink22(UINT8 *dst, int dst_wrap, 

  348.                      UINT8 *src, int src_wrap,

  349.                      int width, int height)

  350. {

  351.     int w;

  352.     UINT8 *s1, *s2, *d;

  353. 

  354.     for(;height > 0; height--) {

  355.         s1 = src;

  356.         s2 = s1 + src_wrap;

  357.         d = dst;

  358.         for(w = width;w >= 4; w-=4) {

  359.             d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 1;

  360.             d[1] = (s1[2] + s1[3] + s2[2] + s2[3] + 2) >> 1;

  361.             d[2] = (s1[4] + s1[5] + s2[4] + s2[5] + 2) >> 1;

  362.             d[3] = (s1[6] + s1[7] + s2[6] + s2[7] + 2) >> 1;

  363.             s1 += 8;

  364.             s2 += 8;

  365.             d += 4;

  366.         }

  367.         for(;w > 0; w--) {

  368.             d[0] = (s1[0] + s1[1] + s2[0] + s2[1] + 2) >> 1;

  369.             s1 += 2;

  370.             s2 += 2;

  371.             d++;

  372.         }

  373.         src += 2 * src_wrap;

  374.         dst += dst_wrap;

  375.     }

  376. }

  377. 

  378. /* 1x1 -> 2x2 */

  379. static void grow22(UINT8 *dst, int dst_wrap,

  380.                      UINT8 *src, int src_wrap,

  381.                      int width, int height)

  382. {

  383.     int w;

  384.     UINT8 *s1, *d;

  385. 

  386.     for(;height > 0; height--) {

  387.         s1 = src;

  388.         d = dst;

  389.         for(w = width;w >= 4; w-=4) {

  390.             d[1] = d[0] = s1[0];

  391.             d[3] = d[2] = s1[1];

  392.             s1 += 2;

  393.             d += 4;

  394.         }

  395.         for(;w > 0; w--) {

  396.             d[0] = s1[0];

  397.             s1 ++;

  398.             d++;

  399.         }

  400.         if (height%2)

  401.             src += src_wrap;

  402.         dst += dst_wrap;

  403.     }

  404. }

  405. 

  406. /* 1x2 -> 2x1. width and height are given for the source picture */

  407. static void conv411(UINT8 *dst, int dst_wrap, 

  408.                     UINT8 *src, int src_wrap,

  409.                     int width, int height)

  410. {

  411.     int w, c;

  412.     UINT8 *s1, *s2, *d;

  413. 

  414.     for(;height > 0; height -= 2) {

  415.         s1 = src;

  416.         s2 = src + src_wrap;

  417.         d = dst;

  418.         for(w = width;w > 0; w--) {

  419.             c = (s1[0] + s2[0]) >> 1;

  420.             d[0] = c;

  421.             d[1] = c;

  422.             s1++;

  423.             s2++;

  424.             d += 2;

  425.         }

  426.         src += src_wrap * 2;

  427.         dst += dst_wrap;

  428.     }

  429. }

  430. 

  431. static void img_copy(UINT8 *dst, int dst_wrap, 

  432.                      UINT8 *src, int src_wrap,

  433.                      int width, int height)

  434. {

  435.     for(;height > 0; height--) {

  436.         memcpy(dst, src, width);

  437.         dst += dst_wrap;

  438.         src += src_wrap;

  439.     }

  440. }

  441. 

  442. #define SCALE_BITS 10

  443. 

  444. #define C_Y  (76309 >> (16 - SCALE_BITS))

  445. #define C_RV (117504 >> (16 - SCALE_BITS))

  446. #define C_BU (138453 >> (16 - SCALE_BITS))

  447. #define C_GU (13954 >> (16 - SCALE_BITS))

  448. #define C_GV (34903 >> (16 - SCALE_BITS))

  449. 

  450. #define RGBOUT(r, g, b, y1)\

  451. {\

  452.     y = (y1 - 16) * C_Y;\

  453.     r = cm[(y + r_add) >> SCALE_BITS];\

  454.     g = cm[(y + g_add) >> SCALE_BITS];\

  455.     b = cm[(y + b_add) >> SCALE_BITS];\

  456. }

  457. 

  458. /* XXX: no chroma interpolating is done */

  459. static void yuv420p_to_bgra32(AVPicture *dst, AVPicture *src, 

  460.                              int width, int height)

  461. {

  462.     UINT8 *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr, *d, *d1, *d2;

  463.     int w, y, cb, cr, r_add, g_add, b_add, width2;

  464.     UINT8 *cm = cropTbl + MAX_NEG_CROP;

  465. 

  466.     d = dst->data[0];

  467.     y1_ptr = src->data[0];

  468.     cb_ptr = src->data[1];

  469.     cr_ptr = src->data[2];

  470.     width2 = width >> 1;

  471.     for(;height > 0; height -= 2) {

  472.         d1 = d;

  473.         d2 = d + dst->linesize[0];

  474.         y2_ptr = y1_ptr + src->linesize[0];

  475.         for(w = width2; w > 0; w --) {

  476.             cb = cb_ptr[0] - 128;

  477.             cr = cr_ptr[0] - 128;

  478.             r_add = C_RV * cr + (1 << (SCALE_BITS - 1));

  479.             g_add = - C_GU * cb - C_GV * cr + (1 << (SCALE_BITS - 1));

  480.             b_add = C_BU * cb + (1 << (SCALE_BITS - 1));

  481.             

  482.             /* output 4 pixels */

  483.             RGBOUT(d1[2], d1[1], d1[0], y1_ptr[0]);

  484.             RGBOUT(d1[6], d1[5], d1[4], y1_ptr[1]);

  485.             RGBOUT(d2[2], d2[1], d2[0], y2_ptr[0]);

  486.             RGBOUT(d2[6], d2[5], d2[4], y2_ptr[1]);

  487. 

  488.             d1[3] = d1[7] = d2[3] = d2[7] = 255;

  489. 

  490.             d1 += 8;

  491.             d2 += 8;

  492.             y1_ptr += 2;

  493.             y2_ptr += 2;

  494.             cb_ptr++;

  495.             cr_ptr++;

  496.         }

  497.         d += 2 * dst->linesize[0];

  498.         y1_ptr += 2 * src->linesize[0] - width;

  499.         cb_ptr += src->linesize[1] - width2;

  500.         cr_ptr += src->linesize[2] - width2;

  501.     }

  502. }

  503. 

  504. /* XXX: no chroma interpolating is done */

  505. static void yuv420p_to_rgba32(AVPicture *dst, AVPicture *src, 

  506.                              int width, int height)

  507. {

  508.     UINT8 *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr, *d, *d1, *d2;

  509.     int w, y, cb, cr, r_add, g_add, b_add, width2;

  510.     UINT8 *cm = cropTbl + MAX_NEG_CROP;

  511. 

  512.     d = dst->data[0];

  513.     y1_ptr = src->data[0];

  514.     cb_ptr = src->data[1];

  515.     cr_ptr = src->data[2];

  516.     width2 = width >> 1;

  517.     for(;height > 0; height -= 2) {

  518.         d1 = d;

  519.         d2 = d + dst->linesize[0];

  520.         y2_ptr = y1_ptr + src->linesize[0];

  521.         for(w = width2; w > 0; w --) {

  522.             cb = cb_ptr[0] - 128;

  523.             cr = cr_ptr[0] - 128;

  524.             r_add = C_RV * cr + (1 << (SCALE_BITS - 1));

  525.             g_add = - C_GU * cb - C_GV * cr + (1 << (SCALE_BITS - 1));

  526.             b_add = C_BU * cb + (1 << (SCALE_BITS - 1));

  527.             

  528.             /* output 4 pixels */

  529.             RGBOUT(d1[0], d1[1], d1[2], y1_ptr[0]);

  530.             RGBOUT(d1[4], d1[5], d1[6], y1_ptr[1]);

  531.             RGBOUT(d2[0], d2[1], d2[2], y2_ptr[0]);

  532.             RGBOUT(d2[4], d2[5], d2[6], y2_ptr[1]);

  533. 

  534.             d1[3] = d1[7] = d2[3] = d2[7] = 255;

  535. 

  536.             d1 += 8;

  537.             d2 += 8;

  538.             y1_ptr += 2;

  539.             y2_ptr += 2;

  540.             cb_ptr++;

  541.             cr_ptr++;

  542.         }

  543.         d += 2 * dst->linesize[0];

  544.         y1_ptr += 2 * src->linesize[0] - width;

  545.         cb_ptr += src->linesize[1] - width2;

  546.         cr_ptr += src->linesize[2] - width2;

  547.     }

  548. }

  549. 

  550. /* XXX: no chroma interpolating is done */

  551. static void yuv420p_to_rgb24(AVPicture *dst, AVPicture *src, 

  552.                              int width, int height)

  553. {

  554.     UINT8 *y1_ptr, *y2_ptr, *cb_ptr, *cr_ptr, *d, *d1, *d2;

  555.     int w, y, cb, cr, r_add, g_add, b_add, width2;

  556.     UINT8 *cm = cropTbl + MAX_NEG_CROP;

  557. 

  558.     d = dst->data[0];

  559.     y1_ptr = src->data[0];

  560.     cb_ptr = src->data[1];

  561.     cr_ptr = src->data[2];

  562.     width2 = width >> 1;

  563.     for(;height > 0; height -= 2) {

  564.         d1 = d;

  565.         d2 = d + dst->linesize[0];

  566.         y2_ptr = y1_ptr + src->linesize[0];

  567.         for(w = width2; w > 0; w --) {

  568.             cb = cb_ptr[0] - 128;

  569.             cr = cr_ptr[0] - 128;

  570.             r_add = C_RV * cr + (1 << (SCALE_BITS - 1));

  571.             g_add = - C_GU * cb - C_GV * cr + (1 << (SCALE_BITS - 1));

  572.             b_add = C_BU * cb + (1 << (SCALE_BITS - 1));

  573.             

  574.             /* output 4 pixels */

  575.             RGBOUT(d1[0], d1[1], d1[2], y1_ptr[0]);

  576.             RGBOUT(d1[3], d1[4], d1[5], y1_ptr[1]);

  577.             RGBOUT(d2[0], d2[1], d2[2], y2_ptr[0]);

  578.             RGBOUT(d2[3], d2[4], d2[5], y2_ptr[1]);

  579. 

  580.             d1 += 6;

  581.             d2 += 6;

  582.             y1_ptr += 2;

  583.             y2_ptr += 2;

  584.             cb_ptr++;

  585.             cr_ptr++;

  586.         }

  587.         d += 2 * dst->linesize[0];

  588.         y1_ptr += 2 * src->linesize[0] - width;

  589.         cb_ptr += src->linesize[1] - width2;

  590.         cr_ptr += src->linesize[2] - width2;

  591.     }

  592. }

  593. 

  594. /* XXX: no chroma interpolating is done */

  595. static void yuv422p_to_rgb24(AVPicture *dst, AVPicture *src, 

  596.                              int width, int height)

  597. {

  598.     UINT8 *y1_ptr, *cb_ptr, *cr_ptr, *d, *d1;

  599.     int w, y, cb, cr, r_add, g_add, b_add, width2;

  600.     UINT8 *cm = cropTbl + MAX_NEG_CROP;

  601. 

  602.     d = dst->data[0];

  603.     y1_ptr = src->data[0];

  604.     cb_ptr = src->data[1];

  605.     cr_ptr = src->data[2];

  606.     width2 = width >> 1;

  607.     for(;height > 0; height --) {

  608.         d1 = d;

  609.         for(w = width2; w > 0; w --) {

  610.             cb = cb_ptr[0] - 128;

  611.             cr = cr_ptr[0] - 128;

  612.             r_add = C_RV * cr + (1 << (SCALE_BITS - 1));

  613.             g_add = - C_GU * cb - C_GV * cr + (1 << (SCALE_BITS - 1));

  614.             b_add = C_BU * cb + (1 << (SCALE_BITS - 1));

  615.             

  616.             /* output 2 pixels */

  617.             RGBOUT(d1[0], d1[1], d1[2], y1_ptr[0]);

  618.             RGBOUT(d1[3], d1[4], d1[5], y1_ptr[1]);

  619. 

  620.             d1 += 6;

  621.             y1_ptr += 2;

  622.             cb_ptr++;

  623.             cr_ptr++;

  624.         }

  625.         d += dst->linesize[0];

  626.         y1_ptr += src->linesize[0] - width;

  627.         cb_ptr += src->linesize[1] - width2;

  628.         cr_ptr += src->linesize[2] - width2;

  629.     }

  630. }

  631. 

  632. /* XXX: always use linesize. Return -1 if not supported */

  633. int img_convert(AVPicture *dst, int dst_pix_fmt,

  634.                 AVPicture *src, int pix_fmt, 

  635.                 int width, int height)

  636. {

  637.     int i;

  638. 

  639.     assert(pix_fmt != PIX_FMT_ANY && dst_pix_fmt != PIX_FMT_ANY);

  640. 

  641.     if (dst_pix_fmt == pix_fmt) {

  642.         switch(pix_fmt) {

  643.         case PIX_FMT_YUV420P:

  644.             for(i=0;i<3;i++) {

  645.                 if (i == 1) {

  646.                     width >>= 1;

  647.                     height >>= 1;

  648.                 }

  649.                 img_copy(dst->data[i], dst->linesize[i],

  650.                          src->data[i], src->linesize[i],

  651.                          width, height);

  652.             }

  653.             break;

  654.         default:

  655.             return -1;

  656.         }

  657.     } else if (dst_pix_fmt == PIX_FMT_YUV420P) {

  658.         

  659.         switch(pix_fmt) {

  660.         case PIX_FMT_YUV411P:

  661.             img_copy(dst->data[0], dst->linesize[0],

  662.                      src->data[0], src->linesize[0],

  663.                      width, height);

  664.             conv411(dst->data[1], dst->linesize[1],

  665.                     src->data[1], src->linesize[1],

  666.                     width / 4, height);

  667.             conv411(dst->data[2], dst->linesize[2],

  668.                     src->data[2], src->linesize[2],

  669.                     width / 4, height);

  670.             break;

  671.         case PIX_FMT_YUV410P:

  672.             img_copy(dst->data[0], dst->linesize[0],

  673.                      src->data[0], src->linesize[0],

  674.                      width, height);

  675.             grow22(dst->data[1], dst->linesize[1],

  676.                      src->data[1], src->linesize[1],

  677.                      width/2, height/2);

  678.             grow22(dst->data[2], dst->linesize[2],

  679.                      src->data[2], src->linesize[2],

  680.                      width/2, height/2);

  681.             break;

  682.         case PIX_FMT_YUV420P:

  683.             for(i=0;i<3;i++) {

  684.                 img_copy(dst->data[i], dst->linesize[i],

  685.                          src->data[i], src->linesize[i],

  686.                          width, height);

  687.             }

  688.             break;

  689.         case PIX_FMT_YUV422P:

  690.             img_copy(dst->data[0], dst->linesize[0],

  691.                      src->data[0], src->linesize[0],

  692.                      width, height);

  693.             width >>= 1;

  694.             height >>= 1;

  695.             for(i=1;i<3;i++) {

  696.                 shrink2(dst->data[i], dst->linesize[i],

  697.                         src->data[i], src->linesize[i],

  698.                         width, height);

  699.             }

  700.             break;

  701.         case PIX_FMT_YUV444P:

  702.             img_copy(dst->data[0], dst->linesize[0],

  703.                      src->data[0], src->linesize[0],

  704.                      width, height);

  705.             width >>= 1;

  706.             height >>= 1;

  707.             for(i=1;i<3;i++) {

  708.                 shrink22(dst->data[i], dst->linesize[i],

  709.                          src->data[i], src->linesize[i],

  710.                          width, height);

  711.             }

  712.             break;

  713.         case PIX_FMT_YUV422:

  714.             yuv422_to_yuv420p(dst->data[0], dst->data[1], dst->data[2], 

  715.                               src->data[0], width, height);

  716.             break;

  717.         case PIX_FMT_RGB24:

  718.             rgb24_to_yuv420p(dst->data[0], dst->data[1], dst->data[2], 

  719.                              src->data[0], width, height);

  720.             break;

  721.         case PIX_FMT_RGBA32:

  722.             rgba32_to_yuv420p(dst->data[0], dst->data[1], dst->data[2], 

  723.                              src->data[0], width, height);

  724.             break;

  725.         case PIX_FMT_BGR24:

  726.             bgr24_to_yuv420p(dst->data[0], dst->data[1], dst->data[2], 

  727.                              src->data[0], width, height);

  728.             break;

  729.         case PIX_FMT_BGRA32:

  730.             bgra32_to_yuv420p(dst->data[0], dst->data[1], dst->data[2], 

  731.                              src->data[0], width, height);

  732.             break;

  733.         default:

  734.             return -1;

  735.         }

  736.     } else if (dst_pix_fmt == PIX_FMT_RGB24) {

  737.         switch(pix_fmt) {

  738.         case PIX_FMT_YUV420P:

  739.             yuv420p_to_rgb24(dst, src, width, height);

  740.             break;

  741.         case PIX_FMT_YUV422P:

  742.             yuv422p_to_rgb24(dst, src, width, height);

  743.             break;

  744.         default:

  745.             return -1;

  746.         }

  747.     } else if (dst_pix_fmt == PIX_FMT_RGBA32) {

  748.         switch(pix_fmt) {

  749.         case PIX_FMT_YUV420P:

  750.             yuv420p_to_rgba32(dst, src, width, height);

  751.             break;

  752.         default:

  753.             return -1;

  754.         }

  755.     } else if (dst_pix_fmt == PIX_FMT_BGRA32) {

  756.         switch(pix_fmt) {

  757.         case PIX_FMT_YUV420P:

  758.             yuv420p_to_bgra32(dst, src, width, height);

  759.             break;

  760.         default:

  761.             return -1;

  762.         }

  763.     } else {

  764.         return -1;

  765.     }

  766.     return 0;

  767. }

  768. 

  769. 

  770. #ifdef HAVE_MMX

  771. #define DEINT_INPLACE_LINE_LUM \

  772.                     movd_m2r(lum_m4[0],mm0);\

  773.                     movd_m2r(lum_m3[0],mm1);\

  774.                     movd_m2r(lum_m2[0],mm2);\

  775.                     movd_m2r(lum_m1[0],mm3);\

  776.                     movd_m2r(lum[0],mm4);\

  777.                     punpcklbw_r2r(mm7,mm0);\

  778.                     movd_r2m(mm2,lum_m4[0]);\

  779.                     punpcklbw_r2r(mm7,mm1);\

  780.                     punpcklbw_r2r(mm7,mm2);\

  781.                     punpcklbw_r2r(mm7,mm3);\

  782.                     punpcklbw_r2r(mm7,mm4);\

  783.                     paddw_r2r(mm3,mm1);\

  784.                     psllw_i2r(1,mm2);\

  785.                     paddw_r2r(mm4,mm0);\

  786.                     psllw_i2r(2,mm1);\

  787.                     paddw_r2r(mm6,mm2);\

  788.                     paddw_r2r(mm2,mm1);\

  789.                     psubusw_r2r(mm0,mm1);\

  790.                     psrlw_i2r(3,mm1);\

  791.                     packuswb_r2r(mm7,mm1);\

  792.                     movd_r2m(mm1,lum_m2[0]);

  793. 

  794. #define DEINT_LINE_LUM \

  795.                     movd_m2r(lum_m4[0],mm0);\

  796.                     movd_m2r(lum_m3[0],mm1);\

  797.                     movd_m2r(lum_m2[0],mm2);\

  798.                     movd_m2r(lum_m1[0],mm3);\

  799.                     movd_m2r(lum[0],mm4);\

  800.                     punpcklbw_r2r(mm7,mm0);\

  801.                     punpcklbw_r2r(mm7,mm1);\

  802.                     punpcklbw_r2r(mm7,mm2);\

  803.                     punpcklbw_r2r(mm7,mm3);\

  804.                     punpcklbw_r2r(mm7,mm4);\

  805.                     paddw_r2r(mm3,mm1);\

  806.                     psllw_i2r(1,mm2);\

  807.                     paddw_r2r(mm4,mm0);\

  808.                     psllw_i2r(2,mm1);\

  809.                     paddw_r2r(mm6,mm2);\

  810.                     paddw_r2r(mm2,mm1);\

  811.                     psubusw_r2r(mm0,mm1);\

  812.                     psrlw_i2r(3,mm1);\

  813.                     packuswb_r2r(mm7,mm1);\

  814.                     movd_r2m(mm1,dst[0]);

  815. #endif

  816. 

  817. /* filter parameters: [-1 4 2 4 -1] // 8 */

  818. static void deinterlace_line(UINT8 *dst, UINT8 *lum_m4, UINT8 *lum_m3, UINT8 *lum_m2, UINT8 *lum_m1, UINT8 *lum,

  819.                                 int size)

  820. {

  821. #ifndef HAVE_MMX

  822.     UINT8 *cm = cropTbl + MAX_NEG_CROP;

  823.     int sum;

  824. 

  825.     for(;size > 0;size--) {

  826.         sum = -lum_m4[0];

  827.         sum += lum_m3[0] << 2;

  828.         sum += lum_m2[0] << 1;

  829.         sum += lum_m1[0] << 2;

  830.         sum += -lum[0];

  831.         dst[0] = cm[(sum + 4) >> 3];

  832.         lum_m4++;

  833.         lum_m3++;

  834.         lum_m2++;

  835.         lum_m1++;

  836.         lum++;

  837.         dst++;

  838.     }

  839. #else

  840. 

  841.     for (;size > 3; size-=4) {

  842.         DEINT_LINE_LUM

  843.         lum_m4+=4;

  844.         lum_m3+=4;

  845.         lum_m2+=4;

  846.         lum_m1+=4;

  847.         lum+=4;

  848.         dst+=4;

  849.     }

  850. #endif

  851. }

  852. static void deinterlace_line_inplace(UINT8 *lum_m4, UINT8 *lum_m3, UINT8 *lum_m2, UINT8 *lum_m1, UINT8 *lum,

  853.                              int size)

  854. {

  855. #ifndef HAVE_MMX

  856.     UINT8 *cm = cropTbl + MAX_NEG_CROP;

  857.     int sum;

  858. 

  859.     for(;size > 0;size--) {

  860.         sum = -lum_m4[0];

  861.         sum += lum_m3[0] << 2;

  862.         sum += lum_m2[0] << 1;

  863.         lum_m4[0]=lum_m2[0];

  864.         sum += lum_m1[0] << 2;

  865.         sum += -lum[0];

  866.         lum_m2[0] = cm[(sum + 4) >> 3];

  867.         lum_m4++;

  868.         lum_m3++;

  869.         lum_m2++;

  870.         lum_m1++;

  871.         lum++;

  872.     }

  873. #else

  874. 

  875.     for (;size > 3; size-=4) {

  876.         DEINT_INPLACE_LINE_LUM

  877.         lum_m4+=4;

  878.         lum_m3+=4;

  879.         lum_m2+=4;

  880.         lum_m1+=4;

  881.         lum+=4;

  882.     }

  883. #endif

  884. }

  885. 

  886. /* deinterlacing : 2 temporal taps, 3 spatial taps linear filter. The

  887.    top field is copied as is, but the bottom field is deinterlaced

  888.    against the top field. */

  889. static void deinterlace_bottom_field(UINT8 *dst, int dst_wrap,

  890.                                     UINT8 *src1, int src_wrap,

  891.                                     int width, int height)

  892. {

  893.     UINT8 *src_m2, *src_m1, *src_0, *src_p1, *src_p2;

  894.     int y;

  895. 

  896.     src_m2 = src1;

  897.     src_m1 = src1;

  898.     src_0=&src_m1[src_wrap];

  899.     src_p1=&src_0[src_wrap];

  900.     src_p2=&src_p1[src_wrap];

  901.     for(y=0;y<(height-2);y+=2) {

  902.         memcpy(dst,src_m1,width);

  903.         dst += dst_wrap;

  904.         deinterlace_line(dst,src_m2,src_m1,src_0,src_p1,src_p2,width);

  905.         src_m2 = src_0;

  906.         src_m1 = src_p1;

  907.         src_0 = src_p2;

  908.         src_p1 += 2*src_wrap;

  909.         src_p2 += 2*src_wrap;

  910.         dst += dst_wrap;

  911.     }

  912.     memcpy(dst,src_m1,width);

  913.     dst += dst_wrap;

  914.     /* do last line */

  915.     deinterlace_line(dst,src_m2,src_m1,src_0,src_0,src_0,width);

  916. }

  917. 

  918. static void deinterlace_bottom_field_inplace(UINT8 *src1, int src_wrap,

  919.                                      int width, int height)

  920. {

  921.     UINT8 *src_m1, *src_0, *src_p1, *src_p2;

  922.     int y;

  923.     UINT8 *buf;

  924.     buf = (UINT8*)av_malloc(width);

  925. 

  926.     src_m1 = src1;

  927.     memcpy(buf,src_m1,width);

  928.     src_0=&src_m1[src_wrap];

  929.     src_p1=&src_0[src_wrap];

  930.     src_p2=&src_p1[src_wrap];

  931.     for(y=0;y<(height-2);y+=2) {

  932.         deinterlace_line_inplace(buf,src_m1,src_0,src_p1,src_p2,width);

  933.         src_m1 = src_p1;

  934.         src_0 = src_p2;

  935.         src_p1 += 2*src_wrap;

  936.         src_p2 += 2*src_wrap;

  937.     }

  938.     /* do last line */

  939.     deinterlace_line_inplace(buf,src_m1,src_0,src_0,src_0,width);

  940.     av_free(buf);

  941. }

  942. 

  943. 

  944. /* deinterlace - if not supported return -1 */

  945. int avpicture_deinterlace(AVPicture *dst, AVPicture *src,

  946.                           int pix_fmt, int width, int height)

  947. {

  948.     int i;

  949. 

  950.     if (pix_fmt != PIX_FMT_YUV420P &&

  951.         pix_fmt != PIX_FMT_YUV422P &&

  952.         pix_fmt != PIX_FMT_YUV444P)

  953.         return -1;

  954.     if ((width & 3) != 0 || (height & 3) != 0)

  955.         return -1;

  956. 

  957. #ifdef HAVE_MMX

  958.     {

  959.         mmx_t rounder;

  960.         rounder.uw[0]=4;

  961.         rounder.uw[1]=4;

  962.         rounder.uw[2]=4;

  963.         rounder.uw[3]=4;

  964.         pxor_r2r(mm7,mm7);

  965.         movq_m2r(rounder,mm6);

  966.     }

  967. #endif

  968. 

  969.     

  970.     for(i=0;i<3;i++) {

  971.         if (i == 1) {

  972.             switch(pix_fmt) {

  973.             case PIX_FMT_YUV420P:

  974.                 width >>= 1;

  975.                 height >>= 1;

  976.                 break;

  977.             case PIX_FMT_YUV422P:

  978.                 width >>= 1;

  979.                 break;

  980.             default:

  981.                 break;

  982.             }

  983.         }

  984.         if (src == dst) {

  985.             deinterlace_bottom_field_inplace(src->data[i], src->linesize[i],

  986.                                  width, height);

  987.         } else {

  988.             deinterlace_bottom_field(dst->data[i],dst->linesize[i],

  989.                                         src->data[i], src->linesize[i],

  990.                                         width, height);

  991.         }

  992.     }

  993. #ifdef HAVE_MMX

  994.     emms();

  995. #endif

  996.     return 0;

  997. }

  998. 

  999. #undef FIX