| /* | |
| * Copyright (c) 2016, Alliance for Open Media. All rights reserved. | |
| * | |
| * This source code is subject to the terms of the BSD 2 Clause License and | |
| * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License | |
| * was not distributed with this source code in the LICENSE file, you can | |
| * obtain it at www.aomedia.org/license/software. If the Alliance for Open | |
| * Media Patent License 1.0 was not distributed with this source code in the | |
| * PATENTS file, you can obtain it at www.aomedia.org/license/patent. | |
| * | |
| * Based on code from the OggTheora software codec source code, | |
| * Copyright (C) 2002-2010 The Xiph.Org Foundation and contributors. | |
| */ | |
| #include <assert.h> | |
| #include <errno.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include "aom/aom_integer.h" | |
| #include "y4minput.h" | |
| // Reads 'size' bytes from 'file' into 'buf' with some fault tolerance. | |
| // Returns true on success. | |
| static int file_read(void *buf, size_t size, FILE *file) { | |
| const int kMaxTries = 5; | |
| int try_count = 0; | |
| int file_error = 0; | |
| size_t len = 0; | |
| while (!feof(file) && len < size && try_count < kMaxTries) { | |
| const size_t n = fread((uint8_t *)buf + len, 1, size - len, file); | |
| ++try_count; | |
| len += n; | |
| file_error = ferror(file); | |
| if (file_error) { | |
| if (errno == EINTR || errno == EAGAIN) { | |
| clearerr(file); | |
| continue; | |
| } else { | |
| fprintf(stderr, "Error reading file: %u of %u bytes read, %d: %s\n", | |
| (uint32_t)len, (uint32_t)size, errno, strerror(errno)); | |
| return 0; | |
| } | |
| } | |
| } | |
| if (!feof(file) && len != size) { | |
| fprintf(stderr, | |
| "Error reading file: %u of %u bytes read," | |
| " error: %d, tries: %d, %d: %s\n", | |
| (uint32_t)len, (uint32_t)size, file_error, try_count, errno, | |
| strerror(errno)); | |
| } | |
| return len == size; | |
| } | |
| // Stores the color range in 'y4m_ctx', returning 1 if successfully parsed, | |
| // 0 otherwise. | |
| static int parse_color_range(y4m_input *y4m_ctx, const char *buf) { | |
| // Note that default is studio range. | |
| if (strcmp(buf, "LIMITED") == 0) { | |
| return 1; | |
| } | |
| if (strcmp(buf, "FULL") == 0) { | |
| y4m_ctx->color_range = AOM_CR_FULL_RANGE; | |
| return 1; | |
| } | |
| fprintf(stderr, "Unknown color range value: %s\n", buf); | |
| return 0; | |
| } | |
| static int parse_metadata(y4m_input *y4m_ctx, const char *buf) { | |
| if (strncmp(buf, "COLORRANGE=", 11) == 0) { | |
| return parse_color_range(y4m_ctx, buf + 11); | |
| } | |
| return 1; // No support for other metadata, just ignore them. | |
| } | |
| static int y4m_parse_tags(y4m_input *_y4m, char *_tags) { | |
| char *p; | |
| char *q; | |
| for (p = _tags;; p = q) { | |
| /*Skip any leading spaces.*/ | |
| while (*p == ' ') p++; | |
| /*If that's all we have, stop.*/ | |
| if (p[0] == '\0') break; | |
| /*Find the end of this tag.*/ | |
| for (q = p + 1; *q != '\0' && *q != ' '; q++) { | |
| } | |
| /*Process the tag.*/ | |
| switch (p[0]) { | |
| case 'W': { | |
| if (sscanf(p + 1, "%d", &_y4m->pic_w) != 1) return -1; | |
| } break; | |
| case 'H': { | |
| if (sscanf(p + 1, "%d", &_y4m->pic_h) != 1) return -1; | |
| } break; | |
| case 'F': { | |
| if (sscanf(p + 1, "%d:%d", &_y4m->fps_n, &_y4m->fps_d) != 2) { | |
| return -1; | |
| } | |
| } break; | |
| case 'I': { | |
| _y4m->interlace = p[1]; | |
| } break; | |
| case 'A': { | |
| if (sscanf(p + 1, "%d:%d", &_y4m->par_n, &_y4m->par_d) != 2) { | |
| return -1; | |
| } | |
| } break; | |
| case 'C': { | |
| if (q - p > 16) return -1; | |
| memcpy(_y4m->chroma_type, p + 1, q - p - 1); | |
| _y4m->chroma_type[q - p - 1] = '\0'; | |
| } break; | |
| case 'X': { | |
| if (!parse_metadata(_y4m, p + 1)) return -1; | |
| } break; | |
| default: break; /*Ignore unknown tags.*/ | |
| } | |
| } | |
| return 0; | |
| } | |
| // Copy a single tag into the buffer, along with a null character. | |
| // Returns 0 if any file IO errors occur. | |
| static int copy_tag(char *buf, size_t buf_len, char *end_tag, FILE *file) { | |
| size_t i; | |
| assert(buf_len >= 1); | |
| // Skip leading space characters. | |
| do { | |
| if (!file_read(buf, 1, file)) { | |
| return 0; | |
| } | |
| } while (buf[0] == ' '); | |
| // If we hit the newline, treat this as the "empty" tag. | |
| if (buf[0] == '\n') { | |
| buf[0] = '\0'; | |
| *end_tag = '\n'; | |
| return 1; | |
| } | |
| // Copy over characters until a space is hit, or the buffer is exhausted. | |
| for (i = 1; i < buf_len; ++i) { | |
| if (!file_read(buf + i, 1, file)) { | |
| return 0; | |
| } | |
| if (buf[i] == ' ' || buf[i] == '\n') { | |
| break; | |
| } | |
| } | |
| if (i == buf_len) { | |
| fprintf(stderr, "Error: Y4M header tags must be less than %lu characters\n", | |
| (unsigned long)i); | |
| return 0; | |
| } | |
| *end_tag = buf[i]; | |
| buf[i] = '\0'; | |
| return 1; | |
| } | |
| // Returns 1 if tags were parsed successfully, 0 otherwise. | |
| static int parse_tags(y4m_input *y4m_ctx, FILE *file) { | |
| char tag[256]; | |
| char end; // Character denoting the end of the tag, ' ' or '\n'. | |
| // Set Y4M tags to defaults, updating them as processing occurs. Mandatory | |
| // fields are marked with -1 and will be checked after the tags are parsed. | |
| y4m_ctx->pic_w = -1; | |
| y4m_ctx->pic_h = -1; | |
| y4m_ctx->fps_n = -1; // Also serves as marker for fps_d | |
| y4m_ctx->par_n = 0; | |
| y4m_ctx->par_d = 0; | |
| y4m_ctx->interlace = '?'; | |
| y4m_ctx->color_range = AOM_CR_STUDIO_RANGE; | |
| snprintf(y4m_ctx->chroma_type, sizeof(y4m_ctx->chroma_type), "420"); | |
| // Find one tag at a time. | |
| do { | |
| if (!copy_tag(tag, sizeof(tag), &end, file)) { | |
| return 0; | |
| } | |
| // y4m_parse_tags returns 0 on success. | |
| if (y4m_parse_tags(y4m_ctx, tag)) { | |
| return 0; | |
| } | |
| } while (end != '\n'); | |
| // Check the mandatory fields. | |
| if (y4m_ctx->pic_w == -1) { | |
| fprintf(stderr, "Width field missing\n"); | |
| return 0; | |
| } | |
| if (y4m_ctx->pic_h == -1) { | |
| fprintf(stderr, "Height field missing\n"); | |
| return 0; | |
| } | |
| if (y4m_ctx->fps_n == -1) { | |
| fprintf(stderr, "FPS field missing\n"); | |
| return 0; | |
| } | |
| return 1; | |
| } | |
| /*All anti-aliasing filters in the following conversion functions are based on | |
| one of two window functions: | |
| The 6-tap Lanczos window (for down-sampling and shifts): | |
| sinc(\pi*t)*sinc(\pi*t/3), |t|<3 (sinc(t)==sin(t)/t) | |
| 0, |t|>=3 | |
| The 4-tap Mitchell window (for up-sampling): | |
| 7|t|^3-12|t|^2+16/3, |t|<1 | |
| -(7/3)|x|^3+12|x|^2-20|x|+32/3, |t|<2 | |
| 0, |t|>=2 | |
| The number of taps is intentionally kept small to reduce computational | |
| overhead and limit ringing. | |
| The taps from these filters are scaled so that their sum is 1, and the | |
| result is scaled by 128 and rounded to integers to create a filter whose | |
| intermediate values fit inside 16 bits. | |
| Coefficients are rounded in such a way as to ensure their sum is still 128, | |
| which is usually equivalent to normal rounding. | |
| Conversions which require both horizontal and vertical filtering could | |
| have these steps pipelined, for less memory consumption and better cache | |
| performance, but we do them separately for simplicity.*/ | |
| #define OC_MINI(_a, _b) ((_a) > (_b) ? (_b) : (_a)) | |
| #define OC_MAXI(_a, _b) ((_a) < (_b) ? (_b) : (_a)) | |
| #define OC_CLAMPI(_a, _b, _c) (OC_MAXI(_a, OC_MINI(_b, _c))) | |
| /*420jpeg chroma samples are sited like: | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | BR | | BR | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | BR | | BR | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| 420mpeg2 chroma samples are sited like: | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| BR | BR | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| BR | BR | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| We use a resampling filter to shift the site locations one quarter pixel (at | |
| the chroma plane's resolution) to the right. | |
| The 4:2:2 modes look exactly the same, except there are twice as many chroma | |
| lines, and they are vertically co-sited with the luma samples in both the | |
| mpeg2 and jpeg cases (thus requiring no vertical resampling).*/ | |
| static void y4m_42xmpeg2_42xjpeg_helper(unsigned char *_dst, | |
| const unsigned char *_src, int _c_w, | |
| int _c_h) { | |
| int y; | |
| int x; | |
| for (y = 0; y < _c_h; y++) { | |
| /*Filter: [4 -17 114 35 -9 1]/128, derived from a 6-tap Lanczos | |
| window.*/ | |
| for (x = 0; x < OC_MINI(_c_w, 2); x++) { | |
| _dst[x] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (4 * _src[0] - 17 * _src[OC_MAXI(x - 1, 0)] + 114 * _src[x] + | |
| 35 * _src[OC_MINI(x + 1, _c_w - 1)] - | |
| 9 * _src[OC_MINI(x + 2, _c_w - 1)] + _src[OC_MINI(x + 3, _c_w - 1)] + | |
| 64) >> | |
| 7, | |
| 255); | |
| } | |
| for (; x < _c_w - 3; x++) { | |
| _dst[x] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (4 * _src[x - 2] - 17 * _src[x - 1] + 114 * _src[x] + | |
| 35 * _src[x + 1] - 9 * _src[x + 2] + _src[x + 3] + 64) >> | |
| 7, | |
| 255); | |
| } | |
| for (; x < _c_w; x++) { | |
| _dst[x] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (4 * _src[x - 2] - 17 * _src[x - 1] + 114 * _src[x] + | |
| 35 * _src[OC_MINI(x + 1, _c_w - 1)] - | |
| 9 * _src[OC_MINI(x + 2, _c_w - 1)] + _src[_c_w - 1] + 64) >> | |
| 7, | |
| 255); | |
| } | |
| _dst += _c_w; | |
| _src += _c_w; | |
| } | |
| } | |
| /*This format is only used for interlaced content, but is included for | |
| completeness. | |
| 420jpeg chroma samples are sited like: | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | BR | | BR | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | BR | | BR | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| 420paldv chroma samples are sited like: | |
| YR------Y-------YR------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| YB------Y-------YB------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| YR------Y-------YR------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| YB------Y-------YB------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| We use a resampling filter to shift the site locations one quarter pixel (at | |
| the chroma plane's resolution) to the right. | |
| Then we use another filter to move the C_r location down one quarter pixel, | |
| and the C_b location up one quarter pixel.*/ | |
| static void y4m_convert_42xpaldv_42xjpeg(y4m_input *_y4m, unsigned char *_dst, | |
| unsigned char *_aux) { | |
| unsigned char *tmp; | |
| int c_w; | |
| int c_h; | |
| int c_sz; | |
| int pli; | |
| int y; | |
| int x; | |
| /*Skip past the luma data.*/ | |
| _dst += _y4m->pic_w * _y4m->pic_h; | |
| /*Compute the size of each chroma plane.*/ | |
| c_w = (_y4m->pic_w + 1) / 2; | |
| c_h = (_y4m->pic_h + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h; | |
| c_sz = c_w * c_h; | |
| tmp = _aux + 2 * c_sz; | |
| for (pli = 1; pli < 3; pli++) { | |
| /*First do the horizontal re-sampling. | |
| This is the same as the mpeg2 case, except that after the horizontal | |
| case, we need to apply a second vertical filter.*/ | |
| y4m_42xmpeg2_42xjpeg_helper(tmp, _aux, c_w, c_h); | |
| _aux += c_sz; | |
| switch (pli) { | |
| case 1: { | |
| /*Slide C_b up a quarter-pel. | |
| This is the same filter used above, but in the other order.*/ | |
| for (x = 0; x < c_w; x++) { | |
| for (y = 0; y < OC_MINI(c_h, 3); y++) { | |
| _dst[y * c_w] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (tmp[0] - 9 * tmp[OC_MAXI(y - 2, 0) * c_w] + | |
| 35 * tmp[OC_MAXI(y - 1, 0) * c_w] + 114 * tmp[y * c_w] - | |
| 17 * tmp[OC_MINI(y + 1, c_h - 1) * c_w] + | |
| 4 * tmp[OC_MINI(y + 2, c_h - 1) * c_w] + 64) >> | |
| 7, | |
| 255); | |
| } | |
| for (; y < c_h - 2; y++) { | |
| _dst[y * c_w] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (tmp[(y - 3) * c_w] - 9 * tmp[(y - 2) * c_w] + | |
| 35 * tmp[(y - 1) * c_w] + 114 * tmp[y * c_w] - | |
| 17 * tmp[(y + 1) * c_w] + 4 * tmp[(y + 2) * c_w] + 64) >> | |
| 7, | |
| 255); | |
| } | |
| for (; y < c_h; y++) { | |
| _dst[y * c_w] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (tmp[(y - 3) * c_w] - 9 * tmp[(y - 2) * c_w] + | |
| 35 * tmp[(y - 1) * c_w] + 114 * tmp[y * c_w] - | |
| 17 * tmp[OC_MINI(y + 1, c_h - 1) * c_w] + | |
| 4 * tmp[(c_h - 1) * c_w] + 64) >> | |
| 7, | |
| 255); | |
| } | |
| _dst++; | |
| tmp++; | |
| } | |
| _dst += c_sz - c_w; | |
| tmp -= c_w; | |
| } break; | |
| case 2: { | |
| /*Slide C_r down a quarter-pel. | |
| This is the same as the horizontal filter.*/ | |
| for (x = 0; x < c_w; x++) { | |
| for (y = 0; y < OC_MINI(c_h, 2); y++) { | |
| _dst[y * c_w] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (4 * tmp[0] - 17 * tmp[OC_MAXI(y - 1, 0) * c_w] + | |
| 114 * tmp[y * c_w] + 35 * tmp[OC_MINI(y + 1, c_h - 1) * c_w] - | |
| 9 * tmp[OC_MINI(y + 2, c_h - 1) * c_w] + | |
| tmp[OC_MINI(y + 3, c_h - 1) * c_w] + 64) >> | |
| 7, | |
| 255); | |
| } | |
| for (; y < c_h - 3; y++) { | |
| _dst[y * c_w] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (4 * tmp[(y - 2) * c_w] - 17 * tmp[(y - 1) * c_w] + | |
| 114 * tmp[y * c_w] + 35 * tmp[(y + 1) * c_w] - | |
| 9 * tmp[(y + 2) * c_w] + tmp[(y + 3) * c_w] + 64) >> | |
| 7, | |
| 255); | |
| } | |
| for (; y < c_h; y++) { | |
| _dst[y * c_w] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (4 * tmp[(y - 2) * c_w] - 17 * tmp[(y - 1) * c_w] + | |
| 114 * tmp[y * c_w] + 35 * tmp[OC_MINI(y + 1, c_h - 1) * c_w] - | |
| 9 * tmp[OC_MINI(y + 2, c_h - 1) * c_w] + tmp[(c_h - 1) * c_w] + | |
| 64) >> | |
| 7, | |
| 255); | |
| } | |
| _dst++; | |
| tmp++; | |
| } | |
| } break; | |
| } | |
| /*For actual interlaced material, this would have to be done separately on | |
| each field, and the shift amounts would be different. | |
| C_r moves down 1/8, C_b up 3/8 in the top field, and C_r moves down 3/8, | |
| C_b up 1/8 in the bottom field. | |
| The corresponding filters would be: | |
| Down 1/8 (reverse order for up): [3 -11 125 15 -4 0]/128 | |
| Down 3/8 (reverse order for up): [4 -19 98 56 -13 2]/128*/ | |
| } | |
| } | |
| /*Perform vertical filtering to reduce a single plane from 4:2:2 to 4:2:0. | |
| This is used as a helper by several conversion routines.*/ | |
| static void y4m_422jpeg_420jpeg_helper(unsigned char *_dst, | |
| const unsigned char *_src, int _c_w, | |
| int _c_h) { | |
| int y; | |
| int x; | |
| /*Filter: [3 -17 78 78 -17 3]/128, derived from a 6-tap Lanczos window.*/ | |
| for (x = 0; x < _c_w; x++) { | |
| for (y = 0; y < OC_MINI(_c_h, 2); y += 2) { | |
| _dst[(y >> 1) * _c_w] = | |
| OC_CLAMPI(0, | |
| (64 * _src[0] + 78 * _src[OC_MINI(1, _c_h - 1) * _c_w] - | |
| 17 * _src[OC_MINI(2, _c_h - 1) * _c_w] + | |
| 3 * _src[OC_MINI(3, _c_h - 1) * _c_w] + 64) >> | |
| 7, | |
| 255); | |
| } | |
| for (; y < _c_h - 3; y += 2) { | |
| _dst[(y >> 1) * _c_w] = | |
| OC_CLAMPI(0, | |
| (3 * (_src[(y - 2) * _c_w] + _src[(y + 3) * _c_w]) - | |
| 17 * (_src[(y - 1) * _c_w] + _src[(y + 2) * _c_w]) + | |
| 78 * (_src[y * _c_w] + _src[(y + 1) * _c_w]) + 64) >> | |
| 7, | |
| 255); | |
| } | |
| for (; y < _c_h; y += 2) { | |
| _dst[(y >> 1) * _c_w] = OC_CLAMPI( | |
| 0, | |
| (3 * (_src[(y - 2) * _c_w] + _src[(_c_h - 1) * _c_w]) - | |
| 17 * (_src[(y - 1) * _c_w] + _src[OC_MINI(y + 2, _c_h - 1) * _c_w]) + | |
| 78 * (_src[y * _c_w] + _src[OC_MINI(y + 1, _c_h - 1) * _c_w]) + | |
| 64) >> | |
| 7, | |
| 255); | |
| } | |
| _src++; | |
| _dst++; | |
| } | |
| } | |
| /*420jpeg chroma samples are sited like: | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | BR | | BR | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | BR | | BR | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| 422jpeg chroma samples are sited like: | |
| Y---BR--Y-------Y---BR--Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| Y---BR--Y-------Y---BR--Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| Y---BR--Y-------Y---BR--Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| Y---BR--Y-------Y---BR--Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| We use a resampling filter to decimate the chroma planes by two in the | |
| vertical direction.*/ | |
| static void y4m_convert_422jpeg_420jpeg(y4m_input *_y4m, unsigned char *_dst, | |
| unsigned char *_aux) { | |
| int c_w; | |
| int c_h; | |
| int c_sz; | |
| int dst_c_w; | |
| int dst_c_h; | |
| int dst_c_sz; | |
| int pli; | |
| /*Skip past the luma data.*/ | |
| _dst += _y4m->pic_w * _y4m->pic_h; | |
| /*Compute the size of each chroma plane.*/ | |
| c_w = (_y4m->pic_w + _y4m->src_c_dec_h - 1) / _y4m->src_c_dec_h; | |
| c_h = _y4m->pic_h; | |
| dst_c_w = (_y4m->pic_w + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h; | |
| dst_c_h = (_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v; | |
| c_sz = c_w * c_h; | |
| dst_c_sz = dst_c_w * dst_c_h; | |
| for (pli = 1; pli < 3; pli++) { | |
| y4m_422jpeg_420jpeg_helper(_dst, _aux, c_w, c_h); | |
| _aux += c_sz; | |
| _dst += dst_c_sz; | |
| } | |
| } | |
| /*420jpeg chroma samples are sited like: | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | BR | | BR | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | BR | | BR | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| 422 chroma samples are sited like: | |
| YBR-----Y-------YBR-----Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| YBR-----Y-------YBR-----Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| YBR-----Y-------YBR-----Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| YBR-----Y-------YBR-----Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| We use a resampling filter to shift the original site locations one quarter | |
| pixel (at the original chroma resolution) to the right. | |
| Then we use a second resampling filter to decimate the chroma planes by two | |
| in the vertical direction.*/ | |
| static void y4m_convert_422_420jpeg(y4m_input *_y4m, unsigned char *_dst, | |
| unsigned char *_aux) { | |
| unsigned char *tmp; | |
| int c_w; | |
| int c_h; | |
| int c_sz; | |
| int dst_c_h; | |
| int dst_c_sz; | |
| int pli; | |
| /*Skip past the luma data.*/ | |
| _dst += _y4m->pic_w * _y4m->pic_h; | |
| /*Compute the size of each chroma plane.*/ | |
| c_w = (_y4m->pic_w + _y4m->src_c_dec_h - 1) / _y4m->src_c_dec_h; | |
| c_h = _y4m->pic_h; | |
| dst_c_h = (_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v; | |
| c_sz = c_w * c_h; | |
| dst_c_sz = c_w * dst_c_h; | |
| tmp = _aux + 2 * c_sz; | |
| for (pli = 1; pli < 3; pli++) { | |
| /*In reality, the horizontal and vertical steps could be pipelined, for | |
| less memory consumption and better cache performance, but we do them | |
| separately for simplicity.*/ | |
| /*First do horizontal filtering (convert to 422jpeg)*/ | |
| y4m_42xmpeg2_42xjpeg_helper(tmp, _aux, c_w, c_h); | |
| /*Now do the vertical filtering.*/ | |
| y4m_422jpeg_420jpeg_helper(_dst, tmp, c_w, c_h); | |
| _aux += c_sz; | |
| _dst += dst_c_sz; | |
| } | |
| } | |
| /*420jpeg chroma samples are sited like: | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | BR | | BR | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | BR | | BR | | |
| | | | | | |
| Y-------Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| 411 chroma samples are sited like: | |
| YBR-----Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| YBR-----Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| YBR-----Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| YBR-----Y-------Y-------Y------- | |
| | | | | | |
| | | | | | |
| | | | | | |
| We use a filter to resample at site locations one eighth pixel (at the source | |
| chroma plane's horizontal resolution) and five eighths of a pixel to the | |
| right. | |
| Then we use another filter to decimate the planes by 2 in the vertical | |
| direction.*/ | |
| static void y4m_convert_411_420jpeg(y4m_input *_y4m, unsigned char *_dst, | |
| unsigned char *_aux) { | |
| unsigned char *tmp; | |
| int c_w; | |
| int c_h; | |
| int c_sz; | |
| int dst_c_w; | |
| int dst_c_h; | |
| int dst_c_sz; | |
| int tmp_sz; | |
| int pli; | |
| int y; | |
| int x; | |
| /*Skip past the luma data.*/ | |
| _dst += _y4m->pic_w * _y4m->pic_h; | |
| /*Compute the size of each chroma plane.*/ | |
| c_w = (_y4m->pic_w + _y4m->src_c_dec_h - 1) / _y4m->src_c_dec_h; | |
| c_h = _y4m->pic_h; | |
| dst_c_w = (_y4m->pic_w + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h; | |
| dst_c_h = (_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v; | |
| c_sz = c_w * c_h; | |
| dst_c_sz = dst_c_w * dst_c_h; | |
| tmp_sz = dst_c_w * c_h; | |
| tmp = _aux + 2 * c_sz; | |
| for (pli = 1; pli < 3; pli++) { | |
| /*In reality, the horizontal and vertical steps could be pipelined, for | |
| less memory consumption and better cache performance, but we do them | |
| separately for simplicity.*/ | |
| /*First do horizontal filtering (convert to 422jpeg)*/ | |
| for (y = 0; y < c_h; y++) { | |
| /*Filters: [1 110 18 -1]/128 and [-3 50 86 -5]/128, both derived from a | |
| 4-tap Mitchell window.*/ | |
| for (x = 0; x < OC_MINI(c_w, 1); x++) { | |
| tmp[x << 1] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (111 * _aux[0] + 18 * _aux[OC_MINI(1, c_w - 1)] - | |
| _aux[OC_MINI(2, c_w - 1)] + 64) >> | |
| 7, | |
| 255); | |
| tmp[x << 1 | 1] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (47 * _aux[0] + 86 * _aux[OC_MINI(1, c_w - 1)] - | |
| 5 * _aux[OC_MINI(2, c_w - 1)] + 64) >> | |
| 7, | |
| 255); | |
| } | |
| for (; x < c_w - 2; x++) { | |
| tmp[x << 1] = | |
| (unsigned char)OC_CLAMPI(0, | |
| (_aux[x - 1] + 110 * _aux[x] + | |
| 18 * _aux[x + 1] - _aux[x + 2] + 64) >> | |
| 7, | |
| 255); | |
| tmp[x << 1 | 1] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (-3 * _aux[x - 1] + 50 * _aux[x] + 86 * _aux[x + 1] - | |
| 5 * _aux[x + 2] + 64) >> | |
| 7, | |
| 255); | |
| } | |
| for (; x < c_w; x++) { | |
| tmp[x << 1] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (_aux[x - 1] + 110 * _aux[x] + 18 * _aux[OC_MINI(x + 1, c_w - 1)] - | |
| _aux[c_w - 1] + 64) >> | |
| 7, | |
| 255); | |
| if ((x << 1 | 1) < dst_c_w) { | |
| tmp[x << 1 | 1] = (unsigned char)OC_CLAMPI( | |
| 0, | |
| (-3 * _aux[x - 1] + 50 * _aux[x] + | |
| 86 * _aux[OC_MINI(x + 1, c_w - 1)] - 5 * _aux[c_w - 1] + 64) >> | |
| 7, | |
| 255); | |
| } | |
| } | |
| tmp += dst_c_w; | |
| _aux += c_w; | |
| } | |
| tmp -= tmp_sz; | |
| /*Now do the vertical filtering.*/ | |
| y4m_422jpeg_420jpeg_helper(_dst, tmp, dst_c_w, c_h); | |
| _dst += dst_c_sz; | |
| } | |
| } | |
| /*Convert 444 to 420jpeg.*/ | |
| static void y4m_convert_444_420jpeg(y4m_input *_y4m, unsigned char *_dst, | |
| unsigned char *_aux) { | |
| unsigned char *tmp; | |
| int c_w; | |
| int c_h; | |
| int c_sz; | |
| int dst_c_w; | |
| int dst_c_h; | |
| int dst_c_sz; | |
| int tmp_sz; | |
| int pli; | |
| int y; | |
| int x; | |
| /*Skip past the luma data.*/ | |
| _dst += _y4m->pic_w * _y4m->pic_h; | |
| /*Compute the size of each chroma plane.*/ | |
| c_w = (_y4m->pic_w + _y4m->src_c_dec_h - 1) / _y4m->src_c_dec_h; | |
| c_h = _y4m->pic_h; | |
| dst_c_w = (_y4m->pic_w + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h; | |
| dst_c_h = (_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v; | |
| c_sz = c_w * c_h; | |
| dst_c_sz = dst_c_w * dst_c_h; | |
| tmp_sz = dst_c_w * c_h; | |
| tmp = _aux + 2 * c_sz; | |
| for (pli = 1; pli < 3; pli++) { | |
| /*Filter: [3 -17 78 78 -17 3]/128, derived from a 6-tap Lanczos window.*/ | |
| for (y = 0; y < c_h; y++) { | |
| for (x = 0; x < OC_MINI(c_w, 2); x += 2) { | |
| tmp[x >> 1] = OC_CLAMPI(0, | |
| (64 * _aux[0] + 78 * _aux[OC_MINI(1, c_w - 1)] - | |
| 17 * _aux[OC_MINI(2, c_w - 1)] + | |
| 3 * _aux[OC_MINI(3, c_w - 1)] + 64) >> | |
| 7, | |
| 255); | |
| } | |
| for (; x < c_w - 3; x += 2) { | |
| tmp[x >> 1] = OC_CLAMPI(0, | |
| (3 * (_aux[x - 2] + _aux[x + 3]) - | |
| 17 * (_aux[x - 1] + _aux[x + 2]) + | |
| 78 * (_aux[x] + _aux[x + 1]) + 64) >> | |
| 7, | |
| 255); | |
| } | |
| for (; x < c_w; x += 2) { | |
| tmp[x >> 1] = | |
| OC_CLAMPI(0, | |
| (3 * (_aux[x - 2] + _aux[c_w - 1]) - | |
| 17 * (_aux[x - 1] + _aux[OC_MINI(x + 2, c_w - 1)]) + | |
| 78 * (_aux[x] + _aux[OC_MINI(x + 1, c_w - 1)]) + 64) >> | |
| 7, | |
| 255); | |
| } | |
| tmp += dst_c_w; | |
| _aux += c_w; | |
| } | |
| tmp -= tmp_sz; | |
| /*Now do the vertical filtering.*/ | |
| y4m_422jpeg_420jpeg_helper(_dst, tmp, dst_c_w, c_h); | |
| _dst += dst_c_sz; | |
| } | |
| } | |
| /*The image is padded with empty chroma components at 4:2:0.*/ | |
| static void y4m_convert_mono_420jpeg(y4m_input *_y4m, unsigned char *_dst, | |
| unsigned char *_aux) { | |
| int c_sz; | |
| (void)_aux; | |
| _dst += _y4m->pic_w * _y4m->pic_h; | |
| c_sz = ((_y4m->pic_w + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h) * | |
| ((_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v); | |
| memset(_dst, 128, c_sz * 2); | |
| } | |
| /*No conversion function needed.*/ | |
| static void y4m_convert_null(y4m_input *_y4m, unsigned char *_dst, | |
| unsigned char *_aux) { | |
| (void)_y4m; | |
| (void)_dst; | |
| (void)_aux; | |
| } | |
| static const char TAG[] = "YUV4MPEG2"; | |
| int y4m_input_open(y4m_input *y4m_ctx, FILE *file, char *skip_buffer, | |
| int num_skip, aom_chroma_sample_position_t csp, | |
| int only_420) { | |
| // File must start with |TAG|. | |
| char tag_buffer[9]; // 9 == strlen(TAG) | |
| // Read as much as possible from |skip_buffer|, which were characters | |
| // that were previously read from the file to do input-type detection. | |
| assert(num_skip >= 0 && num_skip <= 8); | |
| if (num_skip > 0) { | |
| memcpy(tag_buffer, skip_buffer, num_skip); | |
| } | |
| // Start reading from the file now that the |skip_buffer| is depleted. | |
| if (!file_read(tag_buffer + num_skip, 9 - num_skip, file)) { | |
| return -1; | |
| } | |
| if (memcmp(TAG, tag_buffer, 9) != 0) { | |
| fprintf(stderr, "Error parsing header: must start with %s\n", TAG); | |
| return -1; | |
| } | |
| // Next character must be a space. | |
| if (!file_read(tag_buffer, 1, file) || tag_buffer[0] != ' ') { | |
| fprintf(stderr, "Error parsing header: space must follow %s\n", TAG); | |
| return -1; | |
| } | |
| if (!parse_tags(y4m_ctx, file)) { | |
| fprintf(stderr, "Error parsing %s header.\n", TAG); | |
| return -1; | |
| } | |
| if (y4m_ctx->interlace == '?') { | |
| fprintf(stderr, | |
| "Warning: Input video interlacing format unknown; " | |
| "assuming progressive scan.\n"); | |
| } else if (y4m_ctx->interlace != 'p') { | |
| fprintf(stderr, | |
| "Input video is interlaced; " | |
| "Only progressive scan handled.\n"); | |
| return -1; | |
| } | |
| /* Only support vertical chroma sample position if the input format is | |
| * already 420mpeg2. Colocated is not supported in Y4M. | |
| */ | |
| if (csp == AOM_CSP_VERTICAL && | |
| strcmp(y4m_ctx->chroma_type, "420mpeg2") != 0) { | |
| fprintf(stderr, | |
| "Vertical chroma sample position only supported " | |
| "for 420mpeg2 input\n"); | |
| return -1; | |
| } | |
| if (csp == AOM_CSP_COLOCATED) { | |
| // TODO(any): check the right way to handle this in y4m | |
| fprintf(stderr, | |
| "Ignoring colocated chroma sample position for reading in Y4M\n"); | |
| } | |
| y4m_ctx->aom_fmt = AOM_IMG_FMT_I420; | |
| y4m_ctx->bps = 12; | |
| y4m_ctx->bit_depth = 8; | |
| y4m_ctx->aux_buf = NULL; | |
| y4m_ctx->dst_buf = NULL; | |
| if (strcmp(y4m_ctx->chroma_type, "420") == 0 || | |
| strcmp(y4m_ctx->chroma_type, "420jpeg") == 0 || | |
| strcmp(y4m_ctx->chroma_type, "420mpeg2") == 0) { | |
| y4m_ctx->src_c_dec_h = y4m_ctx->dst_c_dec_h = y4m_ctx->src_c_dec_v = | |
| y4m_ctx->dst_c_dec_v = 2; | |
| y4m_ctx->dst_buf_read_sz = | |
| y4m_ctx->pic_w * y4m_ctx->pic_h + | |
| 2 * ((y4m_ctx->pic_w + 1) / 2) * ((y4m_ctx->pic_h + 1) / 2); | |
| /* Natively supported: no conversion required. */ | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz = 0; | |
| y4m_ctx->convert = y4m_convert_null; | |
| } else if (strcmp(y4m_ctx->chroma_type, "420p10") == 0) { | |
| y4m_ctx->src_c_dec_h = 2; | |
| y4m_ctx->dst_c_dec_h = 2; | |
| y4m_ctx->src_c_dec_v = 2; | |
| y4m_ctx->dst_c_dec_v = 2; | |
| y4m_ctx->dst_buf_read_sz = | |
| 2 * (y4m_ctx->pic_w * y4m_ctx->pic_h + | |
| 2 * ((y4m_ctx->pic_w + 1) / 2) * ((y4m_ctx->pic_h + 1) / 2)); | |
| /* Natively supported: no conversion required. */ | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz = 0; | |
| y4m_ctx->convert = y4m_convert_null; | |
| y4m_ctx->bit_depth = 10; | |
| y4m_ctx->bps = 15; | |
| y4m_ctx->aom_fmt = AOM_IMG_FMT_I42016; | |
| if (only_420) { | |
| fprintf(stderr, "Unsupported conversion from 420p10 to 420jpeg\n"); | |
| return -1; | |
| } | |
| } else if (strcmp(y4m_ctx->chroma_type, "420p12") == 0) { | |
| y4m_ctx->src_c_dec_h = 2; | |
| y4m_ctx->dst_c_dec_h = 2; | |
| y4m_ctx->src_c_dec_v = 2; | |
| y4m_ctx->dst_c_dec_v = 2; | |
| y4m_ctx->dst_buf_read_sz = | |
| 2 * (y4m_ctx->pic_w * y4m_ctx->pic_h + | |
| 2 * ((y4m_ctx->pic_w + 1) / 2) * ((y4m_ctx->pic_h + 1) / 2)); | |
| /* Natively supported: no conversion required. */ | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz = 0; | |
| y4m_ctx->convert = y4m_convert_null; | |
| y4m_ctx->bit_depth = 12; | |
| y4m_ctx->bps = 18; | |
| y4m_ctx->aom_fmt = AOM_IMG_FMT_I42016; | |
| if (only_420) { | |
| fprintf(stderr, "Unsupported conversion from 420p12 to 420jpeg\n"); | |
| return -1; | |
| } | |
| } else if (strcmp(y4m_ctx->chroma_type, "420paldv") == 0) { | |
| y4m_ctx->src_c_dec_h = y4m_ctx->dst_c_dec_h = y4m_ctx->src_c_dec_v = | |
| y4m_ctx->dst_c_dec_v = 2; | |
| y4m_ctx->dst_buf_read_sz = y4m_ctx->pic_w * y4m_ctx->pic_h; | |
| /*Chroma filter required: read into the aux buf first. | |
| We need to make two filter passes, so we need some extra space in the | |
| aux buffer.*/ | |
| y4m_ctx->aux_buf_sz = | |
| 3 * ((y4m_ctx->pic_w + 1) / 2) * ((y4m_ctx->pic_h + 1) / 2); | |
| y4m_ctx->aux_buf_read_sz = | |
| 2 * ((y4m_ctx->pic_w + 1) / 2) * ((y4m_ctx->pic_h + 1) / 2); | |
| y4m_ctx->convert = y4m_convert_42xpaldv_42xjpeg; | |
| } else if (strcmp(y4m_ctx->chroma_type, "422jpeg") == 0) { | |
| y4m_ctx->src_c_dec_h = y4m_ctx->dst_c_dec_h = 2; | |
| y4m_ctx->src_c_dec_v = 1; | |
| y4m_ctx->dst_c_dec_v = 2; | |
| y4m_ctx->dst_buf_read_sz = y4m_ctx->pic_w * y4m_ctx->pic_h; | |
| /*Chroma filter required: read into the aux buf first.*/ | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz = | |
| 2 * ((y4m_ctx->pic_w + 1) / 2) * y4m_ctx->pic_h; | |
| y4m_ctx->convert = y4m_convert_422jpeg_420jpeg; | |
| } else if (strcmp(y4m_ctx->chroma_type, "422") == 0) { | |
| y4m_ctx->src_c_dec_h = 2; | |
| y4m_ctx->src_c_dec_v = 1; | |
| if (only_420) { | |
| y4m_ctx->dst_c_dec_h = 2; | |
| y4m_ctx->dst_c_dec_v = 2; | |
| y4m_ctx->dst_buf_read_sz = y4m_ctx->pic_w * y4m_ctx->pic_h; | |
| /*Chroma filter required: read into the aux buf first. | |
| We need to make two filter passes, so we need some extra space in the | |
| aux buffer.*/ | |
| y4m_ctx->aux_buf_read_sz = | |
| 2 * ((y4m_ctx->pic_w + 1) / 2) * y4m_ctx->pic_h; | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz + | |
| ((y4m_ctx->pic_w + 1) / 2) * y4m_ctx->pic_h; | |
| y4m_ctx->convert = y4m_convert_422_420jpeg; | |
| } else { | |
| y4m_ctx->aom_fmt = AOM_IMG_FMT_I422; | |
| y4m_ctx->bps = 16; | |
| y4m_ctx->dst_c_dec_h = y4m_ctx->src_c_dec_h; | |
| y4m_ctx->dst_c_dec_v = y4m_ctx->src_c_dec_v; | |
| y4m_ctx->dst_buf_read_sz = | |
| y4m_ctx->pic_w * y4m_ctx->pic_h + | |
| 2 * ((y4m_ctx->pic_w + 1) / 2) * y4m_ctx->pic_h; | |
| /*Natively supported: no conversion required.*/ | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz = 0; | |
| y4m_ctx->convert = y4m_convert_null; | |
| } | |
| } else if (strcmp(y4m_ctx->chroma_type, "422p10") == 0) { | |
| y4m_ctx->src_c_dec_h = 2; | |
| y4m_ctx->src_c_dec_v = 1; | |
| y4m_ctx->aom_fmt = AOM_IMG_FMT_I42216; | |
| y4m_ctx->bps = 20; | |
| y4m_ctx->bit_depth = 10; | |
| y4m_ctx->dst_c_dec_h = y4m_ctx->src_c_dec_h; | |
| y4m_ctx->dst_c_dec_v = y4m_ctx->src_c_dec_v; | |
| y4m_ctx->dst_buf_read_sz = | |
| 2 * (y4m_ctx->pic_w * y4m_ctx->pic_h + | |
| 2 * ((y4m_ctx->pic_w + 1) / 2) * y4m_ctx->pic_h); | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz = 0; | |
| y4m_ctx->convert = y4m_convert_null; | |
| if (only_420) { | |
| fprintf(stderr, "Unsupported conversion from 422p10 to 420jpeg\n"); | |
| return -1; | |
| } | |
| } else if (strcmp(y4m_ctx->chroma_type, "422p12") == 0) { | |
| y4m_ctx->src_c_dec_h = 2; | |
| y4m_ctx->src_c_dec_v = 1; | |
| y4m_ctx->aom_fmt = AOM_IMG_FMT_I42216; | |
| y4m_ctx->bps = 24; | |
| y4m_ctx->bit_depth = 12; | |
| y4m_ctx->dst_c_dec_h = y4m_ctx->src_c_dec_h; | |
| y4m_ctx->dst_c_dec_v = y4m_ctx->src_c_dec_v; | |
| y4m_ctx->dst_buf_read_sz = | |
| 2 * (y4m_ctx->pic_w * y4m_ctx->pic_h + | |
| 2 * ((y4m_ctx->pic_w + 1) / 2) * y4m_ctx->pic_h); | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz = 0; | |
| y4m_ctx->convert = y4m_convert_null; | |
| if (only_420) { | |
| fprintf(stderr, "Unsupported conversion from 422p12 to 420jpeg\n"); | |
| return -1; | |
| } | |
| } else if (strcmp(y4m_ctx->chroma_type, "411") == 0) { | |
| y4m_ctx->src_c_dec_h = 4; | |
| y4m_ctx->dst_c_dec_h = 2; | |
| y4m_ctx->src_c_dec_v = 1; | |
| y4m_ctx->dst_c_dec_v = 2; | |
| y4m_ctx->dst_buf_read_sz = y4m_ctx->pic_w * y4m_ctx->pic_h; | |
| /*Chroma filter required: read into the aux buf first. | |
| We need to make two filter passes, so we need some extra space in the | |
| aux buffer.*/ | |
| y4m_ctx->aux_buf_read_sz = 2 * ((y4m_ctx->pic_w + 3) / 4) * y4m_ctx->pic_h; | |
| y4m_ctx->aux_buf_sz = | |
| y4m_ctx->aux_buf_read_sz + ((y4m_ctx->pic_w + 1) / 2) * y4m_ctx->pic_h; | |
| y4m_ctx->convert = y4m_convert_411_420jpeg; | |
| } else if (strcmp(y4m_ctx->chroma_type, "444") == 0) { | |
| y4m_ctx->src_c_dec_h = 1; | |
| y4m_ctx->src_c_dec_v = 1; | |
| if (only_420) { | |
| y4m_ctx->dst_c_dec_h = 2; | |
| y4m_ctx->dst_c_dec_v = 2; | |
| y4m_ctx->dst_buf_read_sz = y4m_ctx->pic_w * y4m_ctx->pic_h; | |
| /*Chroma filter required: read into the aux buf first. | |
| We need to make two filter passes, so we need some extra space in the | |
| aux buffer.*/ | |
| y4m_ctx->aux_buf_read_sz = 2 * y4m_ctx->pic_w * y4m_ctx->pic_h; | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz + | |
| ((y4m_ctx->pic_w + 1) / 2) * y4m_ctx->pic_h; | |
| y4m_ctx->convert = y4m_convert_444_420jpeg; | |
| } else { | |
| y4m_ctx->aom_fmt = AOM_IMG_FMT_I444; | |
| y4m_ctx->bps = 24; | |
| y4m_ctx->dst_c_dec_h = y4m_ctx->src_c_dec_h; | |
| y4m_ctx->dst_c_dec_v = y4m_ctx->src_c_dec_v; | |
| y4m_ctx->dst_buf_read_sz = 3 * y4m_ctx->pic_w * y4m_ctx->pic_h; | |
| /*Natively supported: no conversion required.*/ | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz = 0; | |
| y4m_ctx->convert = y4m_convert_null; | |
| } | |
| } else if (strcmp(y4m_ctx->chroma_type, "444p10") == 0) { | |
| y4m_ctx->src_c_dec_h = 1; | |
| y4m_ctx->src_c_dec_v = 1; | |
| y4m_ctx->aom_fmt = AOM_IMG_FMT_I44416; | |
| y4m_ctx->bps = 30; | |
| y4m_ctx->bit_depth = 10; | |
| y4m_ctx->dst_c_dec_h = y4m_ctx->src_c_dec_h; | |
| y4m_ctx->dst_c_dec_v = y4m_ctx->src_c_dec_v; | |
| y4m_ctx->dst_buf_read_sz = 2 * 3 * y4m_ctx->pic_w * y4m_ctx->pic_h; | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz = 0; | |
| y4m_ctx->convert = y4m_convert_null; | |
| if (only_420) { | |
| fprintf(stderr, "Unsupported conversion from 444p10 to 420jpeg\n"); | |
| return -1; | |
| } | |
| } else if (strcmp(y4m_ctx->chroma_type, "444p12") == 0) { | |
| y4m_ctx->src_c_dec_h = 1; | |
| y4m_ctx->src_c_dec_v = 1; | |
| y4m_ctx->aom_fmt = AOM_IMG_FMT_I44416; | |
| y4m_ctx->bps = 36; | |
| y4m_ctx->bit_depth = 12; | |
| y4m_ctx->dst_c_dec_h = y4m_ctx->src_c_dec_h; | |
| y4m_ctx->dst_c_dec_v = y4m_ctx->src_c_dec_v; | |
| y4m_ctx->dst_buf_read_sz = 2 * 3 * y4m_ctx->pic_w * y4m_ctx->pic_h; | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz = 0; | |
| y4m_ctx->convert = y4m_convert_null; | |
| if (only_420) { | |
| fprintf(stderr, "Unsupported conversion from 444p12 to 420jpeg\n"); | |
| return -1; | |
| } | |
| } else if (strcmp(y4m_ctx->chroma_type, "444alpha") == 0) { | |
| y4m_ctx->src_c_dec_h = 1; | |
| y4m_ctx->src_c_dec_v = 1; | |
| if (only_420) { | |
| y4m_ctx->dst_c_dec_h = 2; | |
| y4m_ctx->dst_c_dec_v = 2; | |
| y4m_ctx->dst_buf_read_sz = y4m_ctx->pic_w * y4m_ctx->pic_h; | |
| /*Chroma filter required: read into the aux buf first. | |
| We need to make two filter passes, so we need some extra space in the | |
| aux buffer. | |
| The extra plane also gets read into the aux buf. | |
| It will be discarded.*/ | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz = | |
| 3 * y4m_ctx->pic_w * y4m_ctx->pic_h; | |
| y4m_ctx->convert = y4m_convert_444_420jpeg; | |
| } else { | |
| fprintf(stderr, "Unsupported format: 444A\n"); | |
| return -1; | |
| } | |
| } else if (strcmp(y4m_ctx->chroma_type, "mono") == 0) { | |
| y4m_ctx->src_c_dec_h = y4m_ctx->src_c_dec_v = 0; | |
| y4m_ctx->dst_c_dec_h = y4m_ctx->dst_c_dec_v = 2; | |
| y4m_ctx->dst_buf_read_sz = y4m_ctx->pic_w * y4m_ctx->pic_h; | |
| /*No extra space required, but we need to clear the chroma planes.*/ | |
| y4m_ctx->aux_buf_sz = y4m_ctx->aux_buf_read_sz = 0; | |
| y4m_ctx->convert = y4m_convert_mono_420jpeg; | |
| } else { | |
| fprintf(stderr, "Unknown chroma sampling type: %s\n", y4m_ctx->chroma_type); | |
| return -1; | |
| } | |
| /*The size of the final frame buffers is always computed from the | |
| destination chroma decimation type.*/ | |
| y4m_ctx->dst_buf_sz = | |
| y4m_ctx->pic_w * y4m_ctx->pic_h + | |
| 2 * ((y4m_ctx->pic_w + y4m_ctx->dst_c_dec_h - 1) / y4m_ctx->dst_c_dec_h) * | |
| ((y4m_ctx->pic_h + y4m_ctx->dst_c_dec_v - 1) / y4m_ctx->dst_c_dec_v); | |
| if (y4m_ctx->bit_depth == 8) | |
| y4m_ctx->dst_buf = (unsigned char *)malloc(y4m_ctx->dst_buf_sz); | |
| else | |
| y4m_ctx->dst_buf = (unsigned char *)malloc(2 * y4m_ctx->dst_buf_sz); | |
| if (!y4m_ctx->dst_buf) return -1; | |
| if (y4m_ctx->aux_buf_sz > 0) { | |
| y4m_ctx->aux_buf = (unsigned char *)malloc(y4m_ctx->aux_buf_sz); | |
| if (!y4m_ctx->aux_buf) { | |
| free(y4m_ctx->dst_buf); | |
| return -1; | |
| } | |
| } | |
| return 0; | |
| } | |
| void y4m_input_close(y4m_input *_y4m) { | |
| free(_y4m->dst_buf); | |
| free(_y4m->aux_buf); | |
| } | |
| int y4m_input_fetch_frame(y4m_input *_y4m, FILE *_fin, aom_image_t *_img) { | |
| char frame[6]; | |
| int pic_sz; | |
| int c_w; | |
| int c_h; | |
| int c_sz; | |
| int bytes_per_sample = _y4m->bit_depth > 8 ? 2 : 1; | |
| /*Read and skip the frame header.*/ | |
| if (!file_read(frame, 6, _fin)) return 0; | |
| if (memcmp(frame, "FRAME", 5)) { | |
| fprintf(stderr, "Loss of framing in Y4M input data\n"); | |
| return -1; | |
| } | |
| if (frame[5] != '\n') { | |
| char c; | |
| int j; | |
| for (j = 0; j < 79 && file_read(&c, 1, _fin) && c != '\n'; j++) { | |
| } | |
| if (j == 79) { | |
| fprintf(stderr, "Error parsing Y4M frame header\n"); | |
| return -1; | |
| } | |
| } | |
| /*Read the frame data that needs no conversion.*/ | |
| if (!file_read(_y4m->dst_buf, _y4m->dst_buf_read_sz, _fin)) { | |
| fprintf(stderr, "Error reading Y4M frame data.\n"); | |
| return -1; | |
| } | |
| /*Read the frame data that does need conversion.*/ | |
| if (!file_read(_y4m->aux_buf, _y4m->aux_buf_read_sz, _fin)) { | |
| fprintf(stderr, "Error reading Y4M frame data.\n"); | |
| return -1; | |
| } | |
| /*Now convert the just read frame.*/ | |
| (*_y4m->convert)(_y4m, _y4m->dst_buf, _y4m->aux_buf); | |
| /*Fill in the frame buffer pointers. | |
| We don't use aom_img_wrap() because it forces padding for odd picture | |
| sizes, which would require a separate fread call for every row.*/ | |
| memset(_img, 0, sizeof(*_img)); | |
| /*Y4M has the planes in Y'CbCr order, which libaom calls Y, U, and V.*/ | |
| _img->fmt = _y4m->aom_fmt; | |
| _img->w = _img->d_w = _y4m->pic_w; | |
| _img->h = _img->d_h = _y4m->pic_h; | |
| _img->bit_depth = _y4m->bit_depth; | |
| _img->x_chroma_shift = _y4m->dst_c_dec_h >> 1; | |
| _img->y_chroma_shift = _y4m->dst_c_dec_v >> 1; | |
| _img->bps = _y4m->bps; | |
| /*Set up the buffer pointers.*/ | |
| pic_sz = _y4m->pic_w * _y4m->pic_h * bytes_per_sample; | |
| c_w = (_y4m->pic_w + _y4m->dst_c_dec_h - 1) / _y4m->dst_c_dec_h; | |
| c_w *= bytes_per_sample; | |
| c_h = (_y4m->pic_h + _y4m->dst_c_dec_v - 1) / _y4m->dst_c_dec_v; | |
| c_sz = c_w * c_h; | |
| _img->stride[AOM_PLANE_Y] = _y4m->pic_w * bytes_per_sample; | |
| _img->stride[AOM_PLANE_U] = _img->stride[AOM_PLANE_V] = c_w; | |
| _img->planes[AOM_PLANE_Y] = _y4m->dst_buf; | |
| _img->planes[AOM_PLANE_U] = _y4m->dst_buf + pic_sz; | |
| _img->planes[AOM_PLANE_V] = _y4m->dst_buf + pic_sz + c_sz; | |
| return 1; | |
| } |