1 /*
2  *  Copyright 2013 The LibYuv 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 
11 // Convert an ARGB image to YUV.
12 // Usage: yuvconvert src_argb.raw dst_yuv.raw
13 
14 #ifndef _CRT_SECURE_NO_WARNINGS
15 #define _CRT_SECURE_NO_WARNINGS
16 #endif
17 
18 #include <stddef.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 
23 #include "libyuv/convert.h"
24 #include "libyuv/planar_functions.h"
25 #include "libyuv/scale_argb.h"
26 
27 // options
28 bool verbose = false;
29 bool attenuate = false;
30 bool unattenuate = false;
31 int image_width = 0, image_height = 0;  // original width and height
32 int dst_width = 0, dst_height = 0;      // new width and height
33 int fileindex_org = 0;  // argv argument contains the original file name.
34 int fileindex_rec = 0;  // argv argument contains the reconstructed file name.
35 int num_rec = 0;        // Number of reconstructed images.
36 int num_skip_org = 0;   // Number of frames to skip in original.
37 int num_frames = 0;     // Number of frames to convert.
38 int filter = 1;         // Bilinear filter for scaling.
39 
Abs(int32_t v)40 static __inline uint32_t Abs(int32_t v) {
41   return v >= 0 ? v : -v;
42 }
43 
44 // Parse PYUV format. ie name.1920x800_24Hz_P420.yuv
ExtractResolutionFromFilename(const char * name,int * width_ptr,int * height_ptr)45 bool ExtractResolutionFromFilename(const char* name,
46                                    int* width_ptr,
47                                    int* height_ptr) {
48   // Isolate the .width_height. section of the filename by searching for a
49   // dot or underscore followed by a digit.
50   for (int i = 0; name[i]; ++i) {
51     if ((name[i] == '.' || name[i] == '_') && name[i + 1] >= '0' &&
52         name[i + 1] <= '9') {
53       int n = sscanf(name + i + 1, "%dx%d", width_ptr, height_ptr);  // NOLINT
54       if (2 == n) {
55         return true;
56       }
57     }
58   }
59   return false;
60 }
61 
PrintHelp(const char * program)62 void PrintHelp(const char* program) {
63   printf("%s [-options] src_argb.raw dst_yuv.raw\n", program);
64   printf(
65       " -s <width> <height> .... specify source resolution.  "
66       "Optional if name contains\n"
67       "                          resolution (ie. "
68       "name.1920x800_24Hz_P420.yuv)\n"
69       "                          Negative value mirrors.\n");
70   printf(" -d <width> <height> .... specify destination resolution.\n");
71   printf(" -f <filter> ............ 0 = point, 1 = bilinear (default).\n");
72   printf(" -skip <src_argb> ....... Number of frame to skip of src_argb\n");
73   printf(" -frames <num> .......... Number of frames to convert\n");
74   printf(" -attenuate ............. Attenuate the ARGB image\n");
75   printf(" -unattenuate ........... Unattenuate the ARGB image\n");
76   printf(" -v ..................... verbose\n");
77   printf(" -h ..................... this help\n");
78   exit(0);
79 }
80 
ParseOptions(int argc,const char * argv[])81 void ParseOptions(int argc, const char* argv[]) {
82   if (argc <= 1) {
83     PrintHelp(argv[0]);
84   }
85   for (int c = 1; c < argc; ++c) {
86     if (!strcmp(argv[c], "-v")) {
87       verbose = true;
88     } else if (!strcmp(argv[c], "-attenuate")) {
89       attenuate = true;
90     } else if (!strcmp(argv[c], "-unattenuate")) {
91       unattenuate = true;
92     } else if (!strcmp(argv[c], "-h") || !strcmp(argv[c], "-help")) {
93       PrintHelp(argv[0]);
94     } else if (!strcmp(argv[c], "-s") && c + 2 < argc) {
95       image_width = atoi(argv[++c]);   // NOLINT
96       image_height = atoi(argv[++c]);  // NOLINT
97     } else if (!strcmp(argv[c], "-d") && c + 2 < argc) {
98       dst_width = atoi(argv[++c]);   // NOLINT
99       dst_height = atoi(argv[++c]);  // NOLINT
100     } else if (!strcmp(argv[c], "-skip") && c + 1 < argc) {
101       num_skip_org = atoi(argv[++c]);  // NOLINT
102     } else if (!strcmp(argv[c], "-frames") && c + 1 < argc) {
103       num_frames = atoi(argv[++c]);  // NOLINT
104     } else if (!strcmp(argv[c], "-f") && c + 1 < argc) {
105       filter = atoi(argv[++c]);  // NOLINT
106     } else if (argv[c][0] == '-') {
107       fprintf(stderr, "Unknown option. %s\n", argv[c]);
108     } else if (fileindex_org == 0) {
109       fileindex_org = c;
110     } else if (fileindex_rec == 0) {
111       fileindex_rec = c;
112       num_rec = 1;
113     } else {
114       ++num_rec;
115     }
116   }
117   if (fileindex_org == 0 || fileindex_rec == 0) {
118     fprintf(stderr, "Missing filenames\n");
119     PrintHelp(argv[0]);
120   }
121   if (num_skip_org < 0) {
122     fprintf(stderr, "Skipped frames incorrect\n");
123     PrintHelp(argv[0]);
124   }
125   if (num_frames < 0) {
126     fprintf(stderr, "Number of frames incorrect\n");
127     PrintHelp(argv[0]);
128   }
129 
130   int org_width, org_height;
131   int rec_width, rec_height;
132   bool org_res_avail = ExtractResolutionFromFilename(argv[fileindex_org],
133                                                      &org_width, &org_height);
134   bool rec_res_avail = ExtractResolutionFromFilename(argv[fileindex_rec],
135                                                      &rec_width, &rec_height);
136   if (image_width == 0 || image_height == 0) {
137     if (org_res_avail) {
138       image_width = org_width;
139       image_height = org_height;
140     } else if (rec_res_avail) {
141       image_width = rec_width;
142       image_height = rec_height;
143     } else {
144       fprintf(stderr, "Missing dimensions.\n");
145       PrintHelp(argv[0]);
146     }
147   }
148   if (dst_width == 0 || dst_height == 0) {
149     if (rec_res_avail) {
150       dst_width = rec_width;
151       dst_height = rec_height;
152     } else {
153       dst_width = Abs(image_width);
154       dst_height = Abs(image_height);
155     }
156   }
157 }
158 
159 static const int kTileX = 32;
160 static const int kTileY = 32;
161 
TileARGBScale(const uint8_t * src_argb,int src_stride_argb,int src_width,int src_height,uint8_t * dst_argb,int dst_stride_argb,int dst_width,int dst_height,libyuv::FilterMode filtering)162 static int TileARGBScale(const uint8_t* src_argb,
163                          int src_stride_argb,
164                          int src_width,
165                          int src_height,
166                          uint8_t* dst_argb,
167                          int dst_stride_argb,
168                          int dst_width,
169                          int dst_height,
170                          libyuv::FilterMode filtering) {
171   for (int y = 0; y < dst_height; y += kTileY) {
172     for (int x = 0; x < dst_width; x += kTileX) {
173       int clip_width = kTileX;
174       if (x + clip_width > dst_width) {
175         clip_width = dst_width - x;
176       }
177       int clip_height = kTileY;
178       if (y + clip_height > dst_height) {
179         clip_height = dst_height - y;
180       }
181       int r = libyuv::ARGBScaleClip(src_argb, src_stride_argb, src_width,
182                                     src_height, dst_argb, dst_stride_argb,
183                                     dst_width, dst_height, x, y, clip_width,
184                                     clip_height, filtering);
185       if (r) {
186         return r;
187       }
188     }
189   }
190   return 0;
191 }
192 
main(int argc,const char * argv[])193 int main(int argc, const char* argv[]) {
194   ParseOptions(argc, argv);
195 
196   // Open original file (first file argument)
197   FILE* const file_org = fopen(argv[fileindex_org], "rb");
198   if (file_org == NULL) {
199     fprintf(stderr, "Cannot open %s\n", argv[fileindex_org]);
200     exit(1);
201   }
202 
203   // Open all files to convert to
204   FILE** file_rec = new FILE*[num_rec];
205   memset(file_rec, 0, num_rec * sizeof(FILE*));  // NOLINT
206   for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
207     file_rec[cur_rec] = fopen(argv[fileindex_rec + cur_rec], "wb");
208     if (file_rec[cur_rec] == NULL) {
209       fprintf(stderr, "Cannot open %s\n", argv[fileindex_rec + cur_rec]);
210       fclose(file_org);
211       for (int i = 0; i < cur_rec; ++i) {
212         fclose(file_rec[i]);
213       }
214       delete[] file_rec;
215       exit(1);
216     }
217   }
218 
219   bool org_is_yuv = strstr(argv[fileindex_org], "_P420.") != NULL;
220   bool org_is_argb = strstr(argv[fileindex_org], "_ARGB.") != NULL;
221   if (!org_is_yuv && !org_is_argb) {
222     fprintf(stderr, "Original format unknown %s\n", argv[fileindex_org]);
223     exit(1);
224   }
225   int org_size = Abs(image_width) * Abs(image_height) * 4;  // ARGB
226   // Input is YUV
227   if (org_is_yuv) {
228     const int y_size = Abs(image_width) * Abs(image_height);
229     const int uv_size =
230         ((Abs(image_width) + 1) / 2) * ((Abs(image_height) + 1) / 2);
231     org_size = y_size + 2 * uv_size;  // YUV original.
232   }
233 
234   const int dst_size = dst_width * dst_height * 4;  // ARGB scaled
235   const int y_size = dst_width * dst_height;
236   const int uv_size = ((dst_width + 1) / 2) * ((dst_height + 1) / 2);
237   const size_t total_size = y_size + 2 * uv_size;
238 #if defined(_MSC_VER)
239   _fseeki64(file_org,
240             static_cast<__int64>(num_skip_org) * static_cast<__int64>(org_size),
241             SEEK_SET);
242 #else
243   fseek(file_org, num_skip_org * total_size, SEEK_SET);
244 #endif
245 
246   uint8_t* const ch_org = new uint8_t[org_size];
247   uint8_t* const ch_dst = new uint8_t[dst_size];
248   uint8_t* const ch_rec = new uint8_t[total_size];
249   if (ch_org == NULL || ch_rec == NULL) {
250     fprintf(stderr, "No memory available\n");
251     fclose(file_org);
252     for (int i = 0; i < num_rec; ++i) {
253       fclose(file_rec[i]);
254     }
255     delete[] ch_org;
256     delete[] ch_dst;
257     delete[] ch_rec;
258     delete[] file_rec;
259     exit(1);
260   }
261 
262   if (verbose) {
263     printf("Size: %dx%d to %dx%d\n", image_width, image_height, dst_width,
264            dst_height);
265   }
266 
267   int number_of_frames;
268   for (number_of_frames = 0;; ++number_of_frames) {
269     if (num_frames && number_of_frames >= num_frames) {
270       break;
271     }
272 
273     // Load original YUV or ARGB frame.
274     size_t bytes_org =
275         fread(ch_org, sizeof(uint8_t), static_cast<size_t>(org_size), file_org);
276     if (bytes_org < static_cast<size_t>(org_size)) {
277       break;
278     }
279 
280     // TODO(fbarchard): Attenuate doesnt need to know dimensions.
281     // ARGB attenuate frame
282     if (org_is_argb && attenuate) {
283       libyuv::ARGBAttenuate(ch_org, 0, ch_org, 0, org_size / 4, 1);
284     }
285     // ARGB unattenuate frame
286     if (org_is_argb && unattenuate) {
287       libyuv::ARGBUnattenuate(ch_org, 0, ch_org, 0, org_size / 4, 1);
288     }
289 
290     for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
291       // Scale YUV or ARGB frame.
292       if (org_is_yuv) {
293         int src_width = Abs(image_width);
294         int src_height = Abs(image_height);
295         int half_src_width = (src_width + 1) / 2;
296         int half_src_height = (src_height + 1) / 2;
297         int half_dst_width = (dst_width + 1) / 2;
298         int half_dst_height = (dst_height + 1) / 2;
299         I420Scale(
300             ch_org, src_width, ch_org + src_width * src_height, half_src_width,
301             ch_org + src_width * src_height + half_src_width * half_src_height,
302             half_src_width, image_width, image_height, ch_rec, dst_width,
303             ch_rec + dst_width * dst_height, half_dst_width,
304             ch_rec + dst_width * dst_height + half_dst_width * half_dst_height,
305             half_dst_width, dst_width, dst_height,
306             static_cast<libyuv::FilterMode>(filter));
307       } else {
308         TileARGBScale(ch_org, Abs(image_width) * 4, image_width, image_height,
309                       ch_dst, dst_width * 4, dst_width, dst_height,
310                       static_cast<libyuv::FilterMode>(filter));
311       }
312       bool rec_is_yuv = strstr(argv[fileindex_rec + cur_rec], "_P420.") != NULL;
313       bool rec_is_argb =
314           strstr(argv[fileindex_rec + cur_rec], "_ARGB.") != NULL;
315       if (!rec_is_yuv && !rec_is_argb) {
316         fprintf(stderr, "Output format unknown %s\n",
317                 argv[fileindex_rec + cur_rec]);
318         continue;  // Advance to next file.
319       }
320 
321       // Convert ARGB to YUV.
322       if (!org_is_yuv && rec_is_yuv) {
323         int half_width = (dst_width + 1) / 2;
324         int half_height = (dst_height + 1) / 2;
325         libyuv::ARGBToI420(
326             ch_dst, dst_width * 4, ch_rec, dst_width,
327             ch_rec + dst_width * dst_height, half_width,
328             ch_rec + dst_width * dst_height + half_width * half_height,
329             half_width, dst_width, dst_height);
330       }
331 
332       // Output YUV or ARGB frame.
333       if (rec_is_yuv) {
334         size_t bytes_rec =
335             fwrite(ch_rec, sizeof(uint8_t), static_cast<size_t>(total_size),
336                    file_rec[cur_rec]);
337         if (bytes_rec < static_cast<size_t>(total_size)) {
338           break;
339         }
340       } else {
341         size_t bytes_rec =
342             fwrite(ch_dst, sizeof(uint8_t), static_cast<size_t>(dst_size),
343                    file_rec[cur_rec]);
344         if (bytes_rec < static_cast<size_t>(dst_size)) {
345           break;
346         }
347       }
348       if (verbose) {
349         printf("%5d", number_of_frames);
350       }
351       if (verbose) {
352         printf("\t%s", argv[fileindex_rec + cur_rec]);
353         printf("\n");
354       }
355     }
356   }
357 
358   fclose(file_org);
359   for (int cur_rec = 0; cur_rec < num_rec; ++cur_rec) {
360     fclose(file_rec[cur_rec]);
361   }
362   delete[] ch_org;
363   delete[] ch_dst;
364   delete[] ch_rec;
365   delete[] file_rec;
366   return 0;
367 }
368