[svn] / branches / dev-api-3 / xvidcore / src / image / image.c Repository:
ViewVC logotype

Diff of /branches/dev-api-3/xvidcore/src/image/image.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 449, Sun Sep 8 09:49:55 2002 UTC revision 586, Wed Oct 9 15:56:16 2002 UTC
# Line 3  Line 3 
3   *      XVID MPEG-4 VIDEO CODEC   *      XVID MPEG-4 VIDEO CODEC
4   *      image stuff   *      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   *      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   *      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   *      the Free Software Foundation; either version 2 of the License, or
# Line 23  Line 32 
32   *   *
33   *      History:   *      History:
34   *   *
35     *  05.10.2002  support for interpolated images in qpel mode - Isibaar
36   *      01.05.2002      BFRAME image-based u,v interpolation   *      01.05.2002      BFRAME image-based u,v interpolation
37   *  22.04.2002  added some B-frame support   *  22.04.2002  added some B-frame support
38   *      14.04.2002      added image_dump_yuvpgm(), added image_mad()   *      14.04.2002      added image_dump_yuvpgm(), added image_mad()
39   *              XVID_CSP_USER input support   *              XVID_CSP_USER input support
40   *  09.04.2002  PSNR calculations   *  09.04.2002  PSNR calculations - Isibaar
41   *      06.04.2002      removed interlaced edging from U,V blocks (as per spec)   *      06.04.2002      removed interlaced edging from U,V blocks (as per spec)
42   *  26.03.2002  interlacing support (field-based edging in set_edges)   *  26.03.2002  interlacing support (field-based edging in set_edges)
43   *      26.01.2002      rgb555, rgb565   *      26.01.2002      rgb555, rgb565
# Line 151  Line 161 
161                             uint32_t edged_width,                             uint32_t edged_width,
162                             uint32_t edged_height,                             uint32_t edged_height,
163                             uint32_t width,                             uint32_t width,
164                             uint32_t height,                             uint32_t height)
                            uint32_t interlacing)  
165  {  {
166          const uint32_t edged_width2 = edged_width / 2;          const uint32_t edged_width2 = edged_width / 2;
167          const uint32_t width2 = width / 2;          const uint32_t width2 = width / 2;
# Line 165  Line 174 
174          src = image->y;          src = image->y;
175    
176          for (i = 0; i < EDGE_SIZE; i++) {          for (i = 0; i < EDGE_SIZE; i++) {
 /*              // if interlacing, edges contain top-most data from each field  
                 if (interlacing && (i & 1)) {  
                         memset(dst, *(src + edged_width), EDGE_SIZE);  
                         memcpy(dst + EDGE_SIZE, src + edged_width, width);  
                         memset(dst + edged_width - EDGE_SIZE,  
                                    *(src + edged_width + width - 1), EDGE_SIZE);  
                 } else {*/  
177                          memset(dst, *src, EDGE_SIZE);                          memset(dst, *src, EDGE_SIZE);
178                          memcpy(dst + EDGE_SIZE, src, width);                          memcpy(dst + EDGE_SIZE, src, width);
179                          memset(dst + edged_width - EDGE_SIZE, *(src + width - 1),                          memset(dst + edged_width - EDGE_SIZE, *(src + width - 1),
180                                     EDGE_SIZE);                                     EDGE_SIZE);
                 /*}*/  
181                  dst += edged_width;                  dst += edged_width;
182          }          }
183    
# Line 189  Line 190 
190    
191          src -= edged_width;          src -= edged_width;
192          for (i = 0; i < EDGE_SIZE; i++) {          for (i = 0; i < EDGE_SIZE; i++) {
 /*              // if interlacing, edges contain bottom-most data from each field  
                 if (interlacing && !(i & 1)) {  
                         memset(dst, *(src - edged_width), EDGE_SIZE);  
                         memcpy(dst + EDGE_SIZE, src - edged_width, width);  
                         memset(dst + edged_width - EDGE_SIZE,  
                                    *(src - edged_width + width - 1), EDGE_SIZE);  
                 } else {*/  
193                          memset(dst, *src, EDGE_SIZE);                          memset(dst, *src, EDGE_SIZE);
194                          memcpy(dst + EDGE_SIZE, src, width);                          memcpy(dst + EDGE_SIZE, src, width);
195                          memset(dst + edged_width - EDGE_SIZE, *(src + width - 1),                          memset(dst + edged_width - EDGE_SIZE, *(src + width - 1),
196                                     EDGE_SIZE);                                     EDGE_SIZE);
                 /*}*/  
197                  dst += edged_width;                  dst += edged_width;
198          }          }
199    
# Line 261  Line 254 
254          }          }
255  }  }
256    
257    // bframe encoding requires image-based u,v interpolation
 // image-based y,u,v interpolation  
258  void  void
259  image_interpolate(const IMAGE * refn,  image_interpolate(const IMAGE * refn,
260                                    IMAGE * refh,                                    IMAGE * refh,
# Line 270  Line 262 
262                                    IMAGE * refhv,                                    IMAGE * refhv,
263                                    uint32_t edged_width,                                    uint32_t edged_width,
264                                    uint32_t edged_height,                                    uint32_t edged_height,
265                                      uint32_t quarterpel,
266                                    uint32_t rounding)                                    uint32_t rounding)
267  {  {
268          const uint32_t offset = EDGE_SIZE * (edged_width + 1);          const uint32_t offset = EDGE_SIZE2 * (edged_width + 1); // we only interpolate half of the edge area
269          const uint32_t stride_add = 7 * edged_width;          const uint32_t stride_add = 7 * edged_width;
270    /*
271          /* --- u,v-image-based interpolation ---  #ifdef BFRAMES
272          const uint32_t edged_width2 = edged_width / 2;          const uint32_t edged_width2 = edged_width / 2;
273          const uint32_t edged_height2 = edged_height / 2;          const uint32_t edged_height2 = edged_height / 2;
274          const uint32_t offset2 = EDGE_SIZE2 * (edged_width2 + 1);          const uint32_t offset2 = EDGE_SIZE2 * (edged_width2 + 1);
275          const uint32_t stride_add2 = 7 * edged_width2;          const uint32_t stride_add2 = 7 * edged_width2;
276    #endif
277          */          */
   
278          uint8_t *n_ptr, *h_ptr, *v_ptr, *hv_ptr;          uint8_t *n_ptr, *h_ptr, *v_ptr, *hv_ptr;
279          uint32_t x, y;          uint32_t x, y;
280    
# Line 296  Line 289 
289          v_ptr -= offset;          v_ptr -= offset;
290          hv_ptr -= offset;          hv_ptr -= offset;
291    
292          for (y = 0; y < edged_height; y = y + 8) {          if(quarterpel) {
293                  for (x = 0; x < edged_width; x = x + 8) {  
294                    for (y = 0; y < (edged_height - EDGE_SIZE); y += 8) {
295                            for (x = 0; x < (edged_width - EDGE_SIZE); x += 8) {
296                                    interpolate8x8_6tap_lowpass_h(h_ptr, n_ptr, edged_width, rounding);
297                                    interpolate8x8_6tap_lowpass_v(v_ptr, n_ptr, edged_width, rounding);
298    
299                                    n_ptr += 8;
300                                    h_ptr += 8;
301                                    v_ptr += 8;
302                            }
303    
304                            n_ptr += EDGE_SIZE;
305                            h_ptr += EDGE_SIZE;
306                            v_ptr += EDGE_SIZE;
307    
308                            h_ptr += stride_add;
309                            v_ptr += stride_add;
310                            n_ptr += stride_add;
311                    }
312    
313                    h_ptr = refh->y;
314                    h_ptr -= offset;
315    
316                    for (y = 0; y < (edged_height - EDGE_SIZE); y = y + 8) {
317                            for (x = 0; x < (edged_width - EDGE_SIZE); x = x + 8) {
318                                    interpolate8x8_6tap_lowpass_v(hv_ptr, h_ptr, edged_width, rounding);
319                                    hv_ptr += 8;
320                                    h_ptr += 8;
321                            }
322    
323                            hv_ptr += EDGE_SIZE2;
324                            h_ptr += EDGE_SIZE2;
325    
326                            hv_ptr += stride_add;
327                            h_ptr += stride_add;
328                    }
329            }
330            else {
331    
332                    for (y = 0; y < (edged_height - EDGE_SIZE); y += 8) {
333                            for (x = 0; x < (edged_width - EDGE_SIZE); x += 8) {
334                          interpolate8x8_halfpel_h(h_ptr, n_ptr, edged_width, rounding);                          interpolate8x8_halfpel_h(h_ptr, n_ptr, edged_width, rounding);
335                          interpolate8x8_halfpel_v(v_ptr, n_ptr, edged_width, rounding);                          interpolate8x8_halfpel_v(v_ptr, n_ptr, edged_width, rounding);
336                          interpolate8x8_halfpel_hv(hv_ptr, n_ptr, edged_width, rounding);                          interpolate8x8_halfpel_hv(hv_ptr, n_ptr, edged_width, rounding);
# Line 307  Line 340 
340                          v_ptr += 8;                          v_ptr += 8;
341                          hv_ptr += 8;                          hv_ptr += 8;
342                  }                  }
343    
344                            h_ptr += EDGE_SIZE;
345                            v_ptr += EDGE_SIZE;
346                            hv_ptr += EDGE_SIZE;
347                            n_ptr += EDGE_SIZE;
348    
349                  h_ptr += stride_add;                  h_ptr += stride_add;
350                  v_ptr += stride_add;                  v_ptr += stride_add;
351                  hv_ptr += stride_add;                  hv_ptr += stride_add;
352                  n_ptr += stride_add;                  n_ptr += stride_add;
353          }          }
354            }
355  /* --- u,v-image-based interpolation ---  /*
356    #ifdef BFRAMES
357          n_ptr = refn->u;          n_ptr = refn->u;
358          h_ptr = refh->u;          h_ptr = refh->u;
359          v_ptr = refv->u;          v_ptr = refv->u;
# Line 324  Line 364 
364          v_ptr -= offset2;          v_ptr -= offset2;
365          hv_ptr -= offset2;          hv_ptr -= offset2;
366    
367          for (y = 0; y < edged_height2; y = y + 8) {          for (y = 0; y < edged_height2; y += 8) {
368                  for (x = 0; x < edged_width2; x = x + 8) {                  for (x = 0; x < edged_width2; x += 8) {
369                          interpolate8x8_halfpel_h(h_ptr, n_ptr, edged_width2, rounding);                          interpolate8x8_halfpel_h(h_ptr, n_ptr, edged_width2, rounding);
370                          interpolate8x8_halfpel_v(v_ptr, n_ptr, edged_width2, rounding);                          interpolate8x8_halfpel_v(v_ptr, n_ptr, edged_width2, rounding);
371                          interpolate8x8_halfpel_hv(hv_ptr, n_ptr, edged_width2, rounding);                          interpolate8x8_halfpel_hv(hv_ptr, n_ptr, edged_width2, rounding);
# Line 367  Line 407 
407                  hv_ptr += stride_add2;                  hv_ptr += stride_add2;
408                  n_ptr += stride_add2;                  n_ptr += stride_add2;
409          }          }
410    #endif
411    */
412            /*
413               interpolate_halfpel_h(
414               refh->y - offset,
415               refn->y - offset,
416               edged_width, edged_height,
417               rounding);
418    
419               interpolate_halfpel_v(
420               refv->y - offset,
421               refn->y - offset,
422               edged_width, edged_height,
423               rounding);
424    
425               interpolate_halfpel_hv(
426               refhv->y - offset,
427               refn->y - offset,
428               edged_width, edged_height,
429               rounding);
430             */
431    
432            /* uv-image-based compensation
433               offset = EDGE_SIZE2 * (edged_width / 2 + 1);
434    
435               interpolate_halfpel_h(
436               refh->u - offset,
437               refn->u - offset,
438               edged_width / 2, edged_height / 2,
439               rounding);
440    
441               interpolate_halfpel_v(
442               refv->u - offset,
443               refn->u - offset,
444               edged_width / 2, edged_height / 2,
445               rounding);
446    
447               interpolate_halfpel_hv(
448               refhv->u - offset,
449               refn->u - offset,
450               edged_width / 2, edged_height / 2,
451               rounding);
452    
453    
454               interpolate_halfpel_h(
455               refh->v - offset,
456               refn->v - offset,
457               edged_width / 2, edged_height / 2,
458               rounding);
459    
460               interpolate_halfpel_v(
461               refv->v - offset,
462               refn->v - offset,
463               edged_width / 2, edged_height / 2,
464               rounding);
465    
466               interpolate_halfpel_hv(
467               refhv->v - offset,
468               refn->v - offset,
469               edged_width / 2, edged_height / 2,
470               rounding);
471  */  */
472  }  }
473    
# Line 461  Line 562 
562                  height = -height;                  height = -height;
563          }          }
564    
565            // --- xvid 2.1 compatiblity patch ---
566            // --- remove when xvid_dec_frame->stride equals real stride
567            if ((csp & ~XVID_CSP_VFLIP) == XVID_CSP_RGB555 ||
568                    (csp & ~XVID_CSP_VFLIP) == XVID_CSP_RGB565 ||
569                    (csp & ~XVID_CSP_VFLIP) == XVID_CSP_YUY2 ||
570                    (csp & ~XVID_CSP_VFLIP) == XVID_CSP_YVYU ||
571                    (csp & ~XVID_CSP_VFLIP) == XVID_CSP_UYVY)
572            {
573                    dst_stride *= 2;
574            }
575            else if ((csp & ~XVID_CSP_VFLIP) == XVID_CSP_RGB24)
576            {
577                    dst_stride *= 3;
578            }
579            else if ((csp & ~XVID_CSP_VFLIP) == XVID_CSP_RGB32 ||
580                    (csp & ~XVID_CSP_VFLIP) == XVID_CSP_ABGR ||
581                    (csp & ~XVID_CSP_VFLIP) == XVID_CSP_RGBA)
582            {
583                    dst_stride *= 4;
584            }
585            // ^--- xvid 2.1 compatiblity fix ---^
586    
587    
588          switch (csp & ~XVID_CSP_VFLIP) {          switch (csp & ~XVID_CSP_VFLIP) {
589          case XVID_CSP_RGB555:          case XVID_CSP_RGB555:
590                  yv12_to_rgb555(dst, dst_stride, image->y, image->u, image->v,                  yv12_to_rgb555(dst, dst_stride, image->y, image->u, image->v,
# Line 482  Line 606 
606                                            edged_width, edged_width / 2, width, height);                                            edged_width, edged_width / 2, width, height);
607                  return 0;                  return 0;
608    
609            case XVID_CSP_ABGR:
610                    yv12_to_abgr(dst, dst_stride, image->y, image->u, image->v,
611                                              edged_width, edged_width / 2, width, height);
612                    return 0;
613    
614            case XVID_CSP_RGBA:
615                    yv12_to_rgba(dst, dst_stride, image->y, image->u, image->v,
616                                              edged_width, edged_width / 2, width, height);
617                    return 0;
618    
619          case XVID_CSP_I420:          case XVID_CSP_I420:
620                  yv12_to_yuv(dst, dst_stride, image->y, image->u, image->v, edged_width,                  yv12_to_yuv(dst, dst_stride, image->y, image->u, image->v, edged_width,
621                                          edged_width / 2, width, height);                                          edged_width / 2, width, height);

Legend:
Removed from v.449  
changed lines
  Added in v.586

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4