| /* |
| * 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. |
| */ |
| |
| #include <assert.h> |
| #include <math.h> |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "common/tools_common.h" |
| |
| #if CONFIG_AV1_ENCODER |
| #include "aom/aomcx.h" |
| #endif |
| |
| #if CONFIG_AV1_DECODER |
| #include "aom/aomdx.h" |
| #endif |
| |
| #if defined(_WIN32) |
| #include <io.h> |
| #include <fcntl.h> |
| #endif |
| |
| #define LOG_ERROR(label) \ |
| do { \ |
| const char *l = label; \ |
| va_list ap; \ |
| va_start(ap, fmt); \ |
| if (l) fprintf(stderr, "%s: ", l); \ |
| vfprintf(stderr, fmt, ap); \ |
| fprintf(stderr, "\n"); \ |
| va_end(ap); \ |
| } while (0) |
| |
| FILE *set_binary_mode(FILE *stream) { |
| (void)stream; |
| #if defined(_WIN32) |
| _setmode(_fileno(stream), _O_BINARY); |
| #endif |
| return stream; |
| } |
| |
| void die(const char *fmt, ...) { |
| LOG_ERROR(NULL); |
| usage_exit(); |
| } |
| |
| void fatal(const char *fmt, ...) { |
| LOG_ERROR("Fatal"); |
| exit(EXIT_FAILURE); |
| } |
| |
| void aom_tools_warn(const char *fmt, ...) { LOG_ERROR("Warning"); } |
| |
| void die_codec(aom_codec_ctx_t *ctx, const char *s) { |
| const char *detail = aom_codec_error_detail(ctx); |
| |
| fprintf(stderr, "%s: %s\n", s, aom_codec_error(ctx)); |
| if (detail) fprintf(stderr, " %s\n", detail); |
| exit(EXIT_FAILURE); |
| } |
| |
| const char *image_format_to_string(aom_img_fmt_t fmt) { |
| switch (fmt) { |
| case AOM_IMG_FMT_I420: return "I420"; |
| case AOM_IMG_FMT_I422: return "I422"; |
| case AOM_IMG_FMT_I444: return "I444"; |
| case AOM_IMG_FMT_YV12: return "YV12"; |
| case AOM_IMG_FMT_NV12: return "NV12"; |
| case AOM_IMG_FMT_YV1216: return "YV1216"; |
| case AOM_IMG_FMT_I42016: return "I42016"; |
| case AOM_IMG_FMT_I42216: return "I42216"; |
| case AOM_IMG_FMT_I44416: return "I44416"; |
| default: return "Other"; |
| } |
| } |
| |
| int read_yuv_frame(struct AvxInputContext *input_ctx, aom_image_t *yuv_frame) { |
| FILE *f = input_ctx->file; |
| struct FileTypeDetectionBuffer *detect = &input_ctx->detect; |
| int plane = 0; |
| int shortread = 0; |
| const int bytespp = (yuv_frame->fmt & AOM_IMG_FMT_HIGHBITDEPTH) ? 2 : 1; |
| |
| for (plane = 0; plane < 3; ++plane) { |
| uint8_t *ptr; |
| int w = aom_img_plane_width(yuv_frame, plane); |
| const int h = aom_img_plane_height(yuv_frame, plane); |
| int r; |
| // Assuming that for nv12 we read all chroma data at once |
| if (yuv_frame->fmt == AOM_IMG_FMT_NV12 && plane > 1) break; |
| if (yuv_frame->fmt == AOM_IMG_FMT_NV12 && plane == 1) w *= 2; |
| /* Determine the correct plane based on the image format. The for-loop |
| * always counts in Y,U,V order, but this may not match the order of |
| * the data on disk. |
| */ |
| switch (plane) { |
| case 1: |
| ptr = |
| yuv_frame->planes[yuv_frame->fmt == AOM_IMG_FMT_YV12 ? AOM_PLANE_V |
| : AOM_PLANE_U]; |
| break; |
| case 2: |
| ptr = |
| yuv_frame->planes[yuv_frame->fmt == AOM_IMG_FMT_YV12 ? AOM_PLANE_U |
| : AOM_PLANE_V]; |
| break; |
| default: ptr = yuv_frame->planes[plane]; |
| } |
| |
| for (r = 0; r < h; ++r) { |
| size_t needed = w * bytespp; |
| size_t buf_position = 0; |
| const size_t left = detect->buf_read - detect->position; |
| if (left > 0) { |
| const size_t more = (left < needed) ? left : needed; |
| memcpy(ptr, detect->buf + detect->position, more); |
| buf_position = more; |
| needed -= more; |
| detect->position += more; |
| } |
| if (needed > 0) { |
| shortread |= (fread(ptr + buf_position, 1, needed, f) < needed); |
| } |
| |
| ptr += yuv_frame->stride[plane]; |
| } |
| } |
| |
| return shortread; |
| } |
| |
| struct CodecInfo { |
| // Pointer to a function of zero arguments that returns an aom_codec_iface_t. |
| aom_codec_iface_t *(*interface)(void); |
| const char *short_name; |
| uint32_t fourcc; |
| }; |
| |
| #if CONFIG_AV1_ENCODER |
| static const struct CodecInfo aom_encoders[] = { |
| { &aom_codec_av1_cx, "av1", AV1_FOURCC }, |
| }; |
| |
| int get_aom_encoder_count(void) { |
| return sizeof(aom_encoders) / sizeof(aom_encoders[0]); |
| } |
| |
| aom_codec_iface_t *get_aom_encoder_by_index(int i) { |
| assert(i >= 0 && i < get_aom_encoder_count()); |
| return aom_encoders[i].interface(); |
| } |
| |
| aom_codec_iface_t *get_aom_encoder_by_short_name(const char *name) { |
| for (int i = 0; i < get_aom_encoder_count(); ++i) { |
| const struct CodecInfo *info = &aom_encoders[i]; |
| if (strcmp(info->short_name, name) == 0) return info->interface(); |
| } |
| return NULL; |
| } |
| |
| uint32_t get_fourcc_by_aom_encoder(aom_codec_iface_t *iface) { |
| for (int i = 0; i < get_aom_encoder_count(); ++i) { |
| const struct CodecInfo *info = &aom_encoders[i]; |
| if (info->interface() == iface) { |
| return info->fourcc; |
| } |
| } |
| return 0; |
| } |
| |
| const char *get_short_name_by_aom_encoder(aom_codec_iface_t *iface) { |
| for (int i = 0; i < get_aom_encoder_count(); ++i) { |
| const struct CodecInfo *info = &aom_encoders[i]; |
| if (info->interface() == iface) { |
| return info->short_name; |
| } |
| } |
| return NULL; |
| } |
| |
| #endif // CONFIG_AV1_ENCODER |
| |
| #if CONFIG_AV1_DECODER |
| static const struct CodecInfo aom_decoders[] = { |
| { &aom_codec_av1_dx, "av1", AV1_FOURCC }, |
| }; |
| |
| int get_aom_decoder_count(void) { |
| return sizeof(aom_decoders) / sizeof(aom_decoders[0]); |
| } |
| |
| aom_codec_iface_t *get_aom_decoder_by_index(int i) { |
| assert(i >= 0 && i < get_aom_decoder_count()); |
| return aom_decoders[i].interface(); |
| } |
| |
| aom_codec_iface_t *get_aom_decoder_by_short_name(const char *name) { |
| for (int i = 0; i < get_aom_decoder_count(); ++i) { |
| const struct CodecInfo *info = &aom_decoders[i]; |
| if (strcmp(info->short_name, name) == 0) return info->interface(); |
| } |
| return NULL; |
| } |
| |
| aom_codec_iface_t *get_aom_decoder_by_fourcc(uint32_t fourcc) { |
| for (int i = 0; i < get_aom_decoder_count(); ++i) { |
| const struct CodecInfo *info = &aom_decoders[i]; |
| if (info->fourcc == fourcc) return info->interface(); |
| } |
| return NULL; |
| } |
| |
| const char *get_short_name_by_aom_decoder(aom_codec_iface_t *iface) { |
| for (int i = 0; i < get_aom_decoder_count(); ++i) { |
| const struct CodecInfo *info = &aom_decoders[i]; |
| if (info->interface() == iface) { |
| return info->short_name; |
| } |
| } |
| return NULL; |
| } |
| |
| uint32_t get_fourcc_by_aom_decoder(aom_codec_iface_t *iface) { |
| for (int i = 0; i < get_aom_decoder_count(); ++i) { |
| const struct CodecInfo *info = &aom_decoders[i]; |
| if (info->interface() == iface) { |
| return info->fourcc; |
| } |
| } |
| return 0; |
| } |
| |
| #endif // CONFIG_AV1_DECODER |
| |
| void aom_img_write(const aom_image_t *img, FILE *file) { |
| int plane; |
| const int bytespp = (img->fmt & AOM_IMG_FMT_HIGHBITDEPTH) ? 2 : 1; |
| |
| for (plane = 0; plane < 3; ++plane) { |
| const unsigned char *buf = img->planes[plane]; |
| const int stride = img->stride[plane]; |
| int w = aom_img_plane_width(img, plane); |
| const int h = aom_img_plane_height(img, plane); |
| int y; |
| |
| // Assuming that for nv12 we write all chroma data at once |
| if (img->fmt == AOM_IMG_FMT_NV12 && plane > 1) break; |
| if (img->fmt == AOM_IMG_FMT_NV12 && plane == 1) w *= 2; |
| |
| for (y = 0; y < h; ++y) { |
| fwrite(buf, bytespp, w, file); |
| buf += stride; |
| } |
| } |
| } |
| |
| bool aom_img_read(aom_image_t *img, FILE *file) { |
| int plane; |
| const int bytespp = (img->fmt & AOM_IMG_FMT_HIGHBITDEPTH) ? 2 : 1; |
| |
| for (plane = 0; plane < 3; ++plane) { |
| unsigned char *buf = img->planes[plane]; |
| const int stride = img->stride[plane]; |
| int w = aom_img_plane_width(img, plane); |
| const int h = aom_img_plane_height(img, plane); |
| int y; |
| |
| // Assuming that for nv12 we read all chroma data at once |
| if (img->fmt == AOM_IMG_FMT_NV12 && plane > 1) break; |
| if (img->fmt == AOM_IMG_FMT_NV12 && plane == 1) w *= 2; |
| |
| for (y = 0; y < h; ++y) { |
| if (fread(buf, bytespp, w, file) != (size_t)w) return false; |
| buf += stride; |
| } |
| } |
| |
| return true; |
| } |
| |
| // TODO(dkovalev) change sse_to_psnr signature: double -> int64_t |
| double sse_to_psnr(double samples, double peak, double sse) { |
| static const double kMaxPSNR = 100.0; |
| |
| if (sse > 0.0) { |
| const double psnr = 10.0 * log10(samples * peak * peak / sse); |
| return psnr > kMaxPSNR ? kMaxPSNR : psnr; |
| } else { |
| return kMaxPSNR; |
| } |
| } |
| |
| // TODO(debargha): Consolidate the functions below into a separate file. |
| static void highbd_img_upshift(aom_image_t *dst, const aom_image_t *src, |
| int input_shift) { |
| // Note the offset is 1 less than half. |
| const int offset = input_shift > 0 ? (1 << (input_shift - 1)) - 1 : 0; |
| int plane; |
| if (dst->d_w != src->d_w || dst->d_h != src->d_h || |
| dst->x_chroma_shift != src->x_chroma_shift || |
| dst->y_chroma_shift != src->y_chroma_shift || dst->fmt != src->fmt || |
| input_shift < 0) { |
| fatal("Unsupported image conversion"); |
| } |
| switch (src->fmt) { |
| case AOM_IMG_FMT_I42016: |
| case AOM_IMG_FMT_I42216: |
| case AOM_IMG_FMT_I44416: break; |
| default: fatal("Unsupported image conversion"); |
| } |
| for (plane = 0; plane < 3; plane++) { |
| int w = src->d_w; |
| int h = src->d_h; |
| int x, y; |
| if (plane) { |
| w = (w + src->x_chroma_shift) >> src->x_chroma_shift; |
| h = (h + src->y_chroma_shift) >> src->y_chroma_shift; |
| } |
| for (y = 0; y < h; y++) { |
| const uint16_t *p_src = |
| (const uint16_t *)(src->planes[plane] + y * src->stride[plane]); |
| uint16_t *p_dst = |
| (uint16_t *)(dst->planes[plane] + y * dst->stride[plane]); |
| for (x = 0; x < w; x++) *p_dst++ = (*p_src++ << input_shift) + offset; |
| } |
| } |
| } |
| |
| static void lowbd_img_upshift(aom_image_t *dst, const aom_image_t *src, |
| int input_shift) { |
| // Note the offset is 1 less than half. |
| const int offset = input_shift > 0 ? (1 << (input_shift - 1)) - 1 : 0; |
| int plane; |
| if (dst->d_w != src->d_w || dst->d_h != src->d_h || |
| dst->x_chroma_shift != src->x_chroma_shift || |
| dst->y_chroma_shift != src->y_chroma_shift || |
| dst->fmt != src->fmt + AOM_IMG_FMT_HIGHBITDEPTH || input_shift < 0) { |
| fatal("Unsupported image conversion"); |
| } |
| switch (src->fmt) { |
| case AOM_IMG_FMT_YV12: |
| case AOM_IMG_FMT_I420: |
| case AOM_IMG_FMT_I422: |
| case AOM_IMG_FMT_I444: break; |
| default: fatal("Unsupported image conversion"); |
| } |
| for (plane = 0; plane < 3; plane++) { |
| int w = src->d_w; |
| int h = src->d_h; |
| int x, y; |
| if (plane) { |
| w = (w + src->x_chroma_shift) >> src->x_chroma_shift; |
| h = (h + src->y_chroma_shift) >> src->y_chroma_shift; |
| } |
| for (y = 0; y < h; y++) { |
| const uint8_t *p_src = src->planes[plane] + y * src->stride[plane]; |
| uint16_t *p_dst = |
| (uint16_t *)(dst->planes[plane] + y * dst->stride[plane]); |
| for (x = 0; x < w; x++) { |
| *p_dst++ = (*p_src++ << input_shift) + offset; |
| } |
| } |
| } |
| } |
| |
| void aom_img_upshift(aom_image_t *dst, const aom_image_t *src, |
| int input_shift) { |
| if (src->fmt & AOM_IMG_FMT_HIGHBITDEPTH) { |
| highbd_img_upshift(dst, src, input_shift); |
| } else { |
| lowbd_img_upshift(dst, src, input_shift); |
| } |
| } |
| |
| void aom_img_truncate_16_to_8(aom_image_t *dst, const aom_image_t *src) { |
| int plane; |
| if (dst->fmt + AOM_IMG_FMT_HIGHBITDEPTH != src->fmt || dst->d_w != src->d_w || |
| dst->d_h != src->d_h || dst->x_chroma_shift != src->x_chroma_shift || |
| dst->y_chroma_shift != src->y_chroma_shift) { |
| fatal("Unsupported image conversion"); |
| } |
| switch (dst->fmt) { |
| case AOM_IMG_FMT_I420: |
| case AOM_IMG_FMT_I422: |
| case AOM_IMG_FMT_I444: break; |
| default: fatal("Unsupported image conversion"); |
| } |
| for (plane = 0; plane < 3; plane++) { |
| int w = src->d_w; |
| int h = src->d_h; |
| int x, y; |
| if (plane) { |
| w = (w + src->x_chroma_shift) >> src->x_chroma_shift; |
| h = (h + src->y_chroma_shift) >> src->y_chroma_shift; |
| } |
| for (y = 0; y < h; y++) { |
| const uint16_t *p_src = |
| (const uint16_t *)(src->planes[plane] + y * src->stride[plane]); |
| uint8_t *p_dst = dst->planes[plane] + y * dst->stride[plane]; |
| for (x = 0; x < w; x++) { |
| *p_dst++ = (uint8_t)(*p_src++); |
| } |
| } |
| } |
| } |
| |
| static void highbd_img_downshift(aom_image_t *dst, const aom_image_t *src, |
| int down_shift) { |
| int plane; |
| if (dst->d_w != src->d_w || dst->d_h != src->d_h || |
| dst->x_chroma_shift != src->x_chroma_shift || |
| dst->y_chroma_shift != src->y_chroma_shift || dst->fmt != src->fmt || |
| down_shift < 0) { |
| fatal("Unsupported image conversion"); |
| } |
| switch (src->fmt) { |
| case AOM_IMG_FMT_I42016: |
| case AOM_IMG_FMT_I42216: |
| case AOM_IMG_FMT_I44416: break; |
| default: fatal("Unsupported image conversion"); |
| } |
| for (plane = 0; plane < 3; plane++) { |
| int w = src->d_w; |
| int h = src->d_h; |
| int x, y; |
| if (plane) { |
| w = (w + src->x_chroma_shift) >> src->x_chroma_shift; |
| h = (h + src->y_chroma_shift) >> src->y_chroma_shift; |
| } |
| for (y = 0; y < h; y++) { |
| const uint16_t *p_src = |
| (const uint16_t *)(src->planes[plane] + y * src->stride[plane]); |
| uint16_t *p_dst = |
| (uint16_t *)(dst->planes[plane] + y * dst->stride[plane]); |
| for (x = 0; x < w; x++) *p_dst++ = *p_src++ >> down_shift; |
| } |
| } |
| } |
| |
| static void lowbd_img_downshift(aom_image_t *dst, const aom_image_t *src, |
| int down_shift) { |
| int plane; |
| if (dst->d_w != src->d_w || dst->d_h != src->d_h || |
| dst->x_chroma_shift != src->x_chroma_shift || |
| dst->y_chroma_shift != src->y_chroma_shift || |
| src->fmt != dst->fmt + AOM_IMG_FMT_HIGHBITDEPTH || down_shift < 0) { |
| fatal("Unsupported image conversion"); |
| } |
| switch (dst->fmt) { |
| case AOM_IMG_FMT_I420: |
| case AOM_IMG_FMT_I422: |
| case AOM_IMG_FMT_I444: break; |
| default: fatal("Unsupported image conversion"); |
| } |
| for (plane = 0; plane < 3; plane++) { |
| int w = src->d_w; |
| int h = src->d_h; |
| int x, y; |
| if (plane) { |
| w = (w + src->x_chroma_shift) >> src->x_chroma_shift; |
| h = (h + src->y_chroma_shift) >> src->y_chroma_shift; |
| } |
| for (y = 0; y < h; y++) { |
| const uint16_t *p_src = |
| (const uint16_t *)(src->planes[plane] + y * src->stride[plane]); |
| uint8_t *p_dst = dst->planes[plane] + y * dst->stride[plane]; |
| for (x = 0; x < w; x++) { |
| *p_dst++ = *p_src++ >> down_shift; |
| } |
| } |
| } |
| } |
| |
| void aom_img_downshift(aom_image_t *dst, const aom_image_t *src, |
| int down_shift) { |
| if (dst->fmt & AOM_IMG_FMT_HIGHBITDEPTH) { |
| highbd_img_downshift(dst, src, down_shift); |
| } else { |
| lowbd_img_downshift(dst, src, down_shift); |
| } |
| } |
| |
| static int img_shifted_realloc_required(const aom_image_t *img, |
| const aom_image_t *shifted, |
| aom_img_fmt_t required_fmt) { |
| return img->d_w != shifted->d_w || img->d_h != shifted->d_h || |
| required_fmt != shifted->fmt; |
| } |
| |
| bool aom_shift_img(unsigned int output_bit_depth, aom_image_t **img_ptr, |
| aom_image_t **img_shifted_ptr) { |
| aom_image_t *img = *img_ptr; |
| aom_image_t *img_shifted = *img_shifted_ptr; |
| |
| const aom_img_fmt_t shifted_fmt = output_bit_depth == 8 |
| ? img->fmt & ~AOM_IMG_FMT_HIGHBITDEPTH |
| : img->fmt | AOM_IMG_FMT_HIGHBITDEPTH; |
| |
| if (shifted_fmt != img->fmt || output_bit_depth != img->bit_depth) { |
| if (img_shifted && |
| img_shifted_realloc_required(img, img_shifted, shifted_fmt)) { |
| aom_img_free(img_shifted); |
| img_shifted = NULL; |
| } |
| if (img_shifted) { |
| img_shifted->monochrome = img->monochrome; |
| } |
| if (!img_shifted) { |
| img_shifted = aom_img_alloc(NULL, shifted_fmt, img->d_w, img->d_h, 16); |
| if (!img_shifted) { |
| *img_shifted_ptr = NULL; |
| return false; |
| } |
| img_shifted->bit_depth = output_bit_depth; |
| img_shifted->monochrome = img->monochrome; |
| img_shifted->csp = img->csp; |
| } |
| if (output_bit_depth > img->bit_depth) { |
| aom_img_upshift(img_shifted, img, output_bit_depth - img->bit_depth); |
| } else { |
| aom_img_downshift(img_shifted, img, img->bit_depth - output_bit_depth); |
| } |
| *img_shifted_ptr = img_shifted; |
| *img_ptr = img_shifted; |
| } |
| |
| return true; |
| } |
| |
| // Related to I420, NV12 format has one luma "luminance" plane Y and one plane |
| // with U and V values interleaved. |
| void aom_img_write_nv12(const aom_image_t *img, FILE *file) { |
| // Y plane |
| const unsigned char *buf = img->planes[0]; |
| int stride = img->stride[0]; |
| int w = aom_img_plane_width(img, 0) * |
| ((img->fmt & AOM_IMG_FMT_HIGHBITDEPTH) ? 2 : 1); |
| int h = aom_img_plane_height(img, 0); |
| int x, y; |
| |
| for (y = 0; y < h; ++y) { |
| fwrite(buf, 1, w, file); |
| buf += stride; |
| } |
| |
| // Interleaved U and V plane |
| const unsigned char *ubuf = img->planes[1]; |
| const unsigned char *vbuf = img->planes[2]; |
| const size_t size = (img->fmt & AOM_IMG_FMT_HIGHBITDEPTH) ? 2 : 1; |
| stride = img->stride[1]; |
| w = aom_img_plane_width(img, 1); |
| h = aom_img_plane_height(img, 1); |
| |
| for (y = 0; y < h; ++y) { |
| for (x = 0; x < w; ++x) { |
| fwrite(ubuf, size, 1, file); |
| fwrite(vbuf, size, 1, file); |
| ubuf += size; |
| vbuf += size; |
| } |
| ubuf += (stride - w * size); |
| vbuf += (stride - w * size); |
| } |
| } |
| |
| size_t read_from_input(struct AvxInputContext *input_ctx, size_t n, |
| unsigned char *buf) { |
| const size_t buffered_bytes = |
| input_ctx->detect.buf_read - input_ctx->detect.position; |
| size_t read_n; |
| if (buffered_bytes == 0) { |
| read_n = fread(buf, 1, n, input_ctx->file); |
| } else if (n <= buffered_bytes) { |
| memcpy(buf, input_ctx->detect.buf + input_ctx->detect.position, n); |
| input_ctx->detect.position += n; |
| read_n = n; |
| } else { |
| memcpy(buf, input_ctx->detect.buf + input_ctx->detect.position, |
| buffered_bytes); |
| input_ctx->detect.position += buffered_bytes; |
| read_n = buffered_bytes; |
| read_n += |
| fread(buf + buffered_bytes, 1, n - buffered_bytes, input_ctx->file); |
| } |
| return read_n; |
| } |
| |
| size_t input_to_detect_buf(struct AvxInputContext *input_ctx, size_t n) { |
| if (n + input_ctx->detect.position > DETECT_BUF_SZ) { |
| die("Failed to store in the detect buffer, maximum size exceeded."); |
| } |
| const size_t buffered_bytes = |
| input_ctx->detect.buf_read - input_ctx->detect.position; |
| size_t read_n; |
| if (buffered_bytes == 0) { |
| read_n = fread(input_ctx->detect.buf + input_ctx->detect.buf_read, 1, n, |
| input_ctx->file); |
| input_ctx->detect.buf_read += read_n; |
| } else if (n <= buffered_bytes) { |
| // In this case, don't need to do anything as the data is already in |
| // the detect buffer |
| read_n = n; |
| } else { |
| read_n = fread(input_ctx->detect.buf + input_ctx->detect.buf_read, 1, |
| n - buffered_bytes, input_ctx->file); |
| input_ctx->detect.buf_read += read_n; |
| read_n += buffered_bytes; |
| } |
| return read_n; |
| } |
| |
| // Read from detect buffer to a buffer. If not enough, read from input and also |
| // buffer them first. |
| size_t buffer_input(struct AvxInputContext *input_ctx, size_t n, |
| unsigned char *buf, bool buffered) { |
| if (!buffered) { |
| return read_from_input(input_ctx, n, buf); |
| } |
| const size_t buf_n = input_to_detect_buf(input_ctx, n); |
| if (buf_n < n) { |
| return buf_n; |
| } |
| return read_from_input(input_ctx, n, buf); |
| } |
| |
| void rewind_detect(struct AvxInputContext *input_ctx) { |
| input_ctx->detect.position = 0; |
| } |
| |
| bool input_eof(struct AvxInputContext *input_ctx) { |
| return feof(input_ctx->file) && |
| input_ctx->detect.position == input_ctx->detect.buf_read; |
| } |