/* * Copyright 2013 The LibYuv Project Authors. All rights reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ // Convert an ARGB image to YUV. // Usage: convert src_argb.raw dst_yuv.raw #ifndef _CRT_SECURE_NO_WARNINGS #define _CRT_SECURE_NO_WARNINGS #endif #include <stddef.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include "libyuv/convert.h" #include "libyuv/planar_functions.h" #include "libyuv/scale_argb.h" // options bool verbose = false; bool attenuate = false; bool unattenuate = false; int image_width = 0, image_height = 0; // original width and height int dst_width = 0, dst_height = 0; // new width and height int fileindex_org = 0; // argv argument contains the original file name. int fileindex_rec = 0; // argv argument contains the reconstructed file name. int num_rec = 0; // Number of reconstructed images. int num_skip_org = 0; // Number of frames to skip in original. int num_frames = 0; // Number of frames to convert. int filter = 1; // Bilinear filter for scaling. static __inline uint32 Abs(int32 v) { return v >= 0 ? v : -v; } // Parse PYUV format. ie name.1920x800_24Hz_P420.yuv bool ExtractResolutionFromFilename(const char* name, int* width_ptr, int* height_ptr) { // Isolate the .width_height. section of the filename by searching for a // dot or underscore followed by a digit. for (int i = 0; name[i]; ++i) { if ((name[i] == '.' || name[i] == '_') && name[i + 1] >= '0' && name[i + 1] <= '9') { int n = sscanf(name + i + 1, "%dx%d", width_ptr, height_ptr); // NOLINT if (2 == n) { return true; } } } return false; } void PrintHelp(const char * program) { printf("%s [-options] src_argb.raw dst_yuv.raw\n", program); printf(" -s <width> <height> .... specify source resolution. " "Optional if name contains\n" " resolution (ie. " "name.1920x800_24Hz_P420.yuv)\n" " Negative value mirrors.\n"); printf(" -d <width> <height> .... specify destination resolution.\n"); printf(" -f <filter> ............ 0 = point, 1 = bilinear (default).\n"); printf(" -skip <src_argb> ....... Number of frame to skip of src_argb\n"); printf(" -frames <num> .......... Number of frames to convert\n"); printf(" -attenuate ............. Attenuate the ARGB image\n"); printf(" -unattenuate ........... Unattenuate the ARGB image\n"); printf(" -v ..................... verbose\n"); printf(" -h ..................... this help\n"); exit(0); } void ParseOptions(int argc, const char* argv[]) { if (argc <= 1) PrintHelp(argv[0]); for (int c = 1; c < argc; ++c) { if (!strcmp(argv[c], "-v")) { verbose = true; } else if (!strcmp(argv[c], "-attenuate")) { attenuate = true; } else if (!strcmp(argv[c], "-unattenuate")) { unattenuate = true; } else if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) { PrintHelp(argv[0]); } else if (!strcmp(argv[c], "-s") && c + 2 < argc) { image_width = atoi(argv[++c]); // NOLINT image_height = atoi(argv[++c]); // NOLINT } else if (!strcmp(argv[c], "-d") && c + 2 < argc) { dst_width = atoi(argv[++c]); // NOLINT dst_height = atoi(argv[++c]); // NOLINT } else if (!strcmp(argv[c], "-skip") && c + 1 < argc) { num_skip_org = atoi(argv[++c]); // NOLINT } else if (!strcmp(argv[c], "-frames") && c + 1 < argc) { num_frames = atoi(argv[++c]); // NOLINT } else if (!strcmp(argv[c], "-f") && c + 1 < argc) { filter = atoi(argv[++c]); // NOLINT } else if (argv[c][0] == '-') { fprintf(stderr, "Unknown option. %s\n", argv[c]); } else if (fileindex_org == 0) { fileindex_org = c; } else if (fileindex_rec == 0) { fileindex_rec = c; num_rec = 1; } else { ++num_rec; } } if (fileindex_org == 0 || fileindex_rec == 0) { fprintf(stderr, "Missing filenames\n"); PrintHelp(argv[0]); } if (num_skip_org < 0) { fprintf(stderr, "Skipped frames incorrect\n"); PrintHelp(argv[0]); } if (num_frames < 0) { fprintf(stderr, "Number of frames incorrect\n"); PrintHelp(argv[0]); } int org_width, org_height; int rec_width, rec_height; bool org_res_avail = ExtractResolutionFromFilename(argv[fileindex_org], &org_width, &org_height); bool rec_res_avail = ExtractResolutionFromFilename(argv[fileindex_rec], &rec_width, &rec_height); if (image_width == 0 || image_height == 0) { if (org_res_avail) { image_width = org_width; image_height = org_height; } else if (rec_res_avail) { image_width = rec_width; image_height = rec_height; } else { fprintf(stderr, "Missing dimensions.\n"); PrintHelp(argv[0]); } } if (dst_width == 0 || dst_height == 0) { if (rec_res_avail) { dst_width = rec_width; dst_height = rec_height; } else { dst_width = Abs(image_width); dst_height = Abs(image_height); } } } static const int kTileX = 32; static const int kTileY = 32; static int TileARGBScale(const uint8* src_argb, int src_stride_argb, int src_width, int src_height, uint8* dst_argb, int dst_stride_argb, int dst_width, int dst_height, libyuv::FilterMode filtering) { for (int y = 0; y < dst_height; y += kTileY) { for (int x = 0; x < dst_width; x += kTileX) { int clip_width = kTileX; if (x + clip_width > dst_width) { clip_width = dst_width - x; } int clip_height = kTileY; if (y + clip_height > dst_height) { clip_height = dst_height - y; } int r = libyuv::ARGBScaleClip(src_argb, src_stride_argb, src_width, src_height, dst_argb, dst_stride_argb, dst_width, dst_height, x, y, clip_width, clip_height, filtering); if (r) { return r; } } } return 0; } int main(int argc, const char* argv[]) { ParseOptions(argc, argv); // Open original file (first file argument) FILE* const file_org = fopen(argv[fileindex_org], "rb"); if (file_org == NULL) { fprintf(stderr, "Cannot open %s\n", argv[fileindex_org]); exit(1); } // Open all files to convert to FILE** file_rec = new FILE* [num_rec]; memset(file_rec, 0, num_rec * sizeof(FILE*)); // NOLINT for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) { file_rec[cur_rec] = fopen(argv[fileindex_rec + cur_rec], "wb"); if (file_rec[cur_rec] == NULL) { fprintf(stderr, "Cannot open %s\n", argv[fileindex_rec + cur_rec]); fclose(file_org); for (int i = 0; i < cur_rec; ++i) { fclose(file_rec[i]); } delete[] file_rec; exit(1); } } bool org_is_yuv = strstr(argv[fileindex_org], "_P420.") != NULL; bool org_is_argb = strstr(argv[fileindex_org], "_ARGB.") != NULL; if (!org_is_yuv && !org_is_argb) { fprintf(stderr, "Original format unknown %s\n", argv[fileindex_org]); exit(1); } int org_size = Abs(image_width) * Abs(image_height) * 4; // ARGB // Input is YUV if (org_is_yuv) { const int y_size = Abs(image_width) * Abs(image_height); const int uv_size = ((Abs(image_width) + 1) / 2) * ((Abs(image_height) + 1) / 2); org_size = y_size + 2 * uv_size; // YUV original. } const int dst_size = dst_width * dst_height * 4; // ARGB scaled const int y_size = dst_width * dst_height; const int uv_size = ((dst_width + 1) / 2) * ((dst_height + 1) / 2); const size_t total_size = y_size + 2 * uv_size; #if defined(_MSC_VER) _fseeki64(file_org, static_cast<__int64>(num_skip_org) * static_cast<__int64>(org_size), SEEK_SET); #else fseek(file_org, num_skip_org * total_size, SEEK_SET); #endif uint8* const ch_org = new uint8[org_size]; uint8* const ch_dst = new uint8[dst_size]; uint8* const ch_rec = new uint8[total_size]; if (ch_org == NULL || ch_rec == NULL) { fprintf(stderr, "No memory available\n"); fclose(file_org); for (int i = 0; i < num_rec; ++i) { fclose(file_rec[i]); } delete[] ch_org; delete[] ch_dst; delete[] ch_rec; delete[] file_rec; exit(1); } if (verbose) { printf("Size: %dx%d to %dx%d\n", image_width, image_height, dst_width, dst_height); } int number_of_frames; for (number_of_frames = 0; ; ++number_of_frames) { if (num_frames && number_of_frames >= num_frames) break; // Load original YUV or ARGB frame. size_t bytes_org = fread(ch_org, sizeof(uint8), static_cast<size_t>(org_size), file_org); if (bytes_org < static_cast<size_t>(org_size)) break; // TODO(fbarchard): Attenuate doesnt need to know dimensions. // ARGB attenuate frame if (org_is_argb && attenuate) { libyuv::ARGBAttenuate(ch_org, 0, ch_org, 0, org_size / 4, 1); } // ARGB unattenuate frame if (org_is_argb && unattenuate) { libyuv::ARGBUnattenuate(ch_org, 0, ch_org, 0, org_size / 4, 1); } for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) { // Scale YUV or ARGB frame. if (org_is_yuv) { int src_width = Abs(image_width); int src_height = Abs(image_height); int half_src_width = (src_width + 1) / 2; int half_src_height = (src_height + 1) / 2; int half_dst_width = (dst_width + 1) / 2; int half_dst_height = (dst_height + 1) / 2; I420Scale(ch_org, src_width, ch_org + src_width * src_height, half_src_width, ch_org + src_width * src_height + half_src_width * half_src_height, half_src_width, image_width, image_height, ch_rec, dst_width, ch_rec + dst_width * dst_height, half_dst_width, ch_rec + dst_width * dst_height + half_dst_width * half_dst_height, half_dst_width, dst_width, dst_height, static_cast<libyuv::FilterMode>(filter)); } else { TileARGBScale(ch_org, Abs(image_width) * 4, image_width, image_height, ch_dst, dst_width * 4, dst_width, dst_height, static_cast<libyuv::FilterMode>(filter)); } bool rec_is_yuv = strstr(argv[fileindex_rec + cur_rec], "_P420.") != NULL; bool rec_is_argb = strstr(argv[fileindex_rec + cur_rec], "_ARGB.") != NULL; if (!rec_is_yuv && !rec_is_argb) { fprintf(stderr, "Output format unknown %s\n", argv[fileindex_rec + cur_rec]); continue; // Advance to next file. } // Convert ARGB to YUV. if (!org_is_yuv && rec_is_yuv) { int half_width = (dst_width + 1) / 2; int half_height = (dst_height + 1) / 2; libyuv::ARGBToI420(ch_dst, dst_width * 4, ch_rec, dst_width, ch_rec + dst_width * dst_height, half_width, ch_rec + dst_width * dst_height + half_width * half_height, half_width, dst_width, dst_height); } // Output YUV or ARGB frame. if (rec_is_yuv) { size_t bytes_rec = fwrite(ch_rec, sizeof(uint8), static_cast<size_t>(total_size), file_rec[cur_rec]); if (bytes_rec < static_cast<size_t>(total_size)) break; } else { size_t bytes_rec = fwrite(ch_dst, sizeof(uint8), static_cast<size_t>(dst_size), file_rec[cur_rec]); if (bytes_rec < static_cast<size_t>(dst_size)) break; } if (verbose) { printf("%5d", number_of_frames); } if (verbose) { printf("\t%s", argv[fileindex_rec + cur_rec]); printf("\n"); } } } fclose(file_org); for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) { fclose(file_rec[cur_rec]); } delete[] ch_org; delete[] ch_dst; delete[] ch_rec; delete[] file_rec; return 0; }