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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 558 - (view) (download)

1 : edgomez 558 /*****************************************************************************
2 : chl 376 *
3 : edgomez 558 * XVID MPEG-4 VIDEO CODEC
4 :     * - Console based test application -
5 : chl 376 *
6 : edgomez 558 * Copyright(C) 2002 Christoph Lampert
7 : chl 376 *
8 : edgomez 558 * This program is free software; you can redistribute it and/or modify
9 :     * it under the terms of the GNU General Public License as published by
10 :     * the Free Software Foundation; either version 2 of the License, or
11 :     * (at your option) any later version.
12 : chl 376 *
13 : edgomez 558 * This program is distributed in the hope that it will be useful,
14 :     * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 :     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 :     * GNU General Public License for more details.
17 : chl 376 *
18 : edgomez 558 * You should have received a copy of the GNU General Public License
19 :     * along with this program; if not, write to the Free Software
20 :     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 :     *
22 :     * $Id: xvid_encraw.c,v 1.2 2002-09-28 14:26:53 edgomez Exp $
23 :     *
24 :     ****************************************************************************/
25 : chl 376
26 : edgomez 558 /*****************************************************************************
27 :     * Application notes :
28 : chl 376 *
29 : edgomez 558 * A sequence of YUV pics in PGM file format is encoded and decoded
30 :     * The speed is measured and PSNR of decoded picture is calculated.
31 : chl 376 *
32 :     * The program is plain C and needs no libraries except for libxvidcore,
33 : edgomez 558 * and maths-lib.
34 : chl 376 *
35 :     ************************************************************************/
36 :    
37 :     #include <stdio.h>
38 :     #include <stdlib.h>
39 : edgomez 558 #include <math.h>
40 :     #ifndef _MSC_VER
41 :     #include <sys/time.h>
42 :     #else
43 :     #include <time.h>
44 :     #endif
45 : chl 376
46 : edgomez 558 #include "xvid.h"
47 : chl 376
48 : edgomez 558 /*****************************************************************************
49 :     * Quality presets
50 :     ****************************************************************************/
51 : chl 376
52 : edgomez 558 static int const motion_presets[7] = {
53 :     0, // Q 0
54 :     PMV_EARLYSTOP16, // Q 1
55 :     PMV_EARLYSTOP16, // Q 2
56 :     PMV_EARLYSTOP16 | PMV_HALFPELREFINE16, // Q 3
57 :     PMV_EARLYSTOP16 | PMV_HALFPELREFINE16, // Q 4
58 :     PMV_EARLYSTOP16 | PMV_HALFPELREFINE16 | PMV_EARLYSTOP8 | // Q 5
59 :     PMV_HALFPELREFINE8,
60 :     PMV_EARLYSTOP16 | PMV_HALFPELREFINE16 | PMV_EXTSEARCH16 | // Q 6
61 :     PMV_USESQUARES16 | PMV_EARLYSTOP8 | PMV_HALFPELREFINE8
62 :     };
63 :    
64 :     static int const general_presets[7] = {
65 :     XVID_H263QUANT, // Q 0
66 :     XVID_MPEGQUANT, // Q 1
67 :     XVID_H263QUANT, // Q 2
68 :     XVID_H263QUANT | XVID_HALFPEL, // Q 3
69 :     XVID_H263QUANT | XVID_HALFPEL | XVID_INTER4V, // Q 4
70 :     XVID_H263QUANT | XVID_HALFPEL | XVID_INTER4V, // Q 5
71 :     XVID_H263QUANT | XVID_HALFPEL | XVID_INTER4V // Q 6
72 :     };
73 : chl 376
74 :    
75 : edgomez 558 /*****************************************************************************
76 :     * Command line global variables
77 :     ****************************************************************************/
78 : chl 376
79 : edgomez 558 /* Maximum number of frames to encode */
80 :     #define ABS_MAXFRAMENR 9999
81 : chl 376
82 : edgomez 558 static int ARG_BITRATE = 900;
83 :     static int ARG_QUANTI = 0;
84 :     static int ARG_QUALITY = 6;
85 :     static int ARG_MINQUANT = 1;
86 :     static int ARG_MAXQUANT = 31;
87 :     static float ARG_FRAMERATE = 25.00f;
88 :     static int ARG_MAXFRAMENR = ABS_MAXFRAMENR;
89 :     static char *ARG_INPUTFILE = NULL;
90 :     static int ARG_INPUTTYPE = 0;
91 :     static int ARG_SAVEMPEGSTREAM = 0;
92 :     static int ARG_OUTPUTTYPE = 0;
93 :     static char *ARG_OUTPUTFILE = NULL;
94 :     static int XDIM = 0;
95 :     static int YDIM = 0;
96 :     #define IMAGE_SIZE(x,y) ((x)*(y)*3/2)
97 : chl 376
98 : edgomez 558 #define MAX(A,B) ( ((A)>(B)) ? (A) : (B) )
99 :     #define SMALL_EPS 1e-10
100 : chl 376
101 : edgomez 558 #define LONG_PACK(a,b,c,d) ((long) (((long)(a))<<24) | (((long)(b))<<16) | \
102 :     (((long)(c))<<8) |((long)(d)))
103 : chl 376
104 : edgomez 558 #define SWAP(a) ( (((a)&0x000000ff)<<24) | (((a)&0x0000ff00)<<8) | \
105 :     (((a)&0x00ff0000)>>8) | (((a)&0xff000000)>>24) )
106 : chl 376
107 : edgomez 558 /****************************************************************************
108 :     * Nasty global vars ;-)
109 :     ***************************************************************************/
110 : chl 376
111 : edgomez 558 static int i,filenr = 0;
112 : chl 376
113 : edgomez 558 /* the path where to save output */
114 :     static char filepath[256] = "./";
115 : chl 376
116 : edgomez 558 /* Internal structures (handles) for encoding and decoding */
117 :     static void *enc_handle = NULL;
118 :    
119 :     /*****************************************************************************
120 :     * Local prototypes
121 :     ****************************************************************************/
122 :    
123 :     /* Prints program usage message */
124 :     static void usage();
125 :    
126 :     /* Statistical functions */
127 :     static double msecond();
128 :    
129 :     /* PGM related functions */
130 :     static int read_pgmheader(FILE* handle);
131 :     static int read_pgmdata(FILE* handle, unsigned char *image);
132 :     static int read_yuvdata(FILE* handle, unsigned char *image);
133 :    
134 :     /* Encoder related functions */
135 :     static int enc_init(int use_assembler);
136 :     static int enc_stop();
137 :     static int enc_main(unsigned char* image, unsigned char* bitstream,
138 :     int *streamlength, int* frametype);
139 :    
140 :     /*****************************************************************************
141 :     * Main function
142 :     ****************************************************************************/
143 :    
144 :     int main(int argc, char *argv[])
145 :     {
146 :    
147 :     unsigned char *mp4_buffer = NULL;
148 :     unsigned char *in_buffer = NULL;
149 :     unsigned char *out_buffer = NULL;
150 :    
151 :     double enctime;
152 :     double totalenctime=0.;
153 :    
154 :     long totalsize;
155 :     int status;
156 :     int frame_type;
157 :     int bigendian;
158 :    
159 :     int m4v_size;
160 :     int use_assembler=0;
161 :    
162 :     char filename[256];
163 :    
164 :     FILE *in_file = stdin;
165 :     FILE *out_file = NULL;
166 :    
167 :     printf("xvid_decraw - raw mpeg4 bitstream encoder ");
168 :     printf("written by Christoph Lampert 2002\n\n");
169 :    
170 :     /*****************************************************************************
171 :     * Command line parsing
172 :     ****************************************************************************/
173 :    
174 :     for (i=1; i< argc; i++) {
175 :    
176 :     if (strcmp("-asm", argv[i]) == 0 ) {
177 :     use_assembler = 1;
178 :     }
179 :     else if (strcmp("-w", argv[i]) == 0 && i < argc - 1 ) {
180 :     i++;
181 :     XDIM = atoi(argv[i]);
182 :     }
183 :     else if (strcmp("-h", argv[i]) == 0 && i < argc - 1 ) {
184 :     i++;
185 :     YDIM = atoi(argv[i]);
186 :     }
187 :     else if (strcmp("-b", argv[i]) == 0 && i < argc - 1 ) {
188 :     i++;
189 :     ARG_BITRATE = atoi(argv[i]);
190 :     }
191 :     else if (strcmp("-q", argv[i]) == 0 && i < argc - 1 ) {
192 :     i++;
193 :     ARG_QUALITY = atoi(argv[i]);
194 :     }
195 :     else if (strcmp("-f", argv[i]) == 0 && i < argc - 1 ) {
196 :     i++;
197 :     ARG_FRAMERATE = (float)atof(argv[i]);
198 :     }
199 :     else if (strcmp("-i", argv[i]) == 0 && i < argc - 1 ) {
200 :     i++;
201 :     ARG_INPUTFILE = argv[i];
202 :     }
203 :     else if (strcmp("-t", argv[i]) == 0 && i < argc - 1 ) {
204 :     i++;
205 :     ARG_INPUTTYPE = atoi(argv[i]);
206 :     }
207 :     else if(strcmp("-n", argv[i]) == 0 && i < argc - 1 ) {
208 :     i++;
209 :     ARG_MAXFRAMENR = atoi(argv[i]);
210 :     }
211 :     else if (strcmp("-quant", argv[i]) == 0 && i < argc - 1 ) {
212 :     i++;
213 :     ARG_QUANTI = atoi(argv[i]);
214 :     }
215 :     else if (strcmp("-m", argv[i]) == 0 && i < argc - 1 ) {
216 :     i++;
217 :     ARG_SAVEMPEGSTREAM = atoi(argv[i]);
218 :     }
219 :     else if (strcmp("-mt", argv[i]) == 0 && i < argc - 1 ) {
220 :     i++;
221 :     ARG_OUTPUTTYPE = atoi(argv[i]);
222 :     }
223 :     else if (strcmp("-o", argv[i]) == 0 && i < argc - 1 ) {
224 :     i++;
225 :     ARG_OUTPUTFILE = argv[i];
226 :     }
227 :     else if (strcmp("-help", argv[i])) {
228 :     usage();
229 :     return(0);
230 :     }
231 :     else {
232 :     usage();
233 :     exit(-1);
234 :     }
235 :    
236 :     }
237 :    
238 :     /*****************************************************************************
239 :     * Arguments checking
240 :     ****************************************************************************/
241 :    
242 :     if (XDIM <= 0 || XDIM >= 2048 || YDIM <=0 || YDIM >= 2048 ) {
243 :     fprintf(stderr, "Trying to retreive width and height from PGM header\n");
244 :     ARG_INPUTTYPE = 1; /* pgm */
245 :     }
246 :    
247 :     if ( ARG_QUALITY < 0 || ARG_QUALITY > 6) {
248 :     fprintf(stderr,"Wrong Quality\n");
249 :     return -1;
250 :     }
251 :    
252 :     if ( ARG_BITRATE <= 0 && ARG_QUANTI == 0) {
253 :     fprintf(stderr,"Wrong Bitrate\n");
254 :     return -1;
255 :     }
256 :    
257 :     if ( ARG_FRAMERATE <= 0) {
258 :     fprintf(stderr,"Wrong Framerate %s \n",argv[5]);
259 :     return -1;
260 :     }
261 :    
262 :     if ( ARG_MAXFRAMENR <= 0) {
263 :     fprintf(stderr,"Wrong number of frames\n");
264 :     return -1;
265 :     }
266 :    
267 :     if ( ARG_INPUTFILE == NULL || strcmp(ARG_INPUTFILE, "stdin") == 0) {
268 :     in_file = stdin;
269 :     }
270 :     else {
271 :    
272 :     in_file = fopen(ARG_INPUTFILE, "rb");
273 :     if (in_file == NULL) {
274 :     fprintf(stderr, "Error opening input file %s\n", ARG_INPUTFILE);
275 :     return -1;
276 :     }
277 :     }
278 :    
279 :     if (ARG_INPUTTYPE) {
280 :     if (read_pgmheader(in_file)) {
281 :     fprintf(stderr, "Wrong input format, I want YUV encapsulated in PGM\n");
282 :     return -1;
283 :     }
284 :     }
285 :    
286 :     /* now we know the sizes, so allocate memory */
287 :    
288 :     in_buffer = (unsigned char *) malloc(IMAGE_SIZE(XDIM,YDIM));
289 :     if (!in_buffer)
290 :     goto free_all_memory;
291 :    
292 :     /* this should really be enough memory ! */
293 :     mp4_buffer = (unsigned char *) malloc(IMAGE_SIZE(XDIM,YDIM)*2);
294 :     if (!mp4_buffer)
295 :     goto free_all_memory;
296 :    
297 :     /*****************************************************************************
298 :     * XviD PART Start
299 :     ****************************************************************************/
300 :    
301 :    
302 :     status = enc_init(use_assembler);
303 :     if (status)
304 :     {
305 :     fprintf(stderr, "Encore INIT problem, return value %d\n", status);
306 :     goto release_all;
307 :     }
308 :    
309 :     /*****************************************************************************
310 :     * Main loop
311 :     ****************************************************************************/
312 :    
313 :     if (ARG_SAVEMPEGSTREAM && (ARG_OUTPUTTYPE || ARG_OUTPUTFILE)) {
314 :    
315 :     if (ARG_OUTPUTFILE == NULL && ARG_OUTPUTTYPE)
316 :     ARG_OUTPUTFILE = "stream.mp4u";
317 :     else if(ARG_OUTPUTFILE == NULL && !ARG_OUTPUTTYPE)
318 :     ARG_OUTPUTFILE = "stream.m4v";
319 :    
320 :     if((out_file = fopen(ARG_OUTPUTFILE, "w+b")) == NULL) {
321 :     fprintf(stderr, "Error opening output file %s\n", ARG_OUTPUTFILE);
322 :     goto release_all;
323 :     }
324 :    
325 :     /* Write header */
326 :     if (ARG_OUTPUTTYPE) {
327 :     char *ptr;
328 :     long test;
329 :    
330 :     test = LONG_PACK('M','P','4','U');
331 :     ptr = (unsigned char *)&test;
332 :     if(*ptr == 'M')
333 :     bigendian = 1;
334 :     else
335 :     bigendian = 0;
336 :    
337 :     test = (!bigendian)?SWAP(test):test;
338 :    
339 :     fwrite(&test, sizeof(test), 1, out_file);
340 :    
341 :     }
342 :    
343 :     }
344 :     else {
345 :     out_file = NULL;
346 :     }
347 :    
348 :     /*****************************************************************************
349 :     * Encoding loop
350 :     ****************************************************************************/
351 :    
352 :     totalsize = 0;
353 :    
354 :     do {
355 :    
356 :     if (ARG_INPUTTYPE)
357 :     status = read_pgmdata(in_file, in_buffer); // read PGM data (YUV-format)
358 :     else
359 :     status = read_yuvdata(in_file, in_buffer); // read raw data (YUV-format)
360 :    
361 :     if (status)
362 :     {
363 :     /* Couldn't read image, most likely end-of-file */
364 :     continue;
365 :     }
366 :    
367 :     /*****************************************************************************
368 :     * Encode and decode this frame
369 :     ****************************************************************************/
370 :    
371 :     enctime = msecond();
372 :     status = enc_main(in_buffer, mp4_buffer, &m4v_size, &frame_type);
373 :     enctime = msecond() - enctime;
374 :    
375 :     totalenctime += enctime;
376 :     totalsize += m4v_size;
377 :    
378 :     printf("Frame %5d: intra %1d, enctime=%6.1f ms, size=%6dbytes\n",
379 :     (int)filenr, (int)frame_type, (float)enctime, (int)m4v_size);
380 :    
381 :     if (ARG_SAVEMPEGSTREAM)
382 :     {
383 :     /* Save single files */
384 :     if (out_file == NULL) {
385 :     sprintf(filename, "%sframe%05d.m4v", filepath, filenr);
386 :     out_file = fopen(filename, "wb");
387 :     fwrite(mp4_buffer, m4v_size, 1, out_file);
388 :     fclose(out_file);
389 :     out_file = NULL;
390 :     }
391 :     else {
392 :     /* Using mp4u container */
393 :     if (ARG_OUTPUTTYPE) {
394 :     long size = m4v_size;
395 :     size = (!bigendian)?SWAP(size):size;
396 :     fwrite(&size, sizeof(size), 1, out_file);
397 :     }
398 :    
399 :     /* Write mp4 data */
400 :     fwrite(mp4_buffer, m4v_size, 1, out_file);
401 :    
402 :     }
403 :     }
404 :    
405 :     /* Read the header if it's pgm stream */
406 :     if (ARG_INPUTTYPE)
407 :     status = read_pgmheader(in_file);
408 :    
409 :     filenr++;
410 :    
411 :     } while ( (!status) && (filenr<ARG_MAXFRAMENR) );
412 :    
413 : chl 376
414 : edgomez 558
415 :     /*****************************************************************************
416 :     * Calculate totals and averages for output, print results
417 :     ****************************************************************************/
418 : chl 376
419 : edgomez 558 totalsize /= filenr;
420 :     totalenctime /= filenr;
421 : chl 376
422 : edgomez 558 printf("Avg: enctime %5.2f ms, %5.2f fps, filesize %7d bytes\n",
423 :     totalenctime, 1000/totalenctime, (int)totalsize);
424 : chl 376
425 : edgomez 558 /*****************************************************************************
426 :     * XviD PART Stop
427 :     ****************************************************************************/
428 : chl 376
429 : edgomez 558 release_all:
430 : chl 376
431 : edgomez 558 if (enc_handle)
432 :     {
433 :     status = enc_stop();
434 :     if (status)
435 :     fprintf(stderr, "Encore RELEASE problem return value %d\n", status);
436 :     }
437 : chl 376
438 : edgomez 558 fclose(in_file);
439 :     if(out_file)
440 :     fclose(out_file);
441 :    
442 :     free_all_memory:
443 :     free(out_buffer);
444 :     free(mp4_buffer);
445 :     free(in_buffer);
446 :    
447 :     return 0;
448 :    
449 :     }
450 :    
451 :    
452 :     /*****************************************************************************
453 :     * "statistical" functions
454 :     *
455 :     * these are not needed for encoding or decoding, but for measuring
456 :     * time and quality, there in nothing specific to XviD in these
457 :     *
458 :     *****************************************************************************/
459 :    
460 :     /* Return time elapsed time in miliseconds since the program started */
461 :     static double msecond()
462 : chl 376 {
463 : edgomez 558 #ifndef _MSC_VER
464 : chl 376 struct timeval tv;
465 :     gettimeofday(&tv, 0);
466 : edgomez 558 return tv.tv_sec*1.0e3 + tv.tv_usec * 1.0e-3;
467 :     #else
468 :     clock_t clk;
469 :     clk = clock();
470 :     return clk * 1000 / CLOCKS_PER_SEC;
471 :     #endif
472 : chl 376 }
473 :    
474 : edgomez 558 /*****************************************************************************
475 :     * Usage message
476 :     *****************************************************************************/
477 : chl 376
478 : edgomez 558 static void usage()
479 :     {
480 :    
481 :     fprintf(stderr, "Usage : xvid_stat [OPTIONS]\n");
482 :     fprintf(stderr, "Options :\n");
483 :     fprintf(stderr, " -w integer : frame width ([1.2048])\n");
484 :     fprintf(stderr, " -h integer : frame height ([1.2048])\n");
485 :     fprintf(stderr, " -b integer : target bitrate (>0 | default=900kbit)\n");
486 :     fprintf(stderr, " -f float : target framerate (>0)\n");
487 :     fprintf(stderr, " -i string : input filename (default=stdin)\n");
488 :     fprintf(stderr, " -t integer : input data type (yuv=0, pgm=1)\n");
489 :     fprintf(stderr, " -n integer : number of frames to encode\n");
490 :     fprintf(stderr, " -q integer : quality ([0..5])\n");
491 :     fprintf(stderr, " -d boolean : save decoder output (0 False*, !=0 True)\n");
492 :     fprintf(stderr, " -m boolean : save mpeg4 raw stream (0 False*, !=0 True)\n");
493 :     fprintf(stderr, " -o string : output container filename (only usefull when -m 1 is used) :\n");
494 :     fprintf(stderr, " When this option is not used : one file per encoded frame\n");
495 :     fprintf(stderr, " When this option is used :\n");
496 :     fprintf(stderr, " + stream.m4v with -mt 0\n");
497 :     fprintf(stderr, " + stream.mp4u with -mt 1\n");
498 :     fprintf(stderr, " -mt integer : output type (m4v=0, mp4u=1)\n");
499 :     fprintf(stderr, " -help : prints this help message\n");
500 :     fprintf(stderr, " -quant integer : fixed quantizer (disables -b setting)\n");
501 :     fprintf(stderr, " (* means default)\n");
502 :    
503 :     }
504 :    
505 :     /*****************************************************************************
506 :     * Input and output functions
507 :     *
508 :     * the are small and simple routines to read and write PGM and YUV
509 :     * image. It's just for convenience, again nothing specific to XviD
510 :     *
511 :     *****************************************************************************/
512 :    
513 :     static int read_pgmheader(FILE* handle)
514 : chl 376 {
515 :     int bytes,xsize,ysize,depth;
516 :     char dummy[2];
517 :    
518 :     bytes = fread(dummy,1,2,handle);
519 :    
520 :     if ( (bytes < 2) || (dummy[0] != 'P') || (dummy[1] != '5' ))
521 :     return 1;
522 : edgomez 558
523 : chl 376 fscanf(handle,"%d %d %d",&xsize,&ysize,&depth);
524 :     if ( (xsize > 1440) || (ysize > 2880 ) || (depth != 255) )
525 :     {
526 : edgomez 558 fprintf(stderr,"%d %d %d\n",xsize,ysize,depth);
527 : chl 376 return 2;
528 :     }
529 :     if ( (XDIM==0) || (YDIM==0) )
530 : edgomez 558 {
531 :     XDIM=xsize;
532 :     YDIM=ysize*2/3;
533 : chl 376 }
534 :    
535 :     return 0;
536 :     }
537 :    
538 : edgomez 558 static int read_pgmdata(FILE* handle, unsigned char *image)
539 : chl 376 {
540 : edgomez 558 int i;
541 : chl 376 char dummy;
542 : edgomez 558
543 :     unsigned char *y = image;
544 :     unsigned char *u = image + XDIM*YDIM;
545 :     unsigned char *v = image + XDIM*YDIM + XDIM/2*YDIM/2;
546 : chl 376
547 : edgomez 558 /* read Y component of picture */
548 :     fread(y, 1, XDIM*YDIM, handle);
549 : chl 376
550 : edgomez 558 for (i=0;i<YDIM/2;i++)
551 : chl 376 {
552 : edgomez 558 /* read U */
553 :     fread(u, 1, XDIM/2, handle);
554 :    
555 :     /* read V */
556 :     fread(v, 1, XDIM/2, handle);
557 :    
558 :     /* Update pointers */
559 :     u += XDIM/2;
560 :     v += XDIM/2;
561 : chl 376 }
562 : edgomez 558
563 :     /* I don't know why, but this seems needed */
564 :     fread(&dummy, 1, 1, handle);
565 :    
566 : chl 376 return 0;
567 :     }
568 :    
569 : edgomez 558 static int read_yuvdata(FILE* handle, unsigned char *image)
570 :     {
571 : chl 376
572 : edgomez 558 if (fread(image, 1, IMAGE_SIZE(XDIM, YDIM), handle) != (unsigned int)IMAGE_SIZE(XDIM, YDIM))
573 : chl 376 return 1;
574 :     else
575 :     return 0;
576 :     }
577 :    
578 : edgomez 558 /*****************************************************************************
579 :     * Routines for encoding: init encoder, frame step, release encoder
580 :     ****************************************************************************/
581 : chl 376
582 :     #define FRAMERATE_INCR 1001
583 :    
584 : edgomez 558 /* Initialize encoder for first use, pass all needed parameters to the codec */
585 :     static int enc_init(int use_assembler)
586 :     {
587 : chl 376 int xerr;
588 :    
589 :     XVID_INIT_PARAM xinit;
590 :     XVID_ENC_PARAM xparam;
591 :    
592 : edgomez 558 if(use_assembler) {
593 : chl 376
594 :     #ifdef ARCH_IA64
595 :     xinit.cpu_flags = XVID_CPU_FORCE | XVID_CPU_IA64;
596 :     #else
597 :     xinit.cpu_flags = 0;
598 :     #endif
599 : edgomez 558 }
600 :     else {
601 : chl 376 xinit.cpu_flags = XVID_CPU_FORCE;
602 : edgomez 558 }
603 : chl 376
604 :     xvid_init(NULL, 0, &xinit, NULL);
605 :    
606 :     xparam.width = XDIM;
607 :     xparam.height = YDIM;
608 :     if ((ARG_FRAMERATE - (int)ARG_FRAMERATE) < SMALL_EPS)
609 :     {
610 : edgomez 558 xparam.fincr = 1;
611 :     xparam.fbase = (int)ARG_FRAMERATE;
612 : chl 376 }
613 :     else
614 :     {
615 : edgomez 558 xparam.fincr = FRAMERATE_INCR;
616 :     xparam.fbase = (int)(FRAMERATE_INCR * ARG_FRAMERATE);
617 : chl 376 }
618 :     xparam.rc_reaction_delay_factor = 16;
619 : edgomez 558 xparam.rc_averaging_period = 100;
620 :     xparam.rc_buffer = 10;
621 : chl 376 xparam.rc_bitrate = ARG_BITRATE*1000;
622 : edgomez 558 xparam.min_quantizer = ARG_MINQUANT;
623 :     xparam.max_quantizer = ARG_MAXQUANT;
624 : chl 376 xparam.max_key_interval = (int)ARG_FRAMERATE*10;
625 :    
626 : edgomez 558 /* I use a small value here, since will not encode whole movies, but short clips */
627 : chl 376
628 :     xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xparam, NULL);
629 :     enc_handle=xparam.handle;
630 :    
631 :     return xerr;
632 :     }
633 :    
634 : edgomez 558 static int enc_stop()
635 :     {
636 :     int xerr;
637 : chl 376
638 :     xerr = xvid_encore(enc_handle, XVID_ENC_DESTROY, NULL, NULL);
639 : edgomez 558 return xerr;
640 :    
641 : chl 376 }
642 :    
643 : edgomez 558 static int enc_main(unsigned char* image, unsigned char* bitstream,
644 :     int *streamlength, int* frametype)
645 :     {
646 :     int xerr;
647 : chl 376
648 :     XVID_ENC_FRAME xframe;
649 :     XVID_ENC_STATS xstats;
650 :    
651 :     xframe.bitstream = bitstream;
652 :     xframe.length = -1; // this is written by the routine
653 :    
654 :     xframe.image = image;
655 : edgomez 558 xframe.colorspace = XVID_CSP_YV12; // defined in <xvid.h>
656 : chl 376
657 :     xframe.intra = -1; // let the codec decide between I-frame (1) and P-frame (0)
658 :    
659 :     xframe.quant = ARG_QUANTI; // is quant != 0, use a fixed quant (and ignore bitrate)
660 :    
661 :     xframe.motion = motion_presets[ARG_QUALITY];
662 :     xframe.general = general_presets[ARG_QUALITY];
663 :     xframe.quant_intra_matrix = xframe.quant_inter_matrix = NULL;
664 :    
665 :     xerr = xvid_encore(enc_handle, XVID_ENC_ENCODE, &xframe, &xstats);
666 :    
667 : edgomez 558 /*
668 :     * This is statictical data, e.g. for 2-pass. If you are not
669 :     * interested in any of this, you can use NULL instead of &xstats
670 :     */
671 : chl 376 *frametype = xframe.intra;
672 :     *streamlength = xframe.length;
673 :    
674 :     return xerr;
675 :     }
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4