[svn] / branches / release-1_0-branch / xvidcore / examples / xvid_decraw.c Repository:
ViewVC logotype

Annotation of /branches/release-1_0-branch/xvidcore/examples/xvid_decraw.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1430 - (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 : suxen_drol 1430 * $Id: xvid_decraw.c,v 1.10.2.3 2004-04-15 10:04:55 suxen_drol 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 547 /* max number of frames */
58 :     #define ABS_MAXFRAMENR 9999
59 : chl 376
60 : edgomez 1418 #define USE_PNM 0
61 :     #define USE_TGA 1
62 :    
63 : edgomez 547 static int XDIM = 0;
64 :     static int YDIM = 0;
65 :     static int ARG_SAVEDECOUTPUT = 0;
66 :     static int ARG_SAVEMPEGSTREAM = 0;
67 :     static char *ARG_INPUTFILE = NULL;
68 : edgomez 1414 static int CSP = XVID_CSP_I420;
69 :     static int BPP = 1;
70 : edgomez 1418 static int FORMAT = USE_PNM;
71 : chl 376
72 : edgomez 547 static char filepath[256] = "./";
73 :     static void *dec_handle = NULL;
74 : chl 376
75 : edgomez 1382 #define BUFFER_SIZE (2*1024*1024)
76 : chl 376
77 : edgomez 547 /*****************************************************************************
78 :     * Local prototypes
79 :     ****************************************************************************/
80 : chl 376
81 : edgomez 547 static double msecond();
82 :     static int write_pgm(char *filename,
83 : edgomez 1382 unsigned char *image);
84 : edgomez 547 static int dec_init(int use_assembler);
85 :     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 : suxen_drol 1430 int write_image(char *prefix, unsigned char *image);
92 :     int write_pnm(char *filename, unsigned char *image);
93 :     int write_tga(char *filename, unsigned char *image);
94 : edgomez 547
95 : edgomez 1382 const char * type2str(int type)
96 :     {
97 :     if (type==XVID_TYPE_IVOP)
98 :     return "I";
99 :     if (type==XVID_TYPE_PVOP)
100 :     return "P";
101 :     if (type==XVID_TYPE_BVOP)
102 :     return "B";
103 :     return "S";
104 :     }
105 :    
106 : edgomez 547 /*****************************************************************************
107 :     * Main program
108 :     ****************************************************************************/
109 :    
110 :     int main(int argc, char *argv[])
111 : chl 376 {
112 : edgomez 547 unsigned char *mp4_buffer = NULL;
113 :     unsigned char *mp4_ptr = NULL;
114 :     unsigned char *out_buffer = NULL;
115 : edgomez 1382 int useful_bytes;
116 :     xvid_dec_stats_t xvid_dec_stats;
117 : edgomez 851
118 : edgomez 547 double totaldectime;
119 :    
120 :     long totalsize;
121 :     int status;
122 :    
123 :     int use_assembler = 0;
124 :    
125 :     char filename[256];
126 :    
127 :     FILE *in_file;
128 :     int filenr;
129 :     int i;
130 :    
131 :     printf("xvid_decraw - raw mpeg4 bitstream decoder ");
132 : edgomez 851 printf("written by Christoph Lampert 2002-2003\n\n");
133 : edgomez 547
134 :     /*****************************************************************************
135 :     * Command line parsing
136 :     ****************************************************************************/
137 :    
138 :     for (i=1; i< argc; i++) {
139 :    
140 :     if (strcmp("-asm", argv[i]) == 0 ) {
141 :     use_assembler = 1;
142 : edgomez 1382 } else if (strcmp("-d", argv[i]) == 0) {
143 :     ARG_SAVEDECOUTPUT = 1;
144 :     } else if (strcmp("-i", argv[i]) == 0 && i < argc - 1 ) {
145 : edgomez 547 i++;
146 :     ARG_INPUTFILE = argv[i];
147 : edgomez 1382 } else if (strcmp("-m", argv[i]) == 0) {
148 :     ARG_SAVEMPEGSTREAM = 1;
149 : edgomez 1414 } else if (strcmp("-c", argv[i]) == 0 && i < argc - 1 ) {
150 :     i++;
151 :     if (strcmp(argv[i], "rgb16") == 0) {
152 :     CSP = XVID_CSP_RGB555;
153 :     BPP = 2;
154 :     } else if (strcmp(argv[i], "rgb24") == 0) {
155 :     CSP = XVID_CSP_BGR;
156 :     BPP = 3;
157 :     } else if (strcmp(argv[i], "rgb32") == 0) {
158 :     CSP = XVID_CSP_BGRA;
159 :     BPP = 4;
160 :     } else if (strcmp(argv[i], "yv12") == 0) {
161 :     CSP = XVID_CSP_YV12;
162 :     BPP = 1;
163 :     } else {
164 :     CSP = XVID_CSP_I420;
165 :     BPP = 1;
166 :     }
167 : edgomez 1418 } else if (strcmp("-f", argv[i]) == 0 && i < argc -1) {
168 :     i++;
169 :     if (strcmp(argv[i], "tga") == 0) {
170 :     FORMAT = USE_TGA;
171 :     } else {
172 :     FORMAT = USE_PNM;
173 :     }
174 : edgomez 1382 } else if (strcmp("-help", argv[i]) == 0) {
175 : edgomez 547 usage();
176 :     return(0);
177 : edgomez 1382 } else {
178 : edgomez 547 usage();
179 :     exit(-1);
180 :     }
181 : chl 376 }
182 : edgomez 547
183 : suxen_drol 1430 #if defined(_MSC_VER)
184 :     if (ARG_INPUTFILE==NULL) {
185 :     fprintf(stderr, "Warning: MSVC build does not read EOF correctly from stdin. Use the -i switch.\n\n");
186 :     }
187 :     #endif
188 :    
189 : edgomez 547 /*****************************************************************************
190 :     * Values checking
191 :     ****************************************************************************/
192 :    
193 :     if ( ARG_INPUTFILE == NULL || strcmp(ARG_INPUTFILE, "stdin") == 0) {
194 :     in_file = stdin;
195 :     }
196 :     else {
197 :    
198 :     in_file = fopen(ARG_INPUTFILE, "rb");
199 :     if (in_file == NULL) {
200 :     fprintf(stderr, "Error opening input file %s\n", ARG_INPUTFILE);
201 : edgomez 1382 return(-1);
202 : edgomez 547 }
203 :     }
204 :    
205 : edgomez 1418 /* PNM/PGM format can't handle 16/32 bit data */
206 :     if (BPP != 1 && BPP != 3 && FORMAT == USE_PNM) {
207 :     FORMAT = USE_TGA;
208 :     }
209 :    
210 : edgomez 547 /*****************************************************************************
211 :     * Memory allocation
212 :     ****************************************************************************/
213 :    
214 :     /* Memory for encoded mp4 stream */
215 :     mp4_buffer = (unsigned char *) malloc(BUFFER_SIZE);
216 :     mp4_ptr = mp4_buffer;
217 :     if (!mp4_buffer)
218 :     goto free_all_memory;
219 :    
220 :     /*****************************************************************************
221 :     * XviD PART Start
222 :     ****************************************************************************/
223 :    
224 :     status = dec_init(use_assembler);
225 :     if (status) {
226 :     fprintf(stderr,
227 : edgomez 1382 "Decore INIT problem, return value %d\n", status);
228 : edgomez 547 goto release_all;
229 :     }
230 :    
231 :    
232 :     /*****************************************************************************
233 :     * Main loop
234 :     ****************************************************************************/
235 :    
236 : edgomez 851 /* Fill the buffer */
237 : edgomez 1382 useful_bytes = fread(mp4_buffer, 1, BUFFER_SIZE, in_file);
238 : edgomez 559
239 : edgomez 547 totaldectime = 0;
240 :     totalsize = 0;
241 :     filenr = 0;
242 :     mp4_ptr = mp4_buffer;
243 :    
244 :     do {
245 :     int used_bytes = 0;
246 :     double dectime;
247 :    
248 : edgomez 851 /*
249 :     * If the buffer is half empty or there are no more bytes in it
250 :     * then fill it.
251 :     */
252 : edgomez 1382 if (mp4_ptr > mp4_buffer + BUFFER_SIZE/2) {
253 :     int already_in_buffer = (mp4_buffer + BUFFER_SIZE - mp4_ptr);
254 : edgomez 547
255 : edgomez 851 /* Move data if needed */
256 : edgomez 1382 if (already_in_buffer > 0)
257 :     memcpy(mp4_buffer, mp4_ptr, already_in_buffer);
258 : edgomez 547
259 : edgomez 851 /* Update mp4_ptr */
260 :     mp4_ptr = mp4_buffer;
261 : edgomez 547
262 : edgomez 851 /* read new data */
263 : edgomez 1382 if(feof(in_file))
264 : edgomez 547 break;
265 :    
266 : edgomez 1382 useful_bytes += fread(mp4_buffer + already_in_buffer,
267 :     1, BUFFER_SIZE - already_in_buffer,
268 :     in_file);
269 : edgomez 547
270 :     }
271 :    
272 :    
273 : edgomez 1382 /* This loop is needed to handle VOL/NVOP reading */
274 : edgomez 851 do {
275 : edgomez 547
276 : edgomez 851 /* Decode frame */
277 :     dectime = msecond();
278 : edgomez 1382 used_bytes = dec_main(mp4_ptr, out_buffer, useful_bytes, &xvid_dec_stats);
279 : edgomez 851 dectime = msecond() - dectime;
280 : edgomez 547
281 : edgomez 1382 /* Resize image buffer if needed */
282 :     if(xvid_dec_stats.type == XVID_TYPE_VOL) {
283 :    
284 :     /* Check if old buffer is smaller */
285 :     if(XDIM*YDIM < xvid_dec_stats.data.vol.width*xvid_dec_stats.data.vol.height) {
286 :    
287 :     /* Copy new witdh and new height from the vol structure */
288 :     XDIM = xvid_dec_stats.data.vol.width;
289 :     YDIM = xvid_dec_stats.data.vol.height;
290 :    
291 :     /* Free old output buffer*/
292 :     if(out_buffer) free(out_buffer);
293 :    
294 :     /* Allocate the new buffer */
295 :     out_buffer = (unsigned char*)malloc(XDIM*YDIM*4);
296 :     if(out_buffer == NULL)
297 :     goto free_all_memory;
298 :    
299 :     fprintf(stderr, "Resized frame buffer to %dx%d\n", XDIM, YDIM);
300 :     }
301 : edgomez 851 }
302 : edgomez 547
303 : edgomez 851 /* Update buffer pointers */
304 : edgomez 1382 if(used_bytes > 0) {
305 :     mp4_ptr += used_bytes;
306 :     useful_bytes -= used_bytes;
307 : edgomez 559
308 : edgomez 1382 /* Total size */
309 :     totalsize += used_bytes;
310 :     }
311 : edgomez 547
312 : edgomez 1382 }while(xvid_dec_stats.type <= 0 && useful_bytes > 0);
313 : edgomez 547
314 : edgomez 1382 /* Check if there is a negative number of useful bytes left in buffer
315 :     * This means we went too far */
316 :     if(useful_bytes < 0)
317 :     break;
318 : edgomez 851
319 : edgomez 1382 /* Updated data - Count only usefull decode time */
320 : edgomez 851 totaldectime += dectime;
321 : edgomez 547
322 : edgomez 851
323 : edgomez 1382 printf("Frame %5d: type = %s, dectime(ms) =%6.1f, length(bytes) =%7d\n",
324 :     filenr, type2str(xvid_dec_stats.type), dectime, used_bytes);
325 :    
326 : edgomez 851 /* Save individual mpeg4 stream if required */
327 : edgomez 1382 if(ARG_SAVEMPEGSTREAM) {
328 : edgomez 547 FILE *filehandle = NULL;
329 :    
330 :     sprintf(filename, "%sframe%05d.m4v", filepath, filenr);
331 :     filehandle = fopen(filename, "wb");
332 :     if(!filehandle) {
333 :     fprintf(stderr,
334 : edgomez 851 "Error writing single mpeg4 stream to file %s\n",
335 :     filename);
336 : edgomez 547 }
337 :     else {
338 : edgomez 1382 fwrite(mp4_ptr-used_bytes, 1, used_bytes, filehandle);
339 : edgomez 547 fclose(filehandle);
340 :     }
341 :     }
342 : edgomez 851
343 : edgomez 547 /* Save output frame if required */
344 :     if (ARG_SAVEDECOUTPUT) {
345 : edgomez 1418 sprintf(filename, "%sdec%05d", filepath, filenr);
346 :     if(write_image(filename, out_buffer)) {
347 : edgomez 547 fprintf(stderr,
348 : edgomez 851 "Error writing decoded PGM frame %s\n",
349 :     filename);
350 : edgomez 547 }
351 :     }
352 :    
353 :     filenr++;
354 :    
355 : edgomez 851 } while ( (status>=0) && (filenr<ABS_MAXFRAMENR));
356 : edgomez 547
357 :     /*****************************************************************************
358 : edgomez 851 * Flush decoder buffers
359 :     ****************************************************************************/
360 :    
361 : edgomez 1382 do {
362 :    
363 : edgomez 851 /* Fake vars */
364 : edgomez 1382 int used_bytes;
365 : edgomez 851 double dectime;
366 :    
367 : edgomez 1382 do {
368 :     dectime = msecond();
369 :     used_bytes = dec_main(NULL, out_buffer, -1, &xvid_dec_stats);
370 :     dectime = msecond() - dectime;
371 :     }while(used_bytes>=0 && xvid_dec_stats.type <= 0);
372 : edgomez 851
373 : edgomez 1382 if (used_bytes < 0) { /* XVID_ERR_END */
374 :     break;
375 :     }
376 : edgomez 851
377 :     /* Updated data - Count only usefull decode time */
378 :     totaldectime += dectime;
379 :    
380 :     /* Prints some decoding stats */
381 : edgomez 1382 printf("Frame %5d: type = %s, dectime(ms) =%6.1f, length(bytes) =%7d\n",
382 :     filenr, type2str(xvid_dec_stats.type), dectime, used_bytes);
383 : edgomez 851
384 :     /* Save output frame if required */
385 :     if (ARG_SAVEDECOUTPUT) {
386 : edgomez 1418 sprintf(filename, "%sdec%05d", filepath, filenr);
387 :     if(write_image(filename, out_buffer)) {
388 : edgomez 851 fprintf(stderr,
389 : suxen_drol 1430 "Error writing decoded frame %s\n",
390 : edgomez 851 filename);
391 :     }
392 :     }
393 :    
394 :     filenr++;
395 :    
396 : edgomez 1382 }while(1);
397 : edgomez 851
398 :     /*****************************************************************************
399 : edgomez 547 * Calculate totals and averages for output, print results
400 :     ****************************************************************************/
401 :    
402 : suxen_drol 1430 if (filenr>0) {
403 :     totalsize /= filenr;
404 :     totaldectime /= filenr;
405 :     printf("Avg: dectime(ms) =%7.2f, fps =%7.2f, length(bytes) =%7d\n",
406 :     totaldectime, 1000/totaldectime, (int)totalsize);
407 :     }else{
408 :     printf("Nothing was decoded!\n");
409 :     }
410 : edgomez 547
411 :     /*****************************************************************************
412 :     * XviD PART Stop
413 : edgomez 559 ****************************************************************************/
414 : edgomez 547
415 :     release_all:
416 :     if (dec_handle) {
417 :     status = dec_stop();
418 :     if (status)
419 :     fprintf(stderr, "decore RELEASE problem return value %d\n", status);
420 :     }
421 :    
422 :     free_all_memory:
423 :     free(out_buffer);
424 :     free(mp4_buffer);
425 :    
426 : edgomez 1382 return(0);
427 : chl 376 }
428 :    
429 : edgomez 547 /*****************************************************************************
430 :     * Usage function
431 :     ****************************************************************************/
432 : chl 376
433 : edgomez 547 static void usage()
434 : chl 376 {
435 : edgomez 547
436 : edgomez 1382 fprintf(stderr, "Usage : xvid_decraw [OPTIONS]\n");
437 : edgomez 547 fprintf(stderr, "Options :\n");
438 :     fprintf(stderr, " -asm : use assembly optimizations (default=disabled)\n");
439 :     fprintf(stderr, " -i string : input filename (default=stdin)\n");
440 : edgomez 1382 fprintf(stderr, " -d : save decoder output\n");
441 : edgomez 1418 fprintf(stderr, " -c csp : choose colorspace output (rgb16, rgb24, rgb32, yv12, i420)\n");
442 :     fprintf(stderr, " -f format : choose output file format (tga, pnm, pgm)\n");
443 : edgomez 1382 fprintf(stderr, " -m : save mpeg4 raw stream to individual files\n");
444 : edgomez 547 fprintf(stderr, " -help : This help message\n");
445 :     fprintf(stderr, " (* means default)\n");
446 :    
447 :     }
448 :    
449 :     /*****************************************************************************
450 :     * "helper" functions
451 :     ****************************************************************************/
452 :    
453 :     /* return the current time in milli seconds */
454 :     static double
455 :     msecond()
456 :     {
457 : edgomez 824 #ifndef WIN32
458 : edgomez 547 struct timeval tv;
459 :     gettimeofday(&tv, 0);
460 : edgomez 1382 return((double)tv.tv_sec*1.0e3 + (double)tv.tv_usec*1.0e-3);
461 : edgomez 547 #else
462 :     clock_t clk;
463 :     clk = clock();
464 : edgomez 1382 return(clk * 1000 / CLOCKS_PER_SEC);
465 : edgomez 547 #endif
466 :     }
467 :    
468 :     /*****************************************************************************
469 :     * output functions
470 :     ****************************************************************************/
471 :    
472 : edgomez 1418 int write_image(char *prefix, unsigned char *image)
473 :     {
474 :     char filename[1024];
475 :     char *ext;
476 :     int ret;
477 :    
478 :     if (FORMAT == USE_PNM && BPP == 1) {
479 :     ext = "pgm";
480 :     } else if (FORMAT == USE_PNM && BPP == 3) {
481 :     ext = "pnm";
482 :     } else if (FORMAT == USE_TGA) {
483 :     ext = "tga";
484 :     } else {
485 :     fprintf(stderr, "Bug: should not reach this path code -- please report to xvid-devel@xvid.org with command line options used");
486 :     exit(-1);
487 :     }
488 :    
489 :     sprintf(filename, "%s.%s", prefix, ext);
490 :    
491 :     if (FORMAT == USE_PNM) {
492 :     ret = write_pnm(filename, image);
493 :     } else {
494 :     ret = write_tga(filename, image);
495 :     }
496 :    
497 :     return(ret);
498 :     }
499 :    
500 : edgomez 1414 int write_tga(char *filename, unsigned char *image)
501 : edgomez 547 {
502 : edgomez 1414 FILE * f;
503 :     char hdr[18];
504 : edgomez 547
505 : edgomez 1414 f = fopen(filename, "wb");
506 :     if ( f == NULL) {
507 :     return -1;
508 :     }
509 : edgomez 547
510 : edgomez 1414 hdr[0] = 0; /* ID length */
511 :     hdr[1] = 0; /* Color map type */
512 :     hdr[2] = (BPP>1)?2:3; /* Uncompressed true color (2) or greymap (3) */
513 :     hdr[3] = 0; /* Color map specification (not used) */
514 :     hdr[4] = 0; /* Color map specification (not used) */
515 :     hdr[5] = 0; /* Color map specification (not used) */
516 :     hdr[6] = 0; /* Color map specification (not used) */
517 :     hdr[7] = 0; /* Color map specification (not used) */
518 :     hdr[8] = 0; /* LSB X origin */
519 :     hdr[9] = 0; /* MSB X origin */
520 :     hdr[10] = 0; /* LSB Y origin */
521 :     hdr[11] = 0; /* MSB Y origin */
522 :     hdr[12] = (XDIM>>0)&0xff; /* LSB Width */
523 :     hdr[13] = (XDIM>>8)&0xff; /* MSB Width */
524 :     if (BPP > 1) {
525 :     hdr[14] = (YDIM>>0)&0xff; /* LSB Height */
526 :     hdr[15] = (YDIM>>8)&0xff; /* MSB Height */
527 :     } else {
528 :     hdr[14] = ((YDIM*3)>>1)&0xff; /* LSB Height */
529 :     hdr[15] = ((YDIM*3)>>9)&0xff; /* MSB Height */
530 :     }
531 :     hdr[16] = BPP*8;
532 :     hdr[17] = 0x00 | (1<<5) /* Up to down */ | (0<<4); /* Image descriptor */
533 :    
534 :     /* Write header */
535 :     fwrite(hdr, 1, sizeof(hdr), f);
536 : chl 376
537 : edgomez 1414 #ifdef ARCH_IS_LITTLE_ENDIAN
538 :     /* write first plane */
539 :     fwrite(image, 1, XDIM*YDIM*BPP, f);
540 :     #else
541 :     {
542 :     int i;
543 :     for (i=0; i<width*height*BPP;i+=BPP) {
544 :     if (BPP == 1) {
545 :     fputc(image+i, f);
546 :     } else if (BPP == 2) {
547 :     fputc(image+i+1, f);
548 :     fputc(image+i+0, f);
549 :     } else if (BPP == 3) {
550 :     fputc(image+i+2, f);
551 :     fputc(image+i+1, f);
552 :     fputc(image+i+0, f);
553 :     } else if (BPP == 4) {
554 :     fputc(image+i+3, f);
555 :     fputc(image+i+2, f);
556 :     fputc(image+i+1, f);
557 :     fputc(image+i+0, f);
558 :     }
559 :     }
560 :     }
561 :     #endif
562 : edgomez 547
563 : edgomez 1414 /* Write Y and V planes for YUV formats */
564 :     if (BPP == 1) {
565 :     int i;
566 : edgomez 547
567 : edgomez 1414 /* Write the two chrominance planes */
568 :     for (i=0; i<YDIM/2; i++) {
569 : edgomez 1418 fwrite(image+XDIM*YDIM + i*XDIM/2, 1, XDIM/2, f);
570 :     fwrite(image+5*XDIM*YDIM/4 + i*XDIM/2, 1, XDIM/2, f);
571 : edgomez 1414 }
572 :     }
573 : edgomez 547
574 :    
575 : edgomez 1414 /* Close the file */
576 :     fclose(f);
577 : edgomez 547
578 : edgomez 1414 return(0);
579 : chl 376 }
580 :    
581 : edgomez 1418 int write_pnm(char *filename, unsigned char *image)
582 :     {
583 :     FILE * f;
584 :    
585 :     f = fopen(filename, "wb");
586 :     if ( f == NULL) {
587 :     return -1;
588 :     }
589 :    
590 :     if (BPP == 1) {
591 :     int i;
592 :     fprintf(f, "P5\n#xvid\n%i %i\n255\n", XDIM, YDIM*3/2);
593 :    
594 :     fwrite(image, 1, XDIM*YDIM, f);
595 :    
596 :     for (i=0; i<YDIM/2;i++) {
597 :     fwrite(image+XDIM*YDIM + i*XDIM/2, 1, XDIM/2, f);
598 :     fwrite(image+5*XDIM*YDIM/4 + i*XDIM/2, 1, XDIM/2, f);
599 :     }
600 :     } else if (BPP == 3) {
601 :     int i;
602 :     fprintf(f, "P6\n#xvid\n%i %i\n255\n", XDIM, YDIM);
603 :     for (i=0; i<XDIM*YDIM*3; i+=3) {
604 :     #ifdef ARCH_IS_LITTLE_ENDIAN
605 :     fputc(image[i+2], f);
606 :     fputc(image[i+1], f);
607 :     fputc(image[i+0], f);
608 :     #else
609 :     fputc(image[i+0], f);
610 :     fputc(image[i+1], f);
611 :     fputc(image[i+2], f);
612 :     #endif
613 :     }
614 :     }
615 :    
616 :     fclose(f);
617 :    
618 :     return 0;
619 :     }
620 : edgomez 547 /*****************************************************************************
621 :     * Routines for decoding: init decoder, use, and stop decoder
622 :     ****************************************************************************/
623 : chl 376
624 : edgomez 547 /* init decoder before first run */
625 :     static int
626 :     dec_init(int use_assembler)
627 : chl 376 {
628 : edgomez 1382 int ret;
629 : chl 376
630 : edgomez 1382 xvid_gbl_init_t xvid_gbl_init;
631 :     xvid_dec_create_t xvid_dec_create;
632 : chl 376
633 : edgomez 1382 /*------------------------------------------------------------------------
634 :     * XviD core initialization
635 :     *----------------------------------------------------------------------*/
636 :    
637 :     /* Version */
638 :     xvid_gbl_init.version = XVID_VERSION;
639 :    
640 :     /* Assembly setting */
641 :     if(use_assembler)
642 : suxen_drol 860 #ifdef ARCH_IS_IA64
643 : edgomez 1382 xvid_gbl_init.cpu_flags = XVID_CPU_FORCE | XVID_CPU_IA64;
644 : chl 376 #else
645 : edgomez 1382 xvid_gbl_init.cpu_flags = 0;
646 : chl 376 #endif
647 : edgomez 1382 else
648 :     xvid_gbl_init.cpu_flags = XVID_CPU_FORCE;
649 : chl 376
650 : edgomez 1382 xvid_global(NULL, 0, &xvid_gbl_init, NULL);
651 : chl 376
652 : edgomez 1382 /*------------------------------------------------------------------------
653 :     * XviD encoder initialization
654 :     *----------------------------------------------------------------------*/
655 : edgomez 851
656 : edgomez 1382 /* Version */
657 :     xvid_dec_create.version = XVID_VERSION;
658 : chl 376
659 : edgomez 1382 /*
660 :     * Image dimensions -- set to 0, xvidcore will resize when ever it is
661 :     * needed
662 :     */
663 :     xvid_dec_create.width = 0;
664 :     xvid_dec_create.height = 0;
665 :    
666 :     ret = xvid_decore(NULL, XVID_DEC_CREATE, &xvid_dec_create, NULL);
667 :    
668 :     dec_handle = xvid_dec_create.handle;
669 :    
670 :     return(ret);
671 : chl 376 }
672 :    
673 : edgomez 547 /* decode one frame */
674 :     static int
675 :     dec_main(unsigned char *istream,
676 : edgomez 851 unsigned char *ostream,
677 :     int istream_size,
678 : edgomez 1382 xvid_dec_stats_t *xvid_dec_stats)
679 : edgomez 547 {
680 : chl 376
681 : edgomez 1382 int ret;
682 : chl 376
683 : edgomez 1382 xvid_dec_frame_t xvid_dec_frame;
684 : chl 376
685 : edgomez 1382 /* Set version */
686 :     xvid_dec_frame.version = XVID_VERSION;
687 :     xvid_dec_stats->version = XVID_VERSION;
688 : chl 376
689 : edgomez 1382 /* No general flags to set */
690 :     xvid_dec_frame.general = 0;
691 : chl 376
692 : edgomez 1382 /* Input stream */
693 :     xvid_dec_frame.bitstream = istream;
694 :     xvid_dec_frame.length = istream_size;
695 : edgomez 851
696 : edgomez 1382 /* Output frame structure */
697 :     xvid_dec_frame.output.plane[0] = ostream;
698 : edgomez 1414 xvid_dec_frame.output.stride[0] = XDIM*BPP;
699 :     xvid_dec_frame.output.csp = CSP;
700 : edgomez 1382
701 :     ret = xvid_decore(dec_handle, XVID_DEC_DECODE, &xvid_dec_frame, xvid_dec_stats);
702 :    
703 :     return(ret);
704 : chl 376 }
705 :    
706 : edgomez 547 /* close decoder to release resources */
707 :     static int
708 :     dec_stop()
709 : chl 376 {
710 : edgomez 1382 int ret;
711 : edgomez 547
712 : edgomez 1382 ret = xvid_decore(dec_handle, XVID_DEC_DESTROY, NULL, NULL);
713 : chl 376
714 : edgomez 1382 return(ret);
715 : chl 376 }

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4