y4minput.c

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  *
  10  *  Based on code from the OggTheora software codec source code,
  11  *  Copyright (C) 2002-2010 The Xiph.Org Foundation and contributors.
  12  */
  13 #include <errno.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16
  17 #include "vpx/vpx_integer.h"
  18 #include "y4minput.h"
  19
  20 // Reads 'size' bytes from 'file' into 'buf' with some fault tolerance.
  21 // Returns true on success.
  22 static int file_read(void *buf, size_t size, FILE *file) {
  23   const int kMaxRetries = 5;
  24   int retry_count = 0;
  25   int file_error;
  26   size_t len = 0;
  27   do {
  28     const size_t n = fread((uint8_t*)buf + len, 1, size - len, file);
  29     len += n;
  30     file_error = ferror(file);
  31     if (file_error) {
  32       if (errno == EINTR || errno == EAGAIN) {
  33         clearerr(file);
  34         continue;
  35       } else {
  36         fprintf(stderr, "Error reading file: %u of %u bytes read, %d: %s\n",
  37                 (uint32_t)len, (uint32_t)size, errno, strerror(errno));
  38         return 0;
  39       }
  40     }
  41   } while (!feof(file) && len < size && ++retry_count < kMaxRetries);
  42
  43   if (!feof(file) && len != size) {
  44     fprintf(stderr, "Error reading file: %u of %u bytes read,"
  45                     " error: %d, retries: %d, %d: %s\n",
  46             (uint32_t)len, (uint32_t)size, file_error, retry_count,
  47             errno, strerror(errno));
  48   }
  49   return len == size;
  50 }
  51
  52 static int y4m_parse_tags(y4m_input *_y4m, char *_tags) {
  53   int   got_w;
  54   int   got_h;
  55   int   got_fps;
  56   int   got_interlace;
  57   int   got_par;
  58   int   got_chroma;
  59   char *p;
  60   char *q;
  61   got_w = got_h = got_fps = got_interlace = got_par = got_chroma = 0;
  62   for (p = _tags;; p = q) {
  63     /*Skip any leading spaces.*/
  64     while (*p == ' ')p++;
  65     /*If that's all we have, stop.*/
  66     if (p[0] == '\0')break;
  67     /*Find the end of this tag.*/
  68     for (q = p + 1; *q != '\0' && *q != ' '; q++);
  69     /*Process the tag.*/
  70     switch (p[0]) {
  71       case 'W': {
  72         if (sscanf(p + 1, "%d", &_y4m->pic_w) != 1)return -1;
  73         got_w = 1;
  74       }
  75       break;
  76       case 'H': {
  77         if (sscanf(p + 1, "%d", &_y4m->pic_h) != 1)return -1;
  78         got_h = 1;
  79       }
  80       break;
  81       case 'F': {
  82         if (sscanf(p + 1, "%d:%d", &_y4m->fps_n, &_y4m->fps_d) != 2) {
  83           return -1;
  84         }
  85         got_fps = 1;
  86       }
  87       break;
  88       case 'I': {
  89         _y4m->interlace = p[1];
  90         got_interlace = 1;
  91       }
  92       break;
  93       case 'A': {
  94         if (sscanf(p + 1, "%d:%d", &_y4m->par_n, &_y4m->par_d) != 2) {
  95           return -1;
  96         }
  97         got_par = 1;
  98       }
  99       break;
 100       case 'C': {
 101         if (q - p > 16)return -1;
 102         memcpy(_y4m->chroma_type, p + 1, q - p - 1);
 103         _y4m->chroma_type[q - p - 1] = '\0';
 104         got_chroma = 1;
 105       }
 106       break;
 107       /*Ignore unknown tags.*/
 108     }
 109   }
 110   if (!got_w || !got_h || !got_fps)return -1;
 111   if (!got_interlace)_y4m->interlace = '?';
 112   if (!got_par)_y4m->par_n = _y4m->par_d = 0;
 113   /*Chroma-type is not specified in older files, e.g., those generated by
 114      mplayer.*/
 115   if (!got_chroma)strcpy(_y4m->chroma_type, "420");
 116   return 0;
 117 }
 118
 119
 120
 121 /*All anti-aliasing filters in the following conversion functions are based on
 122    one of two window functions:
 123   The 6-tap Lanczos window (for down-sampling and shifts):
 124    sinc(\pi*t)*sinc(\pi*t/3), |t|<3  (sinc(t)==sin(t)/t)
 125    0,                         |t|>=3
 126   The 4-tap Mitchell window (for up-sampling):
 127    7|t|^3-12|t|^2+16/3,             |t|<1
 128    -(7/3)|x|^3+12|x|^2-20|x|+32/3,  |t|<2
 129    0,                               |t|>=2
 130   The number of taps is intentionally kept small to reduce computational
 131    overhead and limit ringing.
 132
 133   The taps from these filters are scaled so that their sum is 1, and the result
 134    is scaled by 128 and rounded to integers to create a filter whose
 135    intermediate values fit inside 16 bits.
 136   Coefficients are rounded in such a way as to ensure their sum is still 128,
 137    which is usually equivalent to normal rounding.
 138
 139   Conversions which require both horizontal and vertical filtering could
 140    have these steps pipelined, for less memory consumption and better cache
 141    performance, but we do them separately for simplicity.*/
 142
 143 #define OC_MINI(_a,_b)      ((_a)>(_b)?(_b):(_a))
 144 #define OC_MAXI(_a,_b)      ((_a)<(_b)?(_b):(_a))
 145 #define OC_CLAMPI(_a,_b,_c) (OC_MAXI(_a,OC_MINI(_b,_c)))
 146
 147 /*420jpeg chroma samples are sited like:
 148   Y-------Y-------Y-------Y-------
 149   |       |       |       |
 150   |   BR  |       |   BR  |
 151   |       |       |       |
 152   Y-------Y-------Y-------Y-------
 153   |       |       |       |
 154   |       |       |       |
 155   |       |       |       |
 156   Y-------Y-------Y-------Y-------
 157   |       |       |       |
 158   |   BR  |       |   BR  |
 159   |       |       |       |
 160   Y-------Y-------Y-------Y-------
 161   |       |       |       |
 162   |       |       |       |
 163   |       |       |       |
 164
 165   420mpeg2 chroma samples are sited like:
 166   Y-------Y-------Y-------Y-------
 167   |       |       |       |
 168   BR      |       BR      |
 169   |       |       |       |
 170   Y-------Y-------Y-------Y-------
 171   |       |       |       |
 172   |       |       |       |
 173   |       |       |       |
 174   Y-------Y-------Y-------Y-------
 175   |       |       |       |
 176   BR      |       BR      |
 177   |       |       |       |
 178   Y-------Y-------Y-------Y-------
 179   |       |       |       |
 180   |       |       |       |
 181   |       |       |       |
 182
 183   We use a resampling filter to shift the site locations one quarter pixel (at
 184    the chroma plane's resolution) to the right.
 185   The 4:2:2 modes look exactly the same, except there are twice as many chroma
 186    lines, and they are vertically co-sited with the luma samples in both the
 187    mpeg2 and jpeg cases (thus requiring no vertical resampling).*/
 188 static void y4m_42xmpeg2_42xjpeg_helper(unsigned char *_dst,
 189                                         const unsigned char *_src, int _c_w, int _c_h) {
 190   int y;
 191   int x;
 192   for (y = 0; y < _c_h; y++) {
 193     /*Filter: [4 -17 114 35 -9 1]/128, derived from a 6-tap Lanczos
 194        window.*/
 195     for (x = 0; x < OC_MINI(_c_w, 2); x++) {
 196       _dst[x] = (unsigned char)OC_CLAMPI(0, (4 * _src[0] - 17 * _src[OC_MAXI(x - 1, 0)] +
 197                                              114 * _src[x] + 35 * _src[OC_MINI(x + 1, _c_w - 1)] - 9 * _src[OC_MINI(x + 2, _c_w - 1)] +
 198                                              _src[OC_MINI(x + 3, _c_w - 1)] + 64) >> 7, 255);
 199     }
 200     for (; x < _c_w - 3; x++) {
 201       _dst[x] = (unsigned char)OC_CLAMPI(0, (4 * _src[x - 2] - 17 * _src[x - 1] +
 202                                              114 * _src[x] + 35 * _src[x + 1] - 9 * _src[x + 2] + _src[x + 3] + 64) >> 7, 255);
 203     }
 204     for (; x < _c_w; x++) {
 205       _dst[x] = (unsigned char)OC_CLAMPI(0, (4 * _src[x - 2] - 17 * _src[x - 1] +
 206                                              114 * _src[x] + 35 * _src[OC_MINI(x + 1, _c_w - 1)] - 9 * _src[OC_MINI(x + 2, _c_w - 1)] +
 207                                              _src[_c_w - 1] + 64) >> 7, 255);
 208     }
 209     _dst += _c_w;
 210     _src += _c_w;
 211   }
 212 }
 213
 214 /*Handles both 422 and 420mpeg2 to 422jpeg and 420jpeg, respectively.*/
 215 static void y4m_convert_42xmpeg2_42xjpeg(y4m_input *_y4m, unsigned char *_dst,
 216                                          unsigned char *_aux) {
 217   int c_w;
 218   int c_h;
 219   int c_sz;
 220   int pli;
 221   /*Skip past the luma data.*/
 222   _dst += _y4m->pic_w * _y4m->pic_h;
 223   /*Compute the size of each chroma plane.*/
 224   c_w = (_y4m->pic_w + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h;
 225   c_h = (_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v;
 226   c_sz = c_w * c_h;
 227   for (pli = 1; pli < 3; pli++) {
 228     y4m_42xmpeg2_42xjpeg_helper(_dst, _aux, c_w, c_h);
 229     _dst += c_sz;
 230     _aux += c_sz;
 231   }
 232 }
 233
 234 /*This format is only used for interlaced content, but is included for
 235    completeness.
 236
 237   420jpeg chroma samples are sited like:
 238   Y-------Y-------Y-------Y-------
 239   |       |       |       |
 240   |   BR  |       |   BR  |
 241   |       |       |       |
 242   Y-------Y-------Y-------Y-------
 243   |       |       |       |
 244   |       |       |       |
 245   |       |       |       |
 246   Y-------Y-------Y-------Y-------
 247   |       |       |       |
 248   |   BR  |       |   BR  |
 249   |       |       |       |
 250   Y-------Y-------Y-------Y-------
 251   |       |       |       |
 252   |       |       |       |
 253   |       |       |       |
 254
 255   420paldv chroma samples are sited like:
 256   YR------Y-------YR------Y-------
 257   |       |       |       |
 258   |       |       |       |
 259   |       |       |       |
 260   YB------Y-------YB------Y-------
 261   |       |       |       |
 262   |       |       |       |
 263   |       |       |       |
 264   YR------Y-------YR------Y-------
 265   |       |       |       |
 266   |       |       |       |
 267   |       |       |       |
 268   YB------Y-------YB------Y-------
 269   |       |       |       |
 270   |       |       |       |
 271   |       |       |       |
 272
 273   We use a resampling filter to shift the site locations one quarter pixel (at
 274    the chroma plane's resolution) to the right.
 275   Then we use another filter to move the C_r location down one quarter pixel,
 276    and the C_b location up one quarter pixel.*/
 277 static void y4m_convert_42xpaldv_42xjpeg(y4m_input *_y4m, unsigned char *_dst,
 278                                          unsigned char *_aux) {
 279   unsigned char *tmp;
 280   int            c_w;
 281   int            c_h;
 282   int            c_sz;
 283   int            pli;
 284   int            y;
 285   int            x;
 286   /*Skip past the luma data.*/
 287   _dst += _y4m->pic_w * _y4m->pic_h;
 288   /*Compute the size of each chroma plane.*/
 289   c_w = (_y4m->pic_w + 1) / 2;
 290   c_h = (_y4m->pic_h + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h;
 291   c_sz = c_w * c_h;
 292   tmp = _aux + 2 * c_sz;
 293   for (pli = 1; pli < 3; pli++) {
 294     /*First do the horizontal re-sampling.
 295       This is the same as the mpeg2 case, except that after the horizontal
 296        case, we need to apply a second vertical filter.*/
 297     y4m_42xmpeg2_42xjpeg_helper(tmp, _aux, c_w, c_h);
 298     _aux += c_sz;
 299     switch (pli) {
 300       case 1: {
 301         /*Slide C_b up a quarter-pel.
 302           This is the same filter used above, but in the other order.*/
 303         for (x = 0; x < c_w; x++) {
 304           for (y = 0; y < OC_MINI(c_h, 3); y++) {
 305             _dst[y * c_w] = (unsigned char)OC_CLAMPI(0, (tmp[0]
 306                                                          - 9 * tmp[OC_MAXI(y - 2, 0) * c_w] + 35 * tmp[OC_MAXI(y - 1, 0) * c_w]
 307                                                          + 114 * tmp[y * c_w] - 17 * tmp[OC_MINI(y + 1, c_h - 1) * c_w]
 308                                                          + 4 * tmp[OC_MINI(y + 2, c_h - 1) * c_w] + 64) >> 7, 255);
 309           }
 310           for (; y < c_h - 2; y++) {
 311             _dst[y * c_w] = (unsigned char)OC_CLAMPI(0, (tmp[(y - 3) * c_w]
 312                                                          - 9 * tmp[(y - 2) * c_w] + 35 * tmp[(y - 1) * c_w] + 114 * tmp[y * c_w]
 313                                                          - 17 * tmp[(y + 1) * c_w] + 4 * tmp[(y + 2) * c_w] + 64) >> 7, 255);
 314           }
 315           for (; y < c_h; y++) {
 316             _dst[y * c_w] = (unsigned char)OC_CLAMPI(0, (tmp[(y - 3) * c_w]
 317                                                          - 9 * tmp[(y - 2) * c_w] + 35 * tmp[(y - 1) * c_w] + 114 * tmp[y * c_w]
 318                                                          - 17 * tmp[OC_MINI(y + 1, c_h - 1) * c_w] + 4 * tmp[(c_h - 1) * c_w] + 64) >> 7, 255);
 319           }
 320           _dst++;
 321           tmp++;
 322         }
 323         _dst += c_sz - c_w;
 324         tmp -= c_w;
 325       }
 326       break;
 327       case 2: {
 328         /*Slide C_r down a quarter-pel.
 329           This is the same as the horizontal filter.*/
 330         for (x = 0; x < c_w; x++) {
 331           for (y = 0; y < OC_MINI(c_h, 2); y++) {
 332             _dst[y * c_w] = (unsigned char)OC_CLAMPI(0, (4 * tmp[0]
 333                                                          - 17 * tmp[OC_MAXI(y - 1, 0) * c_w] + 114 * tmp[y * c_w]
 334                                                          + 35 * tmp[OC_MINI(y + 1, c_h - 1) * c_w] - 9 * tmp[OC_MINI(y + 2, c_h - 1) * c_w]
 335                                                          + tmp[OC_MINI(y + 3, c_h - 1) * c_w] + 64) >> 7, 255);
 336           }
 337           for (; y < c_h - 3; y++) {
 338             _dst[y * c_w] = (unsigned char)OC_CLAMPI(0, (4 * tmp[(y - 2) * c_w]
 339                                                          - 17 * tmp[(y - 1) * c_w] + 114 * tmp[y * c_w] + 35 * tmp[(y + 1) * c_w]
 340                                                          - 9 * tmp[(y + 2) * c_w] + tmp[(y + 3) * c_w] + 64) >> 7, 255);
 341           }
 342           for (; y < c_h; y++) {
 343             _dst[y * c_w] = (unsigned char)OC_CLAMPI(0, (4 * tmp[(y - 2) * c_w]
 344                                                          - 17 * tmp[(y - 1) * c_w] + 114 * tmp[y * c_w] + 35 * tmp[OC_MINI(y + 1, c_h - 1) * c_w]
 345                                                          - 9 * tmp[OC_MINI(y + 2, c_h - 1) * c_w] + tmp[(c_h - 1) * c_w] + 64) >> 7, 255);
 346           }
 347           _dst++;
 348           tmp++;
 349         }
 350       }
 351       break;
 352     }
 353     /*For actual interlaced material, this would have to be done separately on
 354        each field, and the shift amounts would be different.
 355       C_r moves down 1/8, C_b up 3/8 in the top field, and C_r moves down 3/8,
 356        C_b up 1/8 in the bottom field.
 357       The corresponding filters would be:
 358        Down 1/8 (reverse order for up): [3 -11 125 15 -4 0]/128
 359        Down 3/8 (reverse order for up): [4 -19 98 56 -13 2]/128*/
 360   }
 361 }
 362
 363 /*Perform vertical filtering to reduce a single plane from 4:2:2 to 4:2:0.
 364   This is used as a helper by several converation routines.*/
 365 static void y4m_422jpeg_420jpeg_helper(unsigned char *_dst,
 366                                        const unsigned char *_src, int _c_w, int _c_h) {
 367   int y;
 368   int x;
 369   /*Filter: [3 -17 78 78 -17 3]/128, derived from a 6-tap Lanczos window.*/
 370   for (x = 0; x < _c_w; x++) {
 371     for (y = 0; y < OC_MINI(_c_h, 2); y += 2) {
 372       _dst[(y >> 1)*_c_w] = OC_CLAMPI(0, (64 * _src[0]
 373                                           + 78 * _src[OC_MINI(1, _c_h - 1) * _c_w]
 374                                           - 17 * _src[OC_MINI(2, _c_h - 1) * _c_w]
 375                                           + 3 * _src[OC_MINI(3, _c_h - 1) * _c_w] + 64) >> 7, 255);
 376     }
 377     for (; y < _c_h - 3; y += 2) {
 378       _dst[(y >> 1)*_c_w] = OC_CLAMPI(0, (3 * (_src[(y - 2) * _c_w] + _src[(y + 3) * _c_w])
 379                                           - 17 * (_src[(y - 1) * _c_w] + _src[(y + 2) * _c_w])
 380                                           + 78 * (_src[y * _c_w] + _src[(y + 1) * _c_w]) + 64) >> 7, 255);
 381     }
 382     for (; y < _c_h; y += 2) {
 383       _dst[(y >> 1)*_c_w] = OC_CLAMPI(0, (3 * (_src[(y - 2) * _c_w]
 384                                                + _src[(_c_h - 1) * _c_w]) - 17 * (_src[(y - 1) * _c_w]
 385                                                                                   + _src[OC_MINI(y + 2, _c_h - 1) * _c_w])
 386                                           + 78 * (_src[y * _c_w] + _src[OC_MINI(y + 1, _c_h - 1) * _c_w]) + 64) >> 7, 255);
 387     }
 388     _src++;
 389     _dst++;
 390   }
 391 }
 392
 393 /*420jpeg chroma samples are sited like:
 394   Y-------Y-------Y-------Y-------
 395   |       |       |       |
 396   |   BR  |       |   BR  |
 397   |       |       |       |
 398   Y-------Y-------Y-------Y-------
 399   |       |       |       |
 400   |       |       |       |
 401   |       |       |       |
 402   Y-------Y-------Y-------Y-------
 403   |       |       |       |
 404   |   BR  |       |   BR  |
 405   |       |       |       |
 406   Y-------Y-------Y-------Y-------
 407   |       |       |       |
 408   |       |       |       |
 409   |       |       |       |
 410
 411   422jpeg chroma samples are sited like:
 412   Y---BR--Y-------Y---BR--Y-------
 413   |       |       |       |
 414   |       |       |       |
 415   |       |       |       |
 416   Y---BR--Y-------Y---BR--Y-------
 417   |       |       |       |
 418   |       |       |       |
 419   |       |       |       |
 420   Y---BR--Y-------Y---BR--Y-------
 421   |       |       |       |
 422   |       |       |       |
 423   |       |       |       |
 424   Y---BR--Y-------Y---BR--Y-------
 425   |       |       |       |
 426   |       |       |       |
 427   |       |       |       |
 428
 429   We use a resampling filter to decimate the chroma planes by two in the
 430    vertical direction.*/
 431 static void y4m_convert_422jpeg_420jpeg(y4m_input *_y4m, unsigned char *_dst,
 432                                         unsigned char *_aux) {
 433   int c_w;
 434   int c_h;
 435   int c_sz;
 436   int dst_c_w;
 437   int dst_c_h;
 438   int dst_c_sz;
 439   int pli;
 440   /*Skip past the luma data.*/
 441   _dst += _y4m->pic_w * _y4m->pic_h;
 442   /*Compute the size of each chroma plane.*/
 443   c_w = (_y4m->pic_w + _y4m->src_c_dec_h - 1) / _y4m->src_c_dec_h;
 444   c_h = _y4m->pic_h;
 445   dst_c_w = (_y4m->pic_w + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h;
 446   dst_c_h = (_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v;
 447   c_sz = c_w * c_h;
 448   dst_c_sz = dst_c_w * dst_c_h;
 449   for (pli = 1; pli < 3; pli++) {
 450     y4m_422jpeg_420jpeg_helper(_dst, _aux, c_w, c_h);
 451     _aux += c_sz;
 452     _dst += dst_c_sz;
 453   }
 454 }
 455
 456 /*420jpeg chroma samples are sited like:
 457   Y-------Y-------Y-------Y-------
 458   |       |       |       |
 459   |   BR  |       |   BR  |
 460   |       |       |       |
 461   Y-------Y-------Y-------Y-------
 462   |       |       |       |
 463   |       |       |       |
 464   |       |       |       |
 465   Y-------Y-------Y-------Y-------
 466   |       |       |       |
 467   |   BR  |       |   BR  |
 468   |       |       |       |
 469   Y-------Y-------Y-------Y-------
 470   |       |       |       |
 471   |       |       |       |
 472   |       |       |       |
 473
 474   422 chroma samples are sited like:
 475   YBR-----Y-------YBR-----Y-------
 476   |       |       |       |
 477   |       |       |       |
 478   |       |       |       |
 479   YBR-----Y-------YBR-----Y-------
 480   |       |       |       |
 481   |       |       |       |
 482   |       |       |       |
 483   YBR-----Y-------YBR-----Y-------
 484   |       |       |       |
 485   |       |       |       |
 486   |       |       |       |
 487   YBR-----Y-------YBR-----Y-------
 488   |       |       |       |
 489   |       |       |       |
 490   |       |       |       |
 491
 492   We use a resampling filter to shift the original site locations one quarter
 493    pixel (at the original chroma resolution) to the right.
 494   Then we use a second resampling filter to decimate the chroma planes by two
 495    in the vertical direction.*/
 496 static void y4m_convert_422_420jpeg(y4m_input *_y4m, unsigned char *_dst,
 497                                     unsigned char *_aux) {
 498   unsigned char *tmp;
 499   int            c_w;
 500   int            c_h;
 501   int            c_sz;
 502   int            dst_c_h;
 503   int            dst_c_sz;
 504   int            pli;
 505   /*Skip past the luma data.*/
 506   _dst += _y4m->pic_w * _y4m->pic_h;
 507   /*Compute the size of each chroma plane.*/
 508   c_w = (_y4m->pic_w + _y4m->src_c_dec_h - 1) / _y4m->src_c_dec_h;
 509   c_h = _y4m->pic_h;
 510   dst_c_h = (_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v;
 511   c_sz = c_w * c_h;
 512   dst_c_sz = c_w * dst_c_h;
 513   tmp = _aux + 2 * c_sz;
 514   for (pli = 1; pli < 3; pli++) {
 515     /*In reality, the horizontal and vertical steps could be pipelined, for
 516        less memory consumption and better cache performance, but we do them
 517        separately for simplicity.*/
 518     /*First do horizontal filtering (convert to 422jpeg)*/
 519     y4m_42xmpeg2_42xjpeg_helper(tmp, _aux, c_w, c_h);
 520     /*Now do the vertical filtering.*/
 521     y4m_422jpeg_420jpeg_helper(_dst, tmp, c_w, c_h);
 522     _aux += c_sz;
 523     _dst += dst_c_sz;
 524   }
 525 }
 526
 527 /*420jpeg chroma samples are sited like:
 528   Y-------Y-------Y-------Y-------
 529   |       |       |       |
 530   |   BR  |       |   BR  |
 531   |       |       |       |
 532   Y-------Y-------Y-------Y-------
 533   |       |       |       |
 534   |       |       |       |
 535   |       |       |       |
 536   Y-------Y-------Y-------Y-------
 537   |       |       |       |
 538   |   BR  |       |   BR  |
 539   |       |       |       |
 540   Y-------Y-------Y-------Y-------
 541   |       |       |       |
 542   |       |       |       |
 543   |       |       |       |
 544
 545   411 chroma samples are sited like:
 546   YBR-----Y-------Y-------Y-------
 547   |       |       |       |
 548   |       |       |       |
 549   |       |       |       |
 550   YBR-----Y-------Y-------Y-------
 551   |       |       |       |
 552   |       |       |       |
 553   |       |       |       |
 554   YBR-----Y-------Y-------Y-------
 555   |       |       |       |
 556   |       |       |       |
 557   |       |       |       |
 558   YBR-----Y-------Y-------Y-------
 559   |       |       |       |
 560   |       |       |       |
 561   |       |       |       |
 562
 563   We use a filter to resample at site locations one eighth pixel (at the source
 564    chroma plane's horizontal resolution) and five eighths of a pixel to the
 565    right.
 566   Then we use another filter to decimate the planes by 2 in the vertical
 567    direction.*/
 568 static void y4m_convert_411_420jpeg(y4m_input *_y4m, unsigned char *_dst,
 569                                     unsigned char *_aux) {
 570   unsigned char *tmp;
 571   int            c_w;
 572   int            c_h;
 573   int            c_sz;
 574   int            dst_c_w;
 575   int            dst_c_h;
 576   int            dst_c_sz;
 577   int            tmp_sz;
 578   int            pli;
 579   int            y;
 580   int            x;
 581   /*Skip past the luma data.*/
 582   _dst += _y4m->pic_w * _y4m->pic_h;
 583   /*Compute the size of each chroma plane.*/
 584   c_w = (_y4m->pic_w + _y4m->src_c_dec_h - 1) / _y4m->src_c_dec_h;
 585   c_h = _y4m->pic_h;
 586   dst_c_w = (_y4m->pic_w + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h;
 587   dst_c_h = (_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v;
 588   c_sz = c_w * c_h;
 589   dst_c_sz = dst_c_w * dst_c_h;
 590   tmp_sz = dst_c_w * c_h;
 591   tmp = _aux + 2 * c_sz;
 592   for (pli = 1; pli < 3; pli++) {
 593     /*In reality, the horizontal and vertical steps could be pipelined, for
 594        less memory consumption and better cache performance, but we do them
 595        separately for simplicity.*/
 596     /*First do horizontal filtering (convert to 422jpeg)*/
 597     for (y = 0; y < c_h; y++) {
 598       /*Filters: [1 110 18 -1]/128 and [-3 50 86 -5]/128, both derived from a
 599          4-tap Mitchell window.*/
 600       for (x = 0; x < OC_MINI(c_w, 1); x++) {
 601         tmp[x << 1] = (unsigned char)OC_CLAMPI(0, (111 * _aux[0]
 602                                                    + 18 * _aux[OC_MINI(1, c_w - 1)] - _aux[OC_MINI(2, c_w - 1)] + 64) >> 7, 255);
 603         tmp[x << 1 | 1] = (unsigned char)OC_CLAMPI(0, (47 * _aux[0]
 604                                                        + 86 * _aux[OC_MINI(1, c_w - 1)] - 5 * _aux[OC_MINI(2, c_w - 1)] + 64) >> 7, 255);
 605       }
 606       for (; x < c_w - 2; x++) {
 607         tmp[x << 1] = (unsigned char)OC_CLAMPI(0, (_aux[x - 1] + 110 * _aux[x]
 608                                                    + 18 * _aux[x + 1] - _aux[x + 2] + 64) >> 7, 255);
 609         tmp[x << 1 | 1] = (unsigned char)OC_CLAMPI(0, (-3 * _aux[x - 1] + 50 * _aux[x]
 610                                                        + 86 * _aux[x + 1] - 5 * _aux[x + 2] + 64) >> 7, 255);
 611       }
 612       for (; x < c_w; x++) {
 613         tmp[x << 1] = (unsigned char)OC_CLAMPI(0, (_aux[x - 1] + 110 * _aux[x]
 614                                                    + 18 * _aux[OC_MINI(x + 1, c_w - 1)] - _aux[c_w - 1] + 64) >> 7, 255);
 615         if ((x << 1 | 1) < dst_c_w) {
 616           tmp[x << 1 | 1] = (unsigned char)OC_CLAMPI(0, (-3 * _aux[x - 1] + 50 * _aux[x]
 617                                                          + 86 * _aux[OC_MINI(x + 1, c_w - 1)] - 5 * _aux[c_w - 1] + 64) >> 7, 255);
 618         }
 619       }
 620       tmp += dst_c_w;
 621       _aux += c_w;
 622     }
 623     tmp -= tmp_sz;
 624     /*Now do the vertical filtering.*/
 625     y4m_422jpeg_420jpeg_helper(_dst, tmp, dst_c_w, c_h);
 626     _dst += dst_c_sz;
 627   }
 628 }
 629
 630 /*Convert 444 to 420jpeg.*/
 631 static void y4m_convert_444_420jpeg(y4m_input *_y4m, unsigned char *_dst,
 632                                     unsigned char *_aux) {
 633   unsigned char *tmp;
 634   int            c_w;
 635   int            c_h;
 636   int            c_sz;
 637   int            dst_c_w;
 638   int            dst_c_h;
 639   int            dst_c_sz;
 640   int            tmp_sz;
 641   int            pli;
 642   int            y;
 643   int            x;
 644   /*Skip past the luma data.*/
 645   _dst += _y4m->pic_w * _y4m->pic_h;
 646   /*Compute the size of each chroma plane.*/
 647   c_w = (_y4m->pic_w + _y4m->src_c_dec_h - 1) / _y4m->src_c_dec_h;
 648   c_h = _y4m->pic_h;
 649   dst_c_w = (_y4m->pic_w + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h;
 650   dst_c_h = (_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v;
 651   c_sz = c_w * c_h;
 652   dst_c_sz = dst_c_w * dst_c_h;
 653   tmp_sz = dst_c_w * c_h;
 654   tmp = _aux + 2 * c_sz;
 655   for (pli = 1; pli < 3; pli++) {
 656     /*Filter: [3 -17 78 78 -17 3]/128, derived from a 6-tap Lanczos window.*/
 657     for (y = 0; y < c_h; y++) {
 658       for (x = 0; x < OC_MINI(c_w, 2); x += 2) {
 659         tmp[x >> 1] = OC_CLAMPI(0, (64 * _aux[0] + 78 * _aux[OC_MINI(1, c_w - 1)]
 660                                     - 17 * _aux[OC_MINI(2, c_w - 1)]
 661                                     + 3 * _aux[OC_MINI(3, c_w - 1)] + 64) >> 7, 255);
 662       }
 663       for (; x < c_w - 3; x += 2) {
 664         tmp[x >> 1] = OC_CLAMPI(0, (3 * (_aux[x - 2] + _aux[x + 3])
 665                                     - 17 * (_aux[x - 1] + _aux[x + 2]) + 78 * (_aux[x] + _aux[x + 1]) + 64) >> 7, 255);
 666       }
 667       for (; x < c_w; x += 2) {
 668         tmp[x >> 1] = OC_CLAMPI(0, (3 * (_aux[x - 2] + _aux[c_w - 1]) -
 669                                     17 * (_aux[x - 1] + _aux[OC_MINI(x + 2, c_w - 1)]) +
 670                                     78 * (_aux[x] + _aux[OC_MINI(x + 1, c_w - 1)]) + 64) >> 7, 255);
 671       }
 672       tmp += dst_c_w;
 673       _aux += c_w;
 674     }
 675     tmp -= tmp_sz;
 676     /*Now do the vertical filtering.*/
 677     y4m_422jpeg_420jpeg_helper(_dst, tmp, dst_c_w, c_h);
 678     _dst += dst_c_sz;
 679   }
 680 }
 681
 682 /*The image is padded with empty chroma components at 4:2:0.*/
 683 static void y4m_convert_mono_420jpeg(y4m_input *_y4m, unsigned char *_dst,
 684                                      unsigned char *_aux) {
 685   int c_sz;
 686   _dst += _y4m->pic_w * _y4m->pic_h;
 687   c_sz = ((_y4m->pic_w + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h) *
 688          ((_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v);
 689   memset(_dst, 128, c_sz * 2);
 690 }
 691
 692 /*No conversion function needed.*/
 693 static void y4m_convert_null(y4m_input *_y4m, unsigned char *_dst,
 694                              unsigned char *_aux) {
 695 }
 696
 697 int y4m_input_open(y4m_input *_y4m, FILE *_fin, char *_skip, int _nskip,
 698                    int only_420) {
 699   char buffer[80];
 700   int  ret;
 701   int  i;
 702   /*Read until newline, or 80 cols, whichever happens first.*/
 703   for (i = 0; i < 79; i++) {
 704     if (_nskip > 0) {
 705       buffer[i] = *_skip++;
 706       _nskip--;
 707     } else {
 708       if (!file_read(buffer + i, 1, _fin)) return -1;
 709     }
 710     if (buffer[i] == '\n')break;
 711   }
 712   /*We skipped too much header data.*/
 713   if (_nskip > 0)return -1;
 714   if (i == 79) {
 715     fprintf(stderr, "Error parsing header; not a YUV2MPEG2 file?\n");
 716     return -1;
 717   }
 718   buffer[i] = '\0';
 719   if (memcmp(buffer, "YUV4MPEG", 8)) {
 720     fprintf(stderr, "Incomplete magic for YUV4MPEG file.\n");
 721     return -1;
 722   }
 723   if (buffer[8] != '2') {
 724     fprintf(stderr, "Incorrect YUV input file version; YUV4MPEG2 required.\n");
 725   }
 726   ret = y4m_parse_tags(_y4m, buffer + 5);
 727   if (ret < 0) {
 728     fprintf(stderr, "Error parsing YUV4MPEG2 header.\n");
 729     return ret;
 730   }
 731   if (_y4m->interlace == '?') {
 732     fprintf(stderr, "Warning: Input video interlacing format unknown; "
 733             "assuming progressive scan.\n");
 734   } else if (_y4m->interlace != 'p') {
 735     fprintf(stderr, "Input video is interlaced; "
 736             "Only progressive scan handled.\n");
 737     return -1;
 738   }
 739   _y4m->vpx_fmt = VPX_IMG_FMT_I420;
 740   _y4m->vpx_bps = 12;
 741   if (strcmp(_y4m->chroma_type, "420") == 0 ||
 742       strcmp(_y4m->chroma_type, "420jpeg") == 0) {
 743     _y4m->src_c_dec_h = _y4m->dst_c_dec_h = _y4m->src_c_dec_v = _y4m->dst_c_dec_v = 2;
 744     _y4m->dst_buf_read_sz = _y4m->pic_w * _y4m->pic_h
 745                             + 2 * ((_y4m->pic_w + 1) / 2) * ((_y4m->pic_h + 1) / 2);
 746     /*Natively supported: no conversion required.*/
 747     _y4m->aux_buf_sz = _y4m->aux_buf_read_sz = 0;
 748     _y4m->convert = y4m_convert_null;
 749   } else if (strcmp(_y4m->chroma_type, "420mpeg2") == 0) {
 750     _y4m->src_c_dec_h = _y4m->dst_c_dec_h = _y4m->src_c_dec_v = _y4m->dst_c_dec_v = 2;
 751     _y4m->dst_buf_read_sz = _y4m->pic_w * _y4m->pic_h;
 752     /*Chroma filter required: read into the aux buf first.*/
 753     _y4m->aux_buf_sz = _y4m->aux_buf_read_sz =
 754                          2 * ((_y4m->pic_w + 1) / 2) * ((_y4m->pic_h + 1) / 2);
 755     _y4m->convert = y4m_convert_42xmpeg2_42xjpeg;
 756   } else if (strcmp(_y4m->chroma_type, "420paldv") == 0) {
 757     _y4m->src_c_dec_h = _y4m->dst_c_dec_h = _y4m->src_c_dec_v = _y4m->dst_c_dec_v = 2;
 758     _y4m->dst_buf_read_sz = _y4m->pic_w * _y4m->pic_h;
 759     /*Chroma filter required: read into the aux buf first.
 760       We need to make two filter passes, so we need some extra space in the
 761        aux buffer.*/
 762     _y4m->aux_buf_sz = 3 * ((_y4m->pic_w + 1) / 2) * ((_y4m->pic_h + 1) / 2);
 763     _y4m->aux_buf_read_sz = 2 * ((_y4m->pic_w + 1) / 2) * ((_y4m->pic_h + 1) / 2);
 764     _y4m->convert = y4m_convert_42xpaldv_42xjpeg;
 765   } else if (strcmp(_y4m->chroma_type, "422jpeg") == 0) {
 766     _y4m->src_c_dec_h = _y4m->dst_c_dec_h = 2;
 767     _y4m->src_c_dec_v = 1;
 768     _y4m->dst_c_dec_v = 2;
 769     _y4m->dst_buf_read_sz = _y4m->pic_w * _y4m->pic_h;
 770     /*Chroma filter required: read into the aux buf first.*/
 771     _y4m->aux_buf_sz = _y4m->aux_buf_read_sz = 2 * ((_y4m->pic_w + 1) / 2) * _y4m->pic_h;
 772     _y4m->convert = y4m_convert_422jpeg_420jpeg;
 773   } else if (strcmp(_y4m->chroma_type, "422") == 0) {
 774     _y4m->src_c_dec_h = 2;
 775     _y4m->src_c_dec_v = 1;
 776     if (only_420) {
 777       _y4m->dst_c_dec_h = 2;
 778       _y4m->dst_c_dec_v = 2;
 779       _y4m->dst_buf_read_sz = _y4m->pic_w * _y4m->pic_h;
 780       /*Chroma filter required: read into the aux buf first.
 781         We need to make two filter passes, so we need some extra space in the
 782          aux buffer.*/
 783       _y4m->aux_buf_read_sz = 2 * ((_y4m->pic_w + 1) / 2) * _y4m->pic_h;
 784       _y4m->aux_buf_sz = _y4m->aux_buf_read_sz +
 785           ((_y4m->pic_w + 1) / 2) * _y4m->pic_h;
 786       _y4m->convert = y4m_convert_422_420jpeg;
 787     } else {
 788       _y4m->vpx_fmt = VPX_IMG_FMT_I422;
 789       _y4m->vpx_bps = 16;
 790       _y4m->dst_c_dec_h = _y4m->src_c_dec_h;
 791       _y4m->dst_c_dec_v = _y4m->src_c_dec_v;
 792       _y4m->dst_buf_read_sz = _y4m->pic_w * _y4m->pic_h
 793                               + 2 * ((_y4m->pic_w + 1) / 2) * _y4m->pic_h;
 794       /*Natively supported: no conversion required.*/
 795       _y4m->aux_buf_sz = _y4m->aux_buf_read_sz = 0;
 796       _y4m->convert = y4m_convert_null;
 797       }
 798   } else if (strcmp(_y4m->chroma_type, "411") == 0) {
 799     _y4m->src_c_dec_h = 4;
 800     _y4m->dst_c_dec_h = 2;
 801     _y4m->src_c_dec_v = 1;
 802     _y4m->dst_c_dec_v = 2;
 803     _y4m->dst_buf_read_sz = _y4m->pic_w * _y4m->pic_h;
 804     /*Chroma filter required: read into the aux buf first.
 805       We need to make two filter passes, so we need some extra space in the
 806        aux buffer.*/
 807     _y4m->aux_buf_read_sz = 2 * ((_y4m->pic_w + 3) / 4) * _y4m->pic_h;
 808     _y4m->aux_buf_sz = _y4m->aux_buf_read_sz + ((_y4m->pic_w + 1) / 2) * _y4m->pic_h;
 809     _y4m->convert = y4m_convert_411_420jpeg;
 810   } else if (strcmp(_y4m->chroma_type, "444") == 0) {
 811     _y4m->src_c_dec_h = 1;
 812     _y4m->src_c_dec_v = 1;
 813     if (only_420) {
 814       _y4m->dst_c_dec_h = 2;
 815       _y4m->dst_c_dec_v = 2;
 816       _y4m->dst_buf_read_sz = _y4m->pic_w * _y4m->pic_h;
 817       /*Chroma filter required: read into the aux buf first.
 818         We need to make two filter passes, so we need some extra space in the
 819          aux buffer.*/
 820       _y4m->aux_buf_read_sz = 2 * _y4m->pic_w * _y4m->pic_h;
 821       _y4m->aux_buf_sz = _y4m->aux_buf_read_sz +
 822           ((_y4m->pic_w + 1) / 2) * _y4m->pic_h;
 823       _y4m->convert = y4m_convert_444_420jpeg;
 824     } else {
 825       _y4m->vpx_fmt = VPX_IMG_FMT_I444;
 826       _y4m->vpx_bps = 24;
 827       _y4m->dst_c_dec_h = _y4m->src_c_dec_h;
 828       _y4m->dst_c_dec_v = _y4m->src_c_dec_v;
 829       _y4m->dst_buf_read_sz = 3 * _y4m->pic_w * _y4m->pic_h;
 830       /*Natively supported: no conversion required.*/
 831       _y4m->aux_buf_sz = _y4m->aux_buf_read_sz = 0;
 832       _y4m->convert = y4m_convert_null;
 833     }
 834   } else if (strcmp(_y4m->chroma_type, "444alpha") == 0) {
 835     _y4m->src_c_dec_h = 1;
 836     _y4m->src_c_dec_v = 1;
 837     if (only_420) {
 838       _y4m->dst_c_dec_h = 2;
 839       _y4m->dst_c_dec_v = 2;
 840       _y4m->dst_buf_read_sz = _y4m->pic_w * _y4m->pic_h;
 841       /*Chroma filter required: read into the aux buf first.
 842         We need to make two filter passes, so we need some extra space in the
 843          aux buffer.
 844         The extra plane also gets read into the aux buf.
 845         It will be discarded.*/
 846       _y4m->aux_buf_sz = _y4m->aux_buf_read_sz = 3 * _y4m->pic_w * _y4m->pic_h;
 847       _y4m->convert = y4m_convert_444_420jpeg;
 848     } else {
 849       _y4m->vpx_fmt = VPX_IMG_FMT_444A;
 850       _y4m->vpx_bps = 32;
 851       _y4m->dst_c_dec_h = _y4m->src_c_dec_h;
 852       _y4m->dst_c_dec_v = _y4m->src_c_dec_v;
 853       _y4m->dst_buf_read_sz = 4 * _y4m->pic_w * _y4m->pic_h;
 854       /*Natively supported: no conversion required.*/
 855       _y4m->aux_buf_sz = _y4m->aux_buf_read_sz = 0;
 856       _y4m->convert = y4m_convert_null;
 857     }
 858   } else if (strcmp(_y4m->chroma_type, "mono") == 0) {
 859     _y4m->src_c_dec_h = _y4m->src_c_dec_v = 0;
 860     _y4m->dst_c_dec_h = _y4m->dst_c_dec_v = 2;
 861     _y4m->dst_buf_read_sz = _y4m->pic_w * _y4m->pic_h;
 862     /*No extra space required, but we need to clear the chroma planes.*/
 863     _y4m->aux_buf_sz = _y4m->aux_buf_read_sz = 0;
 864     _y4m->convert = y4m_convert_mono_420jpeg;
 865   } else {
 866     fprintf(stderr, "Unknown chroma sampling type: %s\n", _y4m->chroma_type);
 867     return -1;
 868   }
 869   /*The size of the final frame buffers is always computed from the
 870      destination chroma decimation type.*/
 871   _y4m->dst_buf_sz = _y4m->pic_w * _y4m->pic_h
 872                      + 2 * ((_y4m->pic_w + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h) *
 873                      ((_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v);
 874   _y4m->dst_buf = (unsigned char *)malloc(_y4m->dst_buf_sz);
 875   _y4m->aux_buf = (unsigned char *)malloc(_y4m->aux_buf_sz);
 876   return 0;
 877 }
 878
 879 void y4m_input_close(y4m_input *_y4m) {
 880   free(_y4m->dst_buf);
 881   free(_y4m->aux_buf);
 882 }
 883
 884 int y4m_input_fetch_frame(y4m_input *_y4m, FILE *_fin, vpx_image_t *_img) {
 885   char frame[6];
 886   int  pic_sz;
 887   int  c_w;
 888   int  c_h;
 889   int  c_sz;
 890   /*Read and skip the frame header.*/
 891   if (!file_read(frame, 6, _fin)) return 0;
 892   if (memcmp(frame, "FRAME", 5)) {
 893     fprintf(stderr, "Loss of framing in Y4M input data\n");
 894     return -1;
 895   }
 896   if (frame[5] != '\n') {
 897     char c;
 898     int  j;
 899     for (j = 0; j < 79 && file_read(&c, 1, _fin) && c != '\n'; j++) {}
 900     if (j == 79) {
 901       fprintf(stderr, "Error parsing Y4M frame header\n");
 902       return -1;
 903     }
 904   }
 905   /*Read the frame data that needs no conversion.*/
 906   if (!file_read(_y4m->dst_buf, _y4m->dst_buf_read_sz, _fin)) {
 907     fprintf(stderr, "Error reading Y4M frame data.\n");
 908     return -1;
 909   }
 910   /*Read the frame data that does need conversion.*/
 911   if (!file_read(_y4m->aux_buf, _y4m->aux_buf_read_sz, _fin)) {
 912     fprintf(stderr, "Error reading Y4M frame data.\n");
 913     return -1;
 914   }
 915   /*Now convert the just read frame.*/
 916   (*_y4m->convert)(_y4m, _y4m->dst_buf, _y4m->aux_buf);
 917   /*Fill in the frame buffer pointers.
 918     We don't use vpx_img_wrap() because it forces padding for odd picture
 919      sizes, which would require a separate fread call for every row.*/
 920   memset(_img, 0, sizeof(*_img));
 921   /*Y4M has the planes in Y'CbCr order, which libvpx calls Y, U, and V.*/
 922   _img->fmt = _y4m->vpx_fmt;
 923   _img->w = _img->d_w = _y4m->pic_w;
 924   _img->h = _img->d_h = _y4m->pic_h;
 925   _img->x_chroma_shift = _y4m->dst_c_dec_h >> 1;
 926   _img->y_chroma_shift = _y4m->dst_c_dec_v >> 1;
 927   _img->bps = _y4m->vpx_bps;
 928
 929   /*Set up the buffer pointers.*/
 930   pic_sz = _y4m->pic_w * _y4m->pic_h;
 931   c_w = (_y4m->pic_w + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h;
 932   c_h = (_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v;
 933   c_sz = c_w * c_h;
 934   _img->stride[PLANE_Y] = _img->stride[PLANE_ALPHA] = _y4m->pic_w;
 935   _img->stride[PLANE_U] = _img->stride[PLANE_V] = c_w;
 936   _img->planes[PLANE_Y] = _y4m->dst_buf;
 937   _img->planes[PLANE_U] = _y4m->dst_buf + pic_sz;
 938   _img->planes[PLANE_V] = _y4m->dst_buf + pic_sz + c_sz;
 939   _img->planes[PLANE_ALPHA] = _y4m->dst_buf + pic_sz + 2 * c_sz;
 940   return 1;
 941 }