[svn] / trunk / xvidcore / examples / xvid_decraw.c Repository:
ViewVC logotype

Annotation of /trunk/xvidcore/examples/xvid_decraw.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1881 - (view) (download)

1 : edgomez 547 /*****************************************************************************
2 : chl 376 *
3 : edgomez 547 * XVID MPEG-4 VIDEO CODEC
4 :     * - Console based decoding test application -
5 : chl 376 *
6 : edgomez 851 * Copyright(C) 2002-2003 Christoph Lampert
7 : edgomez 1382 * 2002-2003 Edouard Gomez <ed.gomez@free.fr>
8 : chl 376 *
9 : edgomez 547 * This program is free software; you can redistribute it and/or modify
10 :     * it under the terms of the GNU General Public License as published by
11 :     * the Free Software Foundation; either version 2 of the License, or
12 :     * (at your option) any later version.
13 : chl 376 *
14 : edgomez 547 * This program is distributed in the hope that it will be useful,
15 :     * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 :     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 :     * GNU General Public License for more details.
18 : chl 376 *
19 : edgomez 547 * You should have received a copy of the GNU General Public License
20 :     * along with this program; if not, write to the Free Software
21 :     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 :     *
23 : Isibaar 1881 * $Id: xvid_decraw.c,v 1.26 2010-01-08 10:03:09 Isibaar Exp $
24 : edgomez 547 *
25 :     ****************************************************************************/
26 : chl 376
27 : edgomez 547 /*****************************************************************************
28 : chl 376 *
29 : edgomez 547 * Application notes :
30 : chl 376 *
31 : edgomez 547 * An MPEG-4 bitstream is read from an input file (or stdin) and decoded,
32 :     * the speed for this is measured.
33 : edgomez 1382 *
34 :     * The program is plain C and needs no libraries except for libxvidcore,
35 :     * and maths-lib.
36 : chl 376 *
37 : edgomez 1382 * Use ./xvid_decraw -help for a list of options
38 : chl 376 *
39 : edgomez 547 ****************************************************************************/
40 : chl 376
41 :     #include <stdio.h>
42 :     #include <stdlib.h>
43 : edgomez 547 #include <string.h>
44 :     #include <math.h>
45 : edgomez 824 #ifndef WIN32
46 : edgomez 547 #include <sys/time.h>
47 :     #else
48 :     #include <time.h>
49 :     #endif
50 : chl 376
51 : edgomez 547 #include "xvid.h"
52 : chl 376
53 : edgomez 547 /*****************************************************************************
54 :     * Global vars in module and constants
55 :     ****************************************************************************/
56 : chl 376
57 : edgomez 1423 #define USE_PNM 0
58 :     #define USE_TGA 1
59 : Isibaar 1880 #define USE_YUV 2
60 : edgomez 1423
61 : edgomez 547 static int XDIM = 0;
62 :     static int YDIM = 0;
63 :     static int ARG_SAVEDECOUTPUT = 0;
64 :     static int ARG_SAVEMPEGSTREAM = 0;
65 :     static char *ARG_INPUTFILE = NULL;
66 : edgomez 1423 static int CSP = XVID_CSP_I420;
67 :     static int BPP = 1;
68 :     static int FORMAT = USE_PNM;
69 : chl 376
70 : edgomez 547 static char filepath[256] = "./";
71 :     static void *dec_handle = NULL;
72 : chl 376
73 : edgomez 1382 #define BUFFER_SIZE (2*1024*1024)
74 : chl 376
75 : edgomez 1547 static const int display_buffer_bytes = 0;
76 :    
77 : suxen_drol 1637 #define MIN_USEFUL_BYTES 1
78 :    
79 : edgomez 547 /*****************************************************************************
80 :     * Local prototypes
81 :     ****************************************************************************/
82 : chl 376
83 : edgomez 547 static double msecond();
84 : suxen_drol 1416 static int dec_init(int use_assembler, int debug_level);
85 : edgomez 547 static int dec_main(unsigned char *istream,
86 : edgomez 851 unsigned char *ostream,
87 :     int istream_size,
88 : edgomez 1382 xvid_dec_stats_t *xvid_dec_stats);
89 : edgomez 547 static int dec_stop();
90 :     static void usage();
91 : Isibaar 1881 static int write_image(char *prefix, unsigned char *image, int filenr);
92 : edgomez 1442 static int write_pnm(char *filename, unsigned char *image);
93 :     static int write_tga(char *filename, unsigned char *image);
94 : Isibaar 1880 static int write_yuv(char *filename, unsigned char *image);
95 : edgomez 547
96 : edgomez 1382 const char * type2str(int type)
97 :     {
98 :     if (type==XVID_TYPE_IVOP)
99 :     return "I";
100 :     if (type==XVID_TYPE_PVOP)
101 :     return "P";
102 :     if (type==XVID_TYPE_BVOP)
103 :     return "B";
104 :     return "S";
105 :     }
106 :    
107 : edgomez 547 /*****************************************************************************
108 :     * Main program
109 :     ****************************************************************************/
110 :    
111 :     int main(int argc, char *argv[])
112 : chl 376 {
113 : edgomez 547 unsigned char *mp4_buffer = NULL;
114 :     unsigned char *mp4_ptr = NULL;
115 :     unsigned char *out_buffer = NULL;
116 : edgomez 1382 int useful_bytes;
117 : edgomez 1547 int chunk;
118 : edgomez 1382 xvid_dec_stats_t xvid_dec_stats;
119 : edgomez 851
120 : edgomez 547 double totaldectime;
121 :    
122 :     long totalsize;
123 :     int status;
124 :    
125 :     int use_assembler = 0;
126 : suxen_drol 1416 int debug_level = 0;
127 : edgomez 547
128 :     char filename[256];
129 :    
130 :     FILE *in_file;
131 :     int filenr;
132 :     int i;
133 :    
134 :     printf("xvid_decraw - raw mpeg4 bitstream decoder ");
135 : edgomez 851 printf("written by Christoph Lampert 2002-2003\n\n");
136 : edgomez 547
137 :     /*****************************************************************************
138 :     * Command line parsing
139 :     ****************************************************************************/
140 :    
141 :     for (i=1; i< argc; i++) {
142 :    
143 :     if (strcmp("-asm", argv[i]) == 0 ) {
144 :     use_assembler = 1;
145 : suxen_drol 1416 } else if (strcmp("-debug", argv[i]) == 0 && i < argc - 1 ) {
146 :     i++;
147 :     if (sscanf(argv[i], "0x%x", &debug_level) != 1) {
148 :     debug_level = atoi(argv[i]);
149 :     }
150 : edgomez 1382 } else if (strcmp("-d", argv[i]) == 0) {
151 :     ARG_SAVEDECOUTPUT = 1;
152 :     } else if (strcmp("-i", argv[i]) == 0 && i < argc - 1 ) {
153 : edgomez 547 i++;
154 :     ARG_INPUTFILE = argv[i];
155 : edgomez 1382 } else if (strcmp("-m", argv[i]) == 0) {
156 :     ARG_SAVEMPEGSTREAM = 1;
157 : edgomez 1423 } else if (strcmp("-c", argv[i]) == 0 && i < argc - 1 ) {
158 :     i++;
159 :     if (strcmp(argv[i], "rgb16") == 0) {
160 :     CSP = XVID_CSP_RGB555;
161 :     BPP = 2;
162 :     } else if (strcmp(argv[i], "rgb24") == 0) {
163 :     CSP = XVID_CSP_BGR;
164 :     BPP = 3;
165 :     } else if (strcmp(argv[i], "rgb32") == 0) {
166 :     CSP = XVID_CSP_BGRA;
167 :     BPP = 4;
168 :     } else if (strcmp(argv[i], "yv12") == 0) {
169 :     CSP = XVID_CSP_YV12;
170 :     BPP = 1;
171 :     } else {
172 :     CSP = XVID_CSP_I420;
173 :     BPP = 1;
174 :     }
175 :     } else if (strcmp("-f", argv[i]) == 0 && i < argc -1) {
176 :     i++;
177 :     if (strcmp(argv[i], "tga") == 0) {
178 :     FORMAT = USE_TGA;
179 : Isibaar 1880 } else if (strcmp(argv[i], "yuv") == 0) {
180 :     FORMAT = USE_YUV;
181 : edgomez 1423 } else {
182 :     FORMAT = USE_PNM;
183 :     }
184 : edgomez 1382 } else if (strcmp("-help", argv[i]) == 0) {
185 : edgomez 547 usage();
186 :     return(0);
187 : edgomez 1382 } else {
188 : edgomez 547 usage();
189 :     exit(-1);
190 :     }
191 : chl 376 }
192 : edgomez 1432
193 : suxen_drol 1426 #if defined(_MSC_VER)
194 :     if (ARG_INPUTFILE==NULL) {
195 : edgomez 1432 fprintf(stderr, "Warning: MSVC build does not read EOF correctly from stdin. Use the -i switch.\n\n");
196 : suxen_drol 1426 }
197 :     #endif
198 : edgomez 1432
199 : edgomez 547 /*****************************************************************************
200 :     * Values checking
201 :     ****************************************************************************/
202 :    
203 :     if ( ARG_INPUTFILE == NULL || strcmp(ARG_INPUTFILE, "stdin") == 0) {
204 :     in_file = stdin;
205 :     }
206 :     else {
207 :    
208 :     in_file = fopen(ARG_INPUTFILE, "rb");
209 :     if (in_file == NULL) {
210 :     fprintf(stderr, "Error opening input file %s\n", ARG_INPUTFILE);
211 : edgomez 1382 return(-1);
212 : edgomez 547 }
213 :     }
214 :    
215 : edgomez 1423 /* PNM/PGM format can't handle 16/32 bit data */
216 :     if (BPP != 1 && BPP != 3 && FORMAT == USE_PNM) {
217 :     FORMAT = USE_TGA;
218 :     }
219 : Isibaar 1880 if (BPP != 1 && FORMAT == USE_YUV) {
220 :     FORMAT = USE_TGA;
221 :     }
222 : edgomez 1423
223 : edgomez 547 /*****************************************************************************
224 :     * Memory allocation
225 :     ****************************************************************************/
226 :    
227 :     /* Memory for encoded mp4 stream */
228 :     mp4_buffer = (unsigned char *) malloc(BUFFER_SIZE);
229 :     mp4_ptr = mp4_buffer;
230 :     if (!mp4_buffer)
231 :     goto free_all_memory;
232 :    
233 :     /*****************************************************************************
234 :     * XviD PART Start
235 :     ****************************************************************************/
236 :    
237 : suxen_drol 1416 status = dec_init(use_assembler, debug_level);
238 : edgomez 547 if (status) {
239 :     fprintf(stderr,
240 : edgomez 1382 "Decore INIT problem, return value %d\n", status);
241 : edgomez 547 goto release_all;
242 :     }
243 :    
244 :    
245 :     /*****************************************************************************
246 :     * Main loop
247 :     ****************************************************************************/
248 :    
249 : edgomez 851 /* Fill the buffer */
250 : edgomez 1382 useful_bytes = fread(mp4_buffer, 1, BUFFER_SIZE, in_file);
251 : edgomez 559
252 : edgomez 547 totaldectime = 0;
253 :     totalsize = 0;
254 :     filenr = 0;
255 :     mp4_ptr = mp4_buffer;
256 : edgomez 1547 chunk = 0;
257 :    
258 : edgomez 547 do {
259 :     int used_bytes = 0;
260 :     double dectime;
261 :    
262 : edgomez 851 /*
263 :     * If the buffer is half empty or there are no more bytes in it
264 :     * then fill it.
265 :     */
266 : edgomez 1382 if (mp4_ptr > mp4_buffer + BUFFER_SIZE/2) {
267 :     int already_in_buffer = (mp4_buffer + BUFFER_SIZE - mp4_ptr);
268 : edgomez 547
269 : edgomez 851 /* Move data if needed */
270 : edgomez 1382 if (already_in_buffer > 0)
271 :     memcpy(mp4_buffer, mp4_ptr, already_in_buffer);
272 : edgomez 547
273 : edgomez 851 /* Update mp4_ptr */
274 :     mp4_ptr = mp4_buffer;
275 : edgomez 547
276 : edgomez 851 /* read new data */
277 : Isibaar 1678 if(!feof(in_file)) {
278 :     useful_bytes += fread(mp4_buffer + already_in_buffer,
279 :     1, BUFFER_SIZE - already_in_buffer,
280 :     in_file);
281 :     }
282 : edgomez 547 }
283 :    
284 :    
285 : edgomez 1382 /* This loop is needed to handle VOL/NVOP reading */
286 : edgomez 851 do {
287 : edgomez 547
288 : edgomez 851 /* Decode frame */
289 :     dectime = msecond();
290 : edgomez 1382 used_bytes = dec_main(mp4_ptr, out_buffer, useful_bytes, &xvid_dec_stats);
291 : edgomez 851 dectime = msecond() - dectime;
292 : edgomez 547
293 : edgomez 1382 /* Resize image buffer if needed */
294 :     if(xvid_dec_stats.type == XVID_TYPE_VOL) {
295 :    
296 :     /* Check if old buffer is smaller */
297 :     if(XDIM*YDIM < xvid_dec_stats.data.vol.width*xvid_dec_stats.data.vol.height) {
298 :    
299 :     /* Copy new witdh and new height from the vol structure */
300 :     XDIM = xvid_dec_stats.data.vol.width;
301 :     YDIM = xvid_dec_stats.data.vol.height;
302 :    
303 :     /* Free old output buffer*/
304 :     if(out_buffer) free(out_buffer);
305 :    
306 :     /* Allocate the new buffer */
307 :     out_buffer = (unsigned char*)malloc(XDIM*YDIM*4);
308 :     if(out_buffer == NULL)
309 :     goto free_all_memory;
310 :    
311 :     fprintf(stderr, "Resized frame buffer to %dx%d\n", XDIM, YDIM);
312 :     }
313 : edgomez 1547
314 :     /* Save individual mpeg4 stream if required */
315 :     if(ARG_SAVEMPEGSTREAM) {
316 :     FILE *filehandle = NULL;
317 :    
318 :     sprintf(filename, "%svolhdr.m4v", filepath);
319 :     filehandle = fopen(filename, "wb");
320 :     if(!filehandle) {
321 :     fprintf(stderr,
322 :     "Error writing vol header mpeg4 stream to file %s\n",
323 :     filename);
324 :     } else {
325 :     fwrite(mp4_ptr, 1, used_bytes, filehandle);
326 :     fclose(filehandle);
327 :     }
328 :     }
329 : edgomez 851 }
330 : edgomez 547
331 : edgomez 851 /* Update buffer pointers */
332 : edgomez 1382 if(used_bytes > 0) {
333 :     mp4_ptr += used_bytes;
334 :     useful_bytes -= used_bytes;
335 : edgomez 559
336 : edgomez 1382 /* Total size */
337 :     totalsize += used_bytes;
338 :     }
339 : edgomez 547
340 : edgomez 1547 if (display_buffer_bytes) {
341 :     printf("Data chunk %d: %d bytes consumed, %d bytes in buffer\n", chunk++, used_bytes, useful_bytes);
342 :     }
343 : suxen_drol 1637 } while (xvid_dec_stats.type <= 0 && useful_bytes > MIN_USEFUL_BYTES);
344 : edgomez 547
345 : edgomez 1382 /* Check if there is a negative number of useful bytes left in buffer
346 :     * This means we went too far */
347 :     if(useful_bytes < 0)
348 :     break;
349 : edgomez 851
350 : edgomez 1382 /* Updated data - Count only usefull decode time */
351 : edgomez 851 totaldectime += dectime;
352 : edgomez 547
353 : edgomez 851
354 : edgomez 1547 if (!display_buffer_bytes) {
355 :     printf("Frame %5d: type = %s, dectime(ms) =%6.1f, length(bytes) =%7d\n",
356 :     filenr, type2str(xvid_dec_stats.type), dectime, used_bytes);
357 :     }
358 :    
359 : edgomez 851 /* Save individual mpeg4 stream if required */
360 : edgomez 1382 if(ARG_SAVEMPEGSTREAM) {
361 : edgomez 547 FILE *filehandle = NULL;
362 :    
363 :     sprintf(filename, "%sframe%05d.m4v", filepath, filenr);
364 :     filehandle = fopen(filename, "wb");
365 :     if(!filehandle) {
366 :     fprintf(stderr,
367 : edgomez 851 "Error writing single mpeg4 stream to file %s\n",
368 :     filename);
369 : edgomez 547 }
370 :     else {
371 : edgomez 1382 fwrite(mp4_ptr-used_bytes, 1, used_bytes, filehandle);
372 : edgomez 547 fclose(filehandle);
373 :     }
374 :     }
375 : edgomez 851
376 : edgomez 547 /* Save output frame if required */
377 :     if (ARG_SAVEDECOUTPUT) {
378 : Isibaar 1881 sprintf(filename, "%sdec", filepath);
379 :    
380 :     if(write_image(filename, out_buffer, filenr)) {
381 : edgomez 547 fprintf(stderr,
382 : edgomez 1442 "Error writing decoded frame %s\n",
383 : edgomez 851 filename);
384 : edgomez 547 }
385 :     }
386 :    
387 :     filenr++;
388 :    
389 : suxen_drol 1637 } while (useful_bytes>MIN_USEFUL_BYTES || !feof(in_file));
390 : edgomez 547
391 : edgomez 1547 useful_bytes = 0; /* Empty buffer */
392 :    
393 : edgomez 547 /*****************************************************************************
394 : edgomez 851 * Flush decoder buffers
395 :     ****************************************************************************/
396 :    
397 : edgomez 1382 do {
398 :    
399 : edgomez 851 /* Fake vars */
400 : edgomez 1382 int used_bytes;
401 : edgomez 851 double dectime;
402 :    
403 : edgomez 1382 do {
404 :     dectime = msecond();
405 :     used_bytes = dec_main(NULL, out_buffer, -1, &xvid_dec_stats);
406 :     dectime = msecond() - dectime;
407 : edgomez 1547 if (display_buffer_bytes) {
408 :     printf("Data chunk %d: %d bytes consumed, %d bytes in buffer\n", chunk++, used_bytes, useful_bytes);
409 :     }
410 :     } while(used_bytes>=0 && xvid_dec_stats.type <= 0);
411 : edgomez 851
412 : edgomez 1382 if (used_bytes < 0) { /* XVID_ERR_END */
413 :     break;
414 :     }
415 : edgomez 851
416 :     /* Updated data - Count only usefull decode time */
417 :     totaldectime += dectime;
418 :    
419 :     /* Prints some decoding stats */
420 : edgomez 1547 if (!display_buffer_bytes) {
421 :     printf("Frame %5d: type = %s, dectime(ms) =%6.1f, length(bytes) =%7d\n",
422 :     filenr, type2str(xvid_dec_stats.type), dectime, used_bytes);
423 :     }
424 :    
425 : edgomez 851 /* Save output frame if required */
426 :     if (ARG_SAVEDECOUTPUT) {
427 : Isibaar 1881 sprintf(filename, "%sdec", filepath);
428 :    
429 :     if(write_image(filename, out_buffer, filenr)) {
430 : edgomez 851 fprintf(stderr,
431 : suxen_drol 1426 "Error writing decoded frame %s\n",
432 : edgomez 851 filename);
433 :     }
434 :     }
435 :    
436 :     filenr++;
437 :    
438 : edgomez 1382 }while(1);
439 : edgomez 851
440 :     /*****************************************************************************
441 : edgomez 547 * Calculate totals and averages for output, print results
442 :     ****************************************************************************/
443 :    
444 : suxen_drol 1426 if (filenr>0) {
445 : edgomez 1432 totalsize /= filenr;
446 : suxen_drol 1426 totaldectime /= filenr;
447 :     printf("Avg: dectime(ms) =%7.2f, fps =%7.2f, length(bytes) =%7d\n",
448 :     totaldectime, 1000/totaldectime, (int)totalsize);
449 :     }else{
450 :     printf("Nothing was decoded!\n");
451 :     }
452 : edgomez 547
453 :     /*****************************************************************************
454 :     * XviD PART Stop
455 : edgomez 559 ****************************************************************************/
456 : edgomez 547
457 :     release_all:
458 :     if (dec_handle) {
459 :     status = dec_stop();
460 :     if (status)
461 :     fprintf(stderr, "decore RELEASE problem return value %d\n", status);
462 :     }
463 :    
464 :     free_all_memory:
465 :     free(out_buffer);
466 :     free(mp4_buffer);
467 :    
468 : edgomez 1382 return(0);
469 : chl 376 }
470 :    
471 : edgomez 547 /*****************************************************************************
472 :     * Usage function
473 :     ****************************************************************************/
474 : chl 376
475 : edgomez 547 static void usage()
476 : chl 376 {
477 : edgomez 547
478 : edgomez 1382 fprintf(stderr, "Usage : xvid_decraw [OPTIONS]\n");
479 : edgomez 547 fprintf(stderr, "Options :\n");
480 :     fprintf(stderr, " -asm : use assembly optimizations (default=disabled)\n");
481 : suxen_drol 1416 fprintf(stderr, " -debug : debug level (debug=0)\n");
482 : edgomez 547 fprintf(stderr, " -i string : input filename (default=stdin)\n");
483 : edgomez 1382 fprintf(stderr, " -d : save decoder output\n");
484 : edgomez 1423 fprintf(stderr, " -c csp : choose colorspace output (rgb16, rgb24, rgb32, yv12, i420)\n");
485 : Isibaar 1880 fprintf(stderr, " -f format : choose output file format (tga, pnm, pgm, yuv)\n");
486 : edgomez 1382 fprintf(stderr, " -m : save mpeg4 raw stream to individual files\n");
487 : edgomez 547 fprintf(stderr, " -help : This help message\n");
488 :     fprintf(stderr, " (* means default)\n");
489 :    
490 :     }
491 :    
492 :     /*****************************************************************************
493 :     * "helper" functions
494 :     ****************************************************************************/
495 :    
496 :     /* return the current time in milli seconds */
497 :     static double
498 :     msecond()
499 :     {
500 : edgomez 824 #ifndef WIN32
501 : edgomez 547 struct timeval tv;
502 :     gettimeofday(&tv, 0);
503 : edgomez 1382 return((double)tv.tv_sec*1.0e3 + (double)tv.tv_usec*1.0e-3);
504 : edgomez 547 #else
505 :     clock_t clk;
506 :     clk = clock();
507 : suxen_drol 1646 return(clk * 1000.0 / CLOCKS_PER_SEC);
508 : edgomez 547 #endif
509 :     }
510 :    
511 :     /*****************************************************************************
512 :     * output functions
513 :     ****************************************************************************/
514 :    
515 : Isibaar 1881 static int write_image(char *prefix, unsigned char *image, int filenr)
516 : edgomez 547 {
517 : edgomez 1423 char filename[1024];
518 :     char *ext;
519 :     int ret;
520 : edgomez 547
521 : edgomez 1423 if (FORMAT == USE_PNM && BPP == 1) {
522 :     ext = "pgm";
523 :     } else if (FORMAT == USE_PNM && BPP == 3) {
524 :     ext = "pnm";
525 : Isibaar 1880 } else if (FORMAT == USE_YUV) {
526 :     ext = "yuv";
527 : edgomez 1423 } else if (FORMAT == USE_TGA) {
528 :     ext = "tga";
529 :     } else {
530 :     fprintf(stderr, "Bug: should not reach this path code -- please report to xvid-devel@xvid.org with command line options used");
531 :     exit(-1);
532 :     }
533 : edgomez 547
534 : Isibaar 1881 if (FORMAT == USE_YUV) {
535 :     sprintf(filename, "%s.%s", prefix, ext);
536 : chl 376
537 : Isibaar 1881 if (!filenr) {
538 :     FILE *fp = fopen(filename, "wb");
539 :     fclose(fp);
540 :     }
541 :     } else
542 :     sprintf(filename, "%s%05d.%s", prefix, filenr, ext);
543 :    
544 : edgomez 1423 if (FORMAT == USE_PNM) {
545 :     ret = write_pnm(filename, image);
546 : Isibaar 1880 } else if (FORMAT == USE_YUV) {
547 :     ret = write_yuv(filename, image);
548 : edgomez 1423 } else {
549 :     ret = write_tga(filename, image);
550 :     }
551 : edgomez 547
552 : edgomez 1423 return(ret);
553 :     }
554 : edgomez 547
555 : edgomez 1442 static int write_tga(char *filename, unsigned char *image)
556 : edgomez 1423 {
557 :     FILE * f;
558 :     char hdr[18];
559 : edgomez 547
560 : edgomez 1423 f = fopen(filename, "wb");
561 :     if ( f == NULL) {
562 :     return -1;
563 :     }
564 : edgomez 547
565 : edgomez 1423 hdr[0] = 0; /* ID length */
566 :     hdr[1] = 0; /* Color map type */
567 :     hdr[2] = (BPP>1)?2:3; /* Uncompressed true color (2) or greymap (3) */
568 :     hdr[3] = 0; /* Color map specification (not used) */
569 :     hdr[4] = 0; /* Color map specification (not used) */
570 :     hdr[5] = 0; /* Color map specification (not used) */
571 :     hdr[6] = 0; /* Color map specification (not used) */
572 :     hdr[7] = 0; /* Color map specification (not used) */
573 :     hdr[8] = 0; /* LSB X origin */
574 :     hdr[9] = 0; /* MSB X origin */
575 :     hdr[10] = 0; /* LSB Y origin */
576 :     hdr[11] = 0; /* MSB Y origin */
577 :     hdr[12] = (XDIM>>0)&0xff; /* LSB Width */
578 :     hdr[13] = (XDIM>>8)&0xff; /* MSB Width */
579 :     if (BPP > 1) {
580 :     hdr[14] = (YDIM>>0)&0xff; /* LSB Height */
581 :     hdr[15] = (YDIM>>8)&0xff; /* MSB Height */
582 :     } else {
583 :     hdr[14] = ((YDIM*3)>>1)&0xff; /* LSB Height */
584 :     hdr[15] = ((YDIM*3)>>9)&0xff; /* MSB Height */
585 :     }
586 :     hdr[16] = BPP*8;
587 :     hdr[17] = 0x00 | (1<<5) /* Up to down */ | (0<<4); /* Image descriptor */
588 :    
589 :     /* Write header */
590 :     fwrite(hdr, 1, sizeof(hdr), f);
591 : edgomez 547
592 : edgomez 1423 #ifdef ARCH_IS_LITTLE_ENDIAN
593 :     /* write first plane */
594 :     fwrite(image, 1, XDIM*YDIM*BPP, f);
595 :     #else
596 :     {
597 :     int i;
598 : Isibaar 1627 for (i=0; i<XDIM*YDIM*BPP;i+=BPP) {
599 : edgomez 1423 if (BPP == 1) {
600 : Isibaar 1627 fputc(*(image+i), f);
601 : edgomez 1423 } else if (BPP == 2) {
602 : Isibaar 1627 fputc(*(image+i+1), f);
603 :     fputc(*(image+i+0), f);
604 : edgomez 1423 } else if (BPP == 3) {
605 : Isibaar 1627 fputc(*(image+i+2), f);
606 :     fputc(*(image+i+1), f);
607 :     fputc(*(image+i+0), f);
608 : edgomez 1423 } else if (BPP == 4) {
609 : Isibaar 1627 fputc(*(image+i+3), f);
610 :     fputc(*(image+i+2), f);
611 :     fputc(*(image+i+1), f);
612 :     fputc(*(image+i+0), f);
613 : edgomez 1423 }
614 : edgomez 547 }
615 : edgomez 1423 }
616 :     #endif
617 : edgomez 547
618 : edgomez 1423 /* Write Y and V planes for YUV formats */
619 :     if (BPP == 1) {
620 :     int i;
621 : edgomez 547
622 : edgomez 1423 /* Write the two chrominance planes */
623 :     for (i=0; i<YDIM/2; i++) {
624 :     fwrite(image+XDIM*YDIM + i*XDIM/2, 1, XDIM/2, f);
625 :     fwrite(image+5*XDIM*YDIM/4 + i*XDIM/2, 1, XDIM/2, f);
626 :     }
627 : chl 376 }
628 : edgomez 1423
629 :    
630 :     /* Close the file */
631 :     fclose(f);
632 :    
633 :     return(0);
634 : chl 376 }
635 :    
636 : edgomez 1442 static int write_pnm(char *filename, unsigned char *image)
637 : edgomez 1423 {
638 :     FILE * f;
639 :    
640 :     f = fopen(filename, "wb");
641 :     if ( f == NULL) {
642 :     return -1;
643 :     }
644 :    
645 :     if (BPP == 1) {
646 :     int i;
647 : chl 1658 fprintf(f, "P5\n%i %i\n255\n", XDIM, YDIM*3/2);
648 : edgomez 1423
649 :     fwrite(image, 1, XDIM*YDIM, f);
650 :    
651 :     for (i=0; i<YDIM/2;i++) {
652 :     fwrite(image+XDIM*YDIM + i*XDIM/2, 1, XDIM/2, f);
653 :     fwrite(image+5*XDIM*YDIM/4 + i*XDIM/2, 1, XDIM/2, f);
654 :     }
655 :     } else if (BPP == 3) {
656 :     int i;
657 :     fprintf(f, "P6\n#xvid\n%i %i\n255\n", XDIM, YDIM);
658 :     for (i=0; i<XDIM*YDIM*3; i+=3) {
659 :     #ifdef ARCH_IS_LITTLE_ENDIAN
660 :     fputc(image[i+2], f);
661 :     fputc(image[i+1], f);
662 :     fputc(image[i+0], f);
663 :     #else
664 :     fputc(image[i+0], f);
665 :     fputc(image[i+1], f);
666 :     fputc(image[i+2], f);
667 :     #endif
668 :     }
669 :     }
670 :    
671 :     fclose(f);
672 :    
673 :     return 0;
674 :     }
675 : edgomez 1442
676 : Isibaar 1880 static int write_yuv(char *filename, unsigned char *image)
677 :     {
678 :     FILE * f;
679 :    
680 :     f = fopen(filename, "ab+");
681 :     if ( f == NULL) {
682 :     return -1;
683 :     }
684 :    
685 : Isibaar 1881 fwrite(image, 1, 3*XDIM*YDIM/2, f);
686 : Isibaar 1880
687 :     fclose(f);
688 :    
689 :     return 0;
690 :     }
691 :    
692 : edgomez 547 /*****************************************************************************
693 :     * Routines for decoding: init decoder, use, and stop decoder
694 :     ****************************************************************************/
695 : chl 376
696 : edgomez 547 /* init decoder before first run */
697 :     static int
698 : suxen_drol 1416 dec_init(int use_assembler, int debug_level)
699 : chl 376 {
700 : edgomez 1382 int ret;
701 : chl 376
702 : edgomez 1382 xvid_gbl_init_t xvid_gbl_init;
703 :     xvid_dec_create_t xvid_dec_create;
704 : chl 376
705 : edgomez 1501 /* Reset the structure with zeros */
706 :     memset(&xvid_gbl_init, 0, sizeof(xvid_gbl_init_t));
707 :     memset(&xvid_dec_create, 0, sizeof(xvid_dec_create_t));
708 :    
709 : edgomez 1382 /*------------------------------------------------------------------------
710 :     * XviD core initialization
711 :     *----------------------------------------------------------------------*/
712 :    
713 :     /* Version */
714 :     xvid_gbl_init.version = XVID_VERSION;
715 :    
716 :     /* Assembly setting */
717 :     if(use_assembler)
718 : suxen_drol 860 #ifdef ARCH_IS_IA64
719 : edgomez 1382 xvid_gbl_init.cpu_flags = XVID_CPU_FORCE | XVID_CPU_IA64;
720 : chl 376 #else
721 : edgomez 1382 xvid_gbl_init.cpu_flags = 0;
722 : chl 376 #endif
723 : edgomez 1382 else
724 :     xvid_gbl_init.cpu_flags = XVID_CPU_FORCE;
725 : chl 376
726 : suxen_drol 1416 xvid_gbl_init.debug = debug_level;
727 :    
728 : edgomez 1382 xvid_global(NULL, 0, &xvid_gbl_init, NULL);
729 : chl 376
730 : edgomez 1382 /*------------------------------------------------------------------------
731 :     * XviD encoder initialization
732 :     *----------------------------------------------------------------------*/
733 : edgomez 851
734 : edgomez 1382 /* Version */
735 :     xvid_dec_create.version = XVID_VERSION;
736 : chl 376
737 : edgomez 1382 /*
738 :     * Image dimensions -- set to 0, xvidcore will resize when ever it is
739 :     * needed
740 :     */
741 :     xvid_dec_create.width = 0;
742 :     xvid_dec_create.height = 0;
743 :    
744 :     ret = xvid_decore(NULL, XVID_DEC_CREATE, &xvid_dec_create, NULL);
745 :    
746 :     dec_handle = xvid_dec_create.handle;
747 :    
748 :     return(ret);
749 : chl 376 }
750 :    
751 : edgomez 547 /* decode one frame */
752 :     static int
753 :     dec_main(unsigned char *istream,
754 : edgomez 851 unsigned char *ostream,
755 :     int istream_size,
756 : edgomez 1382 xvid_dec_stats_t *xvid_dec_stats)
757 : edgomez 547 {
758 : chl 376
759 : edgomez 1382 int ret;
760 : chl 376
761 : edgomez 1382 xvid_dec_frame_t xvid_dec_frame;
762 : chl 376
763 : edgomez 1523 /* Reset all structures */
764 :     memset(&xvid_dec_frame, 0, sizeof(xvid_dec_frame_t));
765 :     memset(xvid_dec_stats, 0, sizeof(xvid_dec_stats_t));
766 :    
767 : edgomez 1382 /* Set version */
768 :     xvid_dec_frame.version = XVID_VERSION;
769 :     xvid_dec_stats->version = XVID_VERSION;
770 : chl 376
771 : edgomez 1382 /* No general flags to set */
772 :     xvid_dec_frame.general = 0;
773 : chl 376
774 : edgomez 1382 /* Input stream */
775 :     xvid_dec_frame.bitstream = istream;
776 :     xvid_dec_frame.length = istream_size;
777 : edgomez 851
778 : edgomez 1382 /* Output frame structure */
779 :     xvid_dec_frame.output.plane[0] = ostream;
780 : edgomez 1423 xvid_dec_frame.output.stride[0] = XDIM*BPP;
781 :     xvid_dec_frame.output.csp = CSP;
782 : edgomez 1382
783 :     ret = xvid_decore(dec_handle, XVID_DEC_DECODE, &xvid_dec_frame, xvid_dec_stats);
784 :    
785 :     return(ret);
786 : chl 376 }
787 :    
788 : edgomez 547 /* close decoder to release resources */
789 :     static int
790 :     dec_stop()
791 : chl 376 {
792 : edgomez 1382 int ret;
793 : edgomez 547
794 : edgomez 1382 ret = xvid_decore(dec_handle, XVID_DEC_DESTROY, NULL, NULL);
795 : chl 376
796 : edgomez 1382 return(ret);
797 : chl 376 }
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4