开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
image.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：16k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

image.c：源码内容
  1. /**************************************************************************
  2.  *
  3.  * XVID MPEG-4 VIDEO CODEC
  4.  * image stuff
  5.  *
  6.  * This program is an implementation of a part of one or more MPEG-4
  7.  * Video tools as specified in ISO/IEC 14496-2 standard.  Those intending
  8.  * to use this software module in hardware or software products are
  9.  * advised that its use may infringe existing patents or copyrights, and
  10.  * any such use would be at such party's own risk.  The original
  11.  * developer of this software module and his/her company, and subsequent
  12.  * editors and their companies, will have no liability for use of this
  13.  * software or modifications or derivatives thereof.
  14.  *
  15.  * This program is free software; you can redistribute it and/or modify
  16.  * it under the terms of the GNU General Public License as published by
  17.  * the Free Software Foundation; either version 2 of the License, or
  18.  * (at your option) any later version.
  19.  *
  20.  * This program is distributed in the hope that it will be useful,
  21.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23.  * GNU General Public License for more details.
  24.  *
  25.  * You should have received a copy of the GNU General Public License
  26.  * along with this program; if not, write to the Free Software
  27.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  28.  *
  29.  *************************************************************************/
  31. /**************************************************************************
  32.  *
  33.  * History:
  34.  *
  35.  *  09.04.2002  PSNR calculations
  36.  * 06.04.2002 removed interlaced edging from U,V blocks (as per spec)
  37.  *  26.03.2002  interlacing support (field-based edging in set_edges)
  38.  * 26.01.2002 rgb555, rgb565
  39.  * 07.01.2001 commented u,v interpolation (not required for uv-block-based)
  40.  *  23.12.2001  removed #ifdefs, added function pointers + init_common()
  41.  * 22.12.2001 cpu #ifdefs
  42.  *  19.12.2001  image_dump(); useful for debugging
  43.  *  6.12.2001 inital version; (c)2001 peter ross <pross@cs.rmit.edu.au>
  44.  *
  45.  *************************************************************************/
  48. #include <stdlib.h>
  49. #include <string.h>  // memcpy, memset
  50. #include <math.h>
  52. #include "../portab.h"
  53. #include "../xvid.h"       // XVID_CSP_XXX's
  54. #include "image.h"
  55. #include "colorspace.h"
  56. #include "interpolate8x8.h"
  57. #include "../divx4.h"    
  58. #include "../utils/mem_align.h"
  60. #define SAFETY 64
  61. #define EDGE_SIZE2  (EDGE_SIZE/2)
  64. int32_t image_create(IMAGE * image, uint32_t edged_width, uint32_t edged_height)
  65. {
  66. const uint32_t edged_width2 = edged_width / 2;
  67. const uint32_t edged_height2 = edged_height / 2;
  68. uint32_t i;
  70. image->y = xvid_malloc(edged_width * (edged_height + 1) + SAFETY, CACHE_LINE);
  71. if (image->y == NULL)
  72. {
  73. return -1;
  74. }
  76. for (i=0;i < edged_width * edged_height + SAFETY;i++)
  77. {
  78. image->y[i]=0;
  79. }
  81. image->u = xvid_malloc(edged_width2 * edged_height2 + SAFETY, CACHE_LINE);
  82. if (image->u == NULL)
  83. {
  84. xvid_free(image->y);
  85. return -1;
  86. }
  87. image->v = xvid_malloc(edged_width2 * edged_height2 + SAFETY, CACHE_LINE);
  88. if (image->v == NULL)
  89. {
  90. xvid_free(image->u);
  91. xvid_free(image->y);
  92. return -1;
  93. }
  95. image->y += EDGE_SIZE * edged_width + EDGE_SIZE;
  96. image->u += EDGE_SIZE2 * edged_width2 + EDGE_SIZE2;
  97. image->v += EDGE_SIZE2 * edged_width2 + EDGE_SIZE2;
  99. return 0;
  100. }
  104. void image_destroy(IMAGE * image, uint32_t edged_width, uint32_t edged_height)
  105. {
  106. const uint32_t edged_width2 = edged_width / 2;
  108. if (image->y)
  109. {
  110. xvid_free(image->y - (EDGE_SIZE * edged_width + EDGE_SIZE) );
  111. }
  112. if (image->u)
  113. {
  114. xvid_free(image->u - (EDGE_SIZE2 * edged_width2 + EDGE_SIZE2));
  115. }
  116. if (image->v)
  117. {
  118. xvid_free(image->v - (EDGE_SIZE2 * edged_width2 + EDGE_SIZE2));
  119. }
  120. }
  123. void image_swap(IMAGE * image1, IMAGE * image2)
  124. {
  125.     uint8_t * tmp;
  127.     tmp = image1->y;
  128. image1->y = image2->y;
  129. image2->y = tmp;
  131.     tmp = image1->u;
  132. image1->u = image2->u;
  133. image2->u = tmp;
  135.     tmp = image1->v;
  136. image1->v = image2->v;
  137. image2->v = tmp;
  138. }
  141. void image_copy(IMAGE *image1, IMAGE * image2, uint32_t edged_width, uint32_t height)
  142. {
  143. memcpy(image1->y, image2->y, edged_width * height);
  144. memcpy(image1->u, image2->u, edged_width * height / 4);
  145. memcpy(image1->v, image2->v, edged_width * height / 4);
  146. }
  149. void image_setedges(IMAGE * image, uint32_t edged_width, uint32_t edged_height, uint32_t width, uint32_t height, uint32_t interlacing)
  150. {
  151. const uint32_t edged_width2 = edged_width / 2;
  152. const uint32_t width2 = width / 2;
  153. uint32_t i;
  154. uint8_t * dst;
  155. uint8_t * src;
  157.    
  158.     dst = image->y - (EDGE_SIZE + EDGE_SIZE * edged_width);
  159.     src = image->y;
  161.     for (i = 0; i < EDGE_SIZE; i++)
  162.     {
  163. // if interlacing, edges contain top-most data from each field
  164. if (interlacing && (i & 1))
  165. {
  166. memset(dst, *(src + edged_width), EDGE_SIZE);
  167. memcpy(dst + EDGE_SIZE, src + edged_width, width);
  168. memset(dst + edged_width - EDGE_SIZE, *(src + edged_width + width - 1), EDGE_SIZE);
  169. }
  170. else
  171. {
  172. memset(dst, *src, EDGE_SIZE);
  173. memcpy(dst + EDGE_SIZE, src, width);
  174. memset(dst + edged_width - EDGE_SIZE, *(src + width - 1), EDGE_SIZE);
  175. }
  176. dst += edged_width;
  177.     }
  179.     for (i = 0; i < height; i++)
  180.     {
  181. memset(dst, *src, EDGE_SIZE);
  182. memset(dst + edged_width - EDGE_SIZE, src[width - 1], EDGE_SIZE);
  183. dst += edged_width;
  184. src += edged_width;
  185.     }
  186.     
  187. src -= edged_width;
  188.     for (i = 0; i < EDGE_SIZE; i++)
  189.     {
  190. // if interlacing, edges contain bottom-most data from each field
  191. if (interlacing && !(i & 1))
  192. {
  193. memset(dst, *(src - edged_width), EDGE_SIZE);
  194. memcpy(dst + EDGE_SIZE, src - edged_width, width);
  195. memset(dst + edged_width - EDGE_SIZE, *(src - edged_width + width - 1), EDGE_SIZE);
  196. }
  197. else
  198. {
  199. memset(dst, *src, EDGE_SIZE);
  200. memcpy(dst + EDGE_SIZE, src, width);
  201. memset(dst + edged_width - EDGE_SIZE, *(src + width - 1), EDGE_SIZE);
  202. }
  203. dst += edged_width;
  204.     }
  207. //U
  208.     dst = image->u - (EDGE_SIZE2 + EDGE_SIZE2 * edged_width2);
  209.     src = image->u;
  211.     for (i = 0; i < EDGE_SIZE2; i++)
  212. {
  213. memset(dst, *src, EDGE_SIZE2);
  214. memcpy(dst + EDGE_SIZE2, src, width2);
  215. memset(dst + edged_width2 - EDGE_SIZE2, *(src + width2 - 1), EDGE_SIZE2);
  216. dst += edged_width2;
  217.     }
  219.     for (i = 0; i < height / 2; i++)
  220.     {
  221. memset(dst, *src, EDGE_SIZE2);
  222. memset(dst + edged_width2 - EDGE_SIZE2, src[width2 - 1], EDGE_SIZE2);
  223. dst += edged_width2;
  224. src += edged_width2;
  225.     }
  226.     src -= edged_width2;
  227.     for (i = 0; i < EDGE_SIZE2; i++)
  228. {
  229. memset(dst, *src, EDGE_SIZE2);
  230. memcpy(dst + EDGE_SIZE2, src, width2);
  231. memset(dst + edged_width2 - EDGE_SIZE2, *(src + width2 - 1), EDGE_SIZE2);
  232. dst += edged_width2;
  233.     }
  236. // V
  237. dst = image->v - (EDGE_SIZE2 + EDGE_SIZE2 * edged_width2);
  238. src = image->v;
  240. for (i = 0; i < EDGE_SIZE2; i++)
  241. {
  242. memset(dst, *src, EDGE_SIZE2);
  243. memcpy(dst + EDGE_SIZE2, src, width2);
  244. memset(dst + edged_width2 - EDGE_SIZE2, *(src + width2 - 1), EDGE_SIZE2);
  245. dst += edged_width2;
  246.     }
  247.     
  248. for (i = 0; i < height / 2; i++)
  249.     {
  250. memset(dst, *src, EDGE_SIZE2);
  251. memset(dst + edged_width2 - EDGE_SIZE2, src[width2 - 1], EDGE_SIZE2);
  252. dst += edged_width2;
  253. src += edged_width2;
  254.     }
  255.     src -= edged_width2;
  256.     for (i = 0; i < EDGE_SIZE2; i++)
  257. {
  258. memset(dst, *src, EDGE_SIZE2);
  259. memcpy(dst + EDGE_SIZE2, src, width2);
  260. memset(dst + edged_width2 - EDGE_SIZE2, *(src + width2 - 1), EDGE_SIZE2);
  261. dst += edged_width2;
  262. }
  263. }
  266. void image_interpolate(const IMAGE * refn, 
  267.    IMAGE * refh, IMAGE * refv, IMAGE * refhv, 
  268.    uint32_t edged_width, uint32_t edged_height, uint32_t rounding)
  269. {
  270.     uint32_t offset;
  271. uint8_t *n_ptr, *h_ptr, *v_ptr, *hv_ptr;
  272. uint32_t x,y;
  274. uint32_t stride_add = 7 * edged_width;
  276. offset = EDGE_SIZE * (edged_width + 1);
  278. n_ptr = refn->y;
  279. h_ptr = refh->y;
  280. v_ptr = refv->y;
  281. hv_ptr = refhv->y;
  283. n_ptr -= offset;
  284. h_ptr -= offset;
  285. v_ptr -= offset;
  286. hv_ptr -= offset;
  288. for(y = 0; y < edged_height; y = y + 8) {
  289. for(x = 0; x < edged_width; x = x + 8) {
  290. interpolate8x8_halfpel_h(h_ptr, n_ptr, edged_width, rounding);
  291. interpolate8x8_halfpel_v(v_ptr, n_ptr, edged_width, rounding);
  292. interpolate8x8_halfpel_hv(hv_ptr, n_ptr, edged_width, rounding);
  294. n_ptr += 8;
  295. h_ptr += 8;
  296. v_ptr += 8;
  297. hv_ptr += 8;
  298. }
  299. h_ptr += stride_add;
  300. v_ptr += stride_add;
  301. hv_ptr += stride_add;
  302. n_ptr += stride_add;
  303. }
  304. /*
  305. interpolate_halfpel_h(
  306. refh->y - offset,
  307. refn->y - offset, 
  308. edged_width, edged_height,
  309. rounding);
  311. interpolate_halfpel_v(
  312. refv->y - offset,
  313. refn->y - offset, 
  314. edged_width, edged_height,
  315. rounding);
  317. interpolate_halfpel_hv(
  318. refhv->y - offset,
  319. refn->y - offset,
  320. edged_width, edged_height,
  321. rounding);
  322. */
  324. /* uv-image-based compensation
  325. offset = EDGE_SIZE2 * (edged_width / 2 + 1);
  327.     interpolate_halfpel_h(
  328. refh->u - offset,
  329. refn->u - offset, 
  330. edged_width / 2, edged_height / 2,
  331. rounding);
  333.     interpolate_halfpel_v(
  334. refv->u - offset,
  335. refn->u - offset, 
  336. edged_width / 2, edged_height / 2,
  337. rounding);
  339.     interpolate_halfpel_hv(
  340. refhv->u - offset,
  341. refn->u - offset, 
  342. edged_width / 2, edged_height / 2,
  343. rounding);
  346.     interpolate_halfpel_h(
  347. refh->v - offset,
  348. refn->v - offset, 
  349. edged_width / 2, edged_height / 2,
  350. rounding);
  352.     interpolate_halfpel_v(
  353. refv->v - offset,
  354. refn->v - offset, 
  355. edged_width / 2, edged_height / 2,
  356. rounding);
  358. interpolate_halfpel_hv(
  359. refhv->v - offset,
  360. refn->v - offset, 
  361. edged_width / 2, edged_height / 2,
  362. rounding);
  363. */
  364. }
  367. int image_input(IMAGE * image, uint32_t width, int height, 
  368. uint32_t edged_width, uint8_t * src, int csp)
  369. {
  371. /* if (csp & XVID_CSP_VFLIP)
  372. {
  373. height = -height;
  374. }
  375. */
  377. switch(csp & ~XVID_CSP_VFLIP)
  378. {
  379. case XVID_CSP_RGB555 :
  380. rgb555_to_yv12(image->y, image->u, image->v, src, 
  381. width, height, edged_width);
  382. return 0;
  384. case XVID_CSP_RGB565 :
  385. rgb565_to_yv12(image->y, image->u, image->v, src, 
  386. width, height, edged_width);
  387. return 0;
  390. case XVID_CSP_RGB24 :
  391. rgb24_to_yv12(image->y, image->u, image->v, src, 
  392. width, height, edged_width);
  393. return 0;
  395. case XVID_CSP_RGB32 :
  396. rgb32_to_yv12(image->y, image->u, image->v, src, 
  397. width, height, edged_width);
  398. return 0;
  400. case XVID_CSP_I420 :
  401. yuv_to_yv12(image->y, image->u, image->v, src, 
  402. width, height, edged_width);
  403. return 0;
  405. case XVID_CSP_YV12 : /* u/v swapped */
  406. yuv_to_yv12(image->y, image->v, image->u, src, 
  407. width, height, edged_width);
  408. return 0;
  410. case XVID_CSP_YUY2 :
  411. yuyv_to_yv12(image->y, image->u, image->v, src, 
  412. width, height, edged_width);
  413. return 0;
  415. case XVID_CSP_YVYU : /* u/v swapped */
  416. yuyv_to_yv12(image->y, image->v, image->u, src, 
  417. width, height, edged_width);
  418. return 0;
  420. case XVID_CSP_UYVY :
  421. uyvy_to_yv12(image->y, image->u, image->v, src, 
  422. width, height, edged_width);
  423. return 0;
  425. case XVID_CSP_NULL :
  426. break;
  428.     }
  430. return -1;
  431. }
  435. int image_output(IMAGE * image, uint32_t width, int height, uint32_t edged_width,
  436. uint8_t * dst, uint32_t dst_stride, int csp)
  437. {
  438. if (csp & XVID_CSP_VFLIP)
  439. {
  440. height = -height;
  441. }
  443. switch(csp & ~XVID_CSP_VFLIP)
  444. {
  445. case XVID_CSP_RGB555 :
  446. yv12_to_rgb555(dst, dst_stride,
  447. image->y, image->u, image->v, edged_width, edged_width / 2,
  448. width, height);
  449. return 0;
  451. case XVID_CSP_RGB565 :
  452. yv12_to_rgb565(dst, dst_stride,
  453. image->y, image->u, image->v, edged_width, edged_width / 2,
  454. width, height);
  455. return 0;
  457. case XVID_CSP_RGB24 :
  458. yv12_to_rgb24(dst, dst_stride,
  459. image->y, image->u, image->v, edged_width, edged_width / 2,
  460. width, height);
  461. return 0;
  463. case XVID_CSP_RGB32 :
  464. yv12_to_rgb32(dst, dst_stride,
  465. image->y, image->u, image->v, edged_width, edged_width / 2,
  466. width, height);
  467. return 0;
  469. case XVID_CSP_I420 :
  470. yv12_to_yuv(dst, dst_stride,
  471. image->y, image->u, image->v, edged_width, edged_width / 2,
  472. width, height);
  473. return 0;
  475. case XVID_CSP_YV12 : // u,v swapped
  476. yv12_to_yuv(dst, dst_stride,
  477. image->y, image->v, image->u, edged_width, edged_width / 2,
  478. width, height);
  479. return 0;
  481. case XVID_CSP_YUY2 :
  482. yv12_to_yuyv(dst, dst_stride,
  483. image->y, image->u, image->v, edged_width, edged_width / 2,
  484. width, height);
  485. return 0;
  487. case XVID_CSP_YVYU : // u,v swapped
  488. yv12_to_yuyv(dst, dst_stride,
  489. image->y, image->v, image->u, edged_width, edged_width / 2,
  490. width, height);
  491. return 0;
  493. case XVID_CSP_UYVY :
  494. yv12_to_uyvy(dst, dst_stride,
  495. image->y, image->u, image->v, edged_width, edged_width / 2,
  496. width, height);
  497. return 0;
  499.         case XVID_CSP_USER :
  500.                 ((DEC_PICTURE*)dst)->y = image->y;
  501.                 ((DEC_PICTURE*)dst)->u = image->u;
  502.                 ((DEC_PICTURE*)dst)->v = image->v;
  503.                 ((DEC_PICTURE*)dst)->stride_y = edged_width;
  504.                 ((DEC_PICTURE*)dst)->stride_uv = edged_width/2;
  505.                 return 0;
  506.                                  
  507. case XVID_CSP_NULL :
  508. return 0;
  510. }
  512. return -1;
  513. }
  515. float image_psnr(IMAGE *orig_image, IMAGE *recon_image,
  516.               uint16_t stride, uint16_t width, uint16_t height)
  517. {
  518.     int32_t diff, x, y, quad = 0;
  519.     uint8_t *orig = orig_image->y;
  520. uint8_t *recon = recon_image->y;
  521.     float psnr_y;
  522.     
  523.     for (y = 0; y < height; y++) {
  524.         for (x = 0; x < width; x++) {
  525.             diff = *(orig + x) - *(recon + x);
  526.             quad += diff*diff;
  527.         }
  528.         orig += stride;
  529.         recon += stride;
  530.     }
  531.    
  532.     psnr_y = (float) quad / (float) (width * height);
  533.     
  534.     if (psnr_y) {
  535.         psnr_y = (float) (255 * 255) / psnr_y;
  536.         psnr_y = 10 * (float) log10 (psnr_y); 
  537.     } 
  538. else
  539.         psnr_y = (float) 99.99;
  541. return psnr_y;
  542. }
  544. #include <stdio.h>
  545. #include <string.h>
  547. int image_dump_pgm(uint8_t * bmp, uint32_t width, uint32_t height, char * filename)
  548. {
  549. FILE * f;
  550. char hdr[1024];
  552. f = fopen(filename, "wb");
  553. if ( f == NULL)
  554. {
  555. return -1;
  556. }
  557. sprintf(hdr, "P5n#xvidn%i %in255n", width, height);
  558. fwrite(hdr, strlen(hdr), 1, f);
  559. fwrite(bmp, width, height, f);
  560. fclose(f);
  562. return 0;
  563. }
  566. /* dump image+edges to yuv pgm files */
  568. int image_dump(IMAGE * image, uint32_t edged_width, uint32_t edged_height, char * path, int number)
  569. {
  570. char filename[1024];
  572. sprintf(filename, "%s_%i_%c.pgm", path, number, 'y');
  573. image_dump_pgm(
  574. image->y - (EDGE_SIZE * edged_width + EDGE_SIZE),
  575. edged_width, edged_height, filename);
  577. sprintf(filename, "%s_%i_%c.pgm", path, number, 'u');
  578. image_dump_pgm(
  579. image->u - (EDGE_SIZE2 * edged_width / 2 + EDGE_SIZE2),
  580. edged_width / 2, edged_height / 2, filename);
  582. sprintf(filename, "%s_%i_%c.pgm", path, number, 'v');
  583. image_dump_pgm(
  584. image->v - (EDGE_SIZE2 * edged_width / 2 + EDGE_SIZE2),
  585. edged_width / 2, edged_height / 2, filename);
  587. return 0;
  588. }
  590. #ifdef MPEG4IP
  591. int yuv_input(
  592. IMAGE * image, 
  593. uint32_t width, 
  594. uint32_t height, 
  595. uint32_t stride_out, 
  596. uint8_t *y_in, 
  597. uint8_t *u_in, 
  598. uint8_t *v_in, 
  599. uint32_t stride_in, 
  600. int csp)
  601. {
  602. uint8_t* y_out = image->y;
  603. uint8_t* u_out = image->u;
  604. uint8_t* v_out = image->v;
  606. uint32_t stridein2 = stride_in >> 1;
  607. uint32_t strideout2 = stride_out >> 1;
  608. uint32_t width2 = width >> 1;
  610.     uint32_t y;
  612. for (y = height; y; y--) {
  613.     memcpy(y_out, y_in, width);
  614.     y_in += stride_in;
  615. y_out += stride_out;
  616. }
  618. for (y = height >> 1; y; y--) {
  619.     memcpy(u_out, u_in, width2);
  620. u_in += stridein2;
  621. u_out += strideout2;
  622. }
  624. for (y = height >> 1; y; y--) {
  625.     memcpy(v_out, v_in, width2);
  626. v_in += stridein2;
  627. v_out+= strideout2;
  628. }
  630. return 0;
  631. }
  632. #endif