[svn] / branches / dev-api-4 / xvidcore / examples / xvid_encraw.c Repository:
ViewVC logotype

Diff of /branches/dev-api-4/xvidcore/examples/xvid_encraw.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/xvidcore/examples/xvid_encraw.c revision 376, Sat Aug 17 20:03:36 2002 UTC branches/dev-api-4/xvidcore/examples/xvid_encraw.c revision 944, Tue Mar 25 22:53:57 2003 UTC
# Line 1  Line 1 
1  /**************************************************************************  /*****************************************************************************
2   *   *
3   *      XVID MPEG-4 VIDEO CODEC - Example for encoding and decoding   *  XVID MPEG-4 VIDEO CODEC
4     *  - Console based test application  -
5     *
6     *  Copyright(C) 2002-2003 Christoph Lampert
7   *   *
8   *      This program is free software; you can redistribute it and/or modify   *      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   *      it under the terms of the GNU General Public License as published by
# Line 14  Line 17 
17   *   *
18   *      You should have received a copy of the GNU General Public License   *      You should have received a copy of the GNU General Public License
19   *      along with this program; if not, write to the Free Software   *      along with this program; if not, write to the Free Software
20   *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21   *   *
22   *************************************************************************/   * $Id: xvid_encraw.c,v 1.11.2.13 2003-03-25 22:53:57 edgomez Exp $
   
 /************************************************************************  
23   *   *
24   *  Speed test routine for XviD using the XviD-API   ****************************************************************************/
25   *  (C) Christoph Lampert, 2002/08/17  
26    /*****************************************************************************
27     *  Application notes :
28   *   *
29   *  A sequence of YUV pics in PGM or RAW file format is encoded and the   *  A sequence of raw YUV I420 pics or YUV I420 PGM file format is encoded
30   *  raw MPEG-4 stream is written to stdout.   *  The speed is measured and frames' PSNR are taken from core.
  *  The encoding speed of this is measured, too.  
31   *   *
32   *  The program is plain C and needs no libraries except for libxvidcore,   *  The program is plain C and needs no libraries except for libxvidcore,
33   *  and maths-lib, so with UN*X you simply compile by   *  and maths-lib.
  *  
  *   gcc xvid_encraw.c -lxvidcore -lm -o xvid_encraw  
  *  
  *  Run without or with illegal parameters, then PGM input input is read  
  *  from stdin.  
  *  
  *  Parameters are: xvid_stat XDIM YDIM QUALITY BITRATE/QUANTIZER FRAMERATE  
  *  
  *  if XDIM or YDIM are illegal (e.g. 0), they are ignored and input is  
  *  considered to be PGM. Otherwise (X and Y both greater than 0) raw YUV  
  *  is expected, as e.g. the standard MPEG test-files, like "foreman"  
  *  
  *  0 <= QUALITY <= 6  (default 5)  
  *  
  *  BITRATE is in kbps (default 900),  
  *      if BITRATE<32, then value is taken is fixed QUANTIZER  
  *  
  *  FRAMERATE is a float (with or without decimal dot), default is 25.00  
  *  
  *  input/output and m4v-output is saved, if corresponding flags are set  
  *  
  *  PGM input must in a very specific format, see read_pgmheader  
  *  it can be generated e.g. from MPEG2 by    mpeg2dec -o pgmpipe  
  *  
  ************************************************************************/  
   
 /************************************************************************  
  *  
  *  For EXAMPLES how to use this, see the seperate file xvid_stat.examples  
34   *   *
35   ************************************************************************/   ************************************************************************/
36    
37  #include <stdio.h>  #include <stdio.h>
38  #include <stdlib.h>  #include <stdlib.h>
39  #include <math.h>               // needed for log10  #include <string.h>
40  #include <sys/time.h>           // only needed for gettimeofday  #include <math.h>
41    #ifndef WIN32
42    #include <sys/time.h>
43    #else
44    #include <time.h>
45    #endif
46    
47    #include "xvid.h"
48    
 #include "../src/xvid.h"                /* comes with XviD */  
49    
50  int motion_presets[7] = {  /*****************************************************************************
51          0,                                                              // Q 0   *                            Quality presets
52          PMV_EARLYSTOP16,                                                // Q 1   ****************************************************************************/
53          PMV_EARLYSTOP16,                                                // Q 2  
54          PMV_EARLYSTOP16 | PMV_HALFPELREFINE16,                          // Q 3  static xvid_motion_t const motion_presets[] = {
55          PMV_EARLYSTOP16 | PMV_HALFPELREFINE16,                          // Q 4          0,
56          PMV_EARLYSTOP16 | PMV_HALFPELREFINE16 | PMV_EARLYSTOP8          // Q 5          PMV_HALFPELREFINE16,
57                          | PMV_HALFPELREFINE8,          PMV_HALFPELREFINE16,
58          PMV_EARLYSTOP16 | PMV_HALFPELREFINE16 | PMV_EXTSEARCH16         // Q 6          PMV_HALFPELREFINE16 | PMV_HALFPELREFINE8,
59                          | PMV_USESQUARES16 | PMV_EARLYSTOP8 | PMV_HALFPELREFINE8          PMV_HALFPELREFINE16 | PMV_HALFPELREFINE8 | PMV_EXTSEARCH16 |
60                    PMV_USESQUARES16,
61            PMV_HALFPELREFINE16 | PMV_HALFPELREFINE8 | PMV_EXTSEARCH16 |
62                    PMV_USESQUARES16 | PMV_CHROMA16 | PMV_CHROMA8,
63          };          };
64    
65  int general_presets[7] = {  static xvid_vol_t const vol_presets[] = {
66          XVID_H263QUANT, /* or use XVID_MPEGQUANT */             // Q 0          XVID_MPEGQUANT,
67          XVID_MPEGQUANT,                                         // Q 1          0,
68          XVID_H263QUANT,                                // Q 2          0,
69          XVID_H263QUANT | XVID_HALFPEL,                          // Q 3          XVID_QUARTERPEL,
70          XVID_H263QUANT | XVID_HALFPEL | XVID_INTER4V,           // Q 4          XVID_QUARTERPEL | XVID_GMC,
71          XVID_H263QUANT | XVID_HALFPEL | XVID_INTER4V,           // Q 5          0
72          XVID_H263QUANT | XVID_HALFPEL | XVID_INTER4V };         // Q 6  };
73    
74    static xvid_vop_t const vop_presets[] = {
75            XVID_DYNAMIC_BFRAMES,
76            XVID_DYNAMIC_BFRAMES,
77            XVID_DYNAMIC_BFRAMES | XVID_HALFPEL,
78            XVID_DYNAMIC_BFRAMES | XVID_HALFPEL | XVID_INTER4V,
79            XVID_DYNAMIC_BFRAMES | XVID_HALFPEL | XVID_INTER4V | XVID_HQACPRED,
80            XVID_DYNAMIC_BFRAMES | XVID_HALFPEL | XVID_HQACPRED |
81                    XVID_MODEDECISION_BITS
82    };
83    
84  /* my default values for encoding */  /*****************************************************************************
85     *                     Command line global variables
86     ****************************************************************************/
87    
88    /* Maximum number of frames to encode */
89    #define ABS_MAXFRAMENR 9999
90    
91    static int ARG_STATS = 0;
92    static int ARG_DUMP = 0;
93    static int ARG_LUMIMASKING = 0;
94    static int ARG_BITRATE = 0;
95    static char *ARG_PASS1 = 0;
96    static char *ARG_PASS2 = 0;
97    static float ARG_QUANTI = 0.0f;
98    static int ARG_QUALITY = 5;
99    static float ARG_FRAMERATE = 25.00f;
100    static int ARG_MAXFRAMENR = ABS_MAXFRAMENR;
101    static char *ARG_INPUTFILE = NULL;
102    static int ARG_INPUTTYPE = 0;
103    static int ARG_SAVEMPEGSTREAM = 0;
104    static char *ARG_OUTPUTFILE = NULL;
105    static int XDIM = 0;
106    static int YDIM = 0;
107    static int ARG_BQRATIO = 150;
108    static int ARG_BQOFFSET = 100;
109    static int ARG_MAXBFRAMES = 0;
110    static int ARG_PACKED = 0;
111    static int ARG_DEBUG = 0;
112    
113  #define ABS_MAXFRAMENR 9999               // max number of frames  #define IMAGE_SIZE(x,y) ((x)*(y)*3/2)
114    
115  int ARG_BITRATE=900;  #define MAX(A,B) ( ((A)>(B)) ? (A) : (B) )
116  int ARG_QUANTI=0;  #define SMALL_EPS (1e-10)
117    
118  int ARG_QUALITY =6;  #define SWAP(a) ( (((a)&0x000000ff)<<24) | (((a)&0x0000ff00)<<8) | \
119  int ARG_MINQUANT=1;                    (((a)&0x00ff0000)>>8)  | (((a)&0xff000000)>>24) )
 int ARG_MAXQUANT=31;  
 float ARG_FRAMERATE=25.00;  
120    
121  int ARG_MAXFRAMENR=ABS_MAXFRAMENR;  /****************************************************************************
122     *                     Nasty global vars ;-)
123     ***************************************************************************/
124    
125  #ifdef BFRAMES  static int i;
126    
127  int ARG_MAXBFRAMES=1;  /* the path where to save output */
128  int ARG_BQUANTRATIO=200;  static char filepath[256] = "./";
129    
130  #endif  /* Internal structures (handles) for encoding and decoding */
131    static void *enc_handle = NULL;
132    
133  #define MAX(A,B) ( ((A)>(B)) ? (A) : (B) )  /*****************************************************************************
134  #define SMALL_EPS 1e-10   *               Local prototypes
135     ****************************************************************************/
136    
137  /* these are global variables. Not very elegant, but easy, and this is an easy program */  /* Prints program usage message */
138    static void usage();
139    
140  int XDIM=0;  /* Statistical functions */
141  int YDIM=0;     // will be set when reading first image  static double msecond();
 int i,filenr = 0;  
142    
143  int save_m4v_flag = 1;          // output MPEG4-bytestream?  /* PGM related functions */
144  int save_ref_flag = 0;          // save input image  static int read_pgmheader(FILE * handle);
145    static int read_pgmdata(FILE * handle,
146                                                    unsigned char *image);
147    static int read_yuvdata(FILE * handle,
148                                                    unsigned char *image);
149    
150  int pgmflag = 0;                // a flag, if input is in PGM format, overwritten in init-phase  /* Encoder related functions */
151  char filepath[256] = "./";      // the path where to save output  static int enc_init(int use_assembler);
152    static int enc_stop();
153    static int enc_main(unsigned char *image,
154                                            unsigned char *bitstream,
155                                            int *key,
156                                            int *stats_type,
157                                            int *stats_quant,
158                                            int *stats_length,
159                                            int stats[3]);
160    
161  void *enc_handle = NULL;                // internal structures (handles) for encoding  /*****************************************************************************
162     *               Main function
163     ****************************************************************************/
164    
165    int
166    main(int argc,
167             char *argv[])
168    {
169    
170  /*********************************************************************/          unsigned char *mp4_buffer = NULL;
171  /*                     "statistical" functions                       */          unsigned char *in_buffer = NULL;
172  /*                                                                   */          unsigned char *out_buffer = NULL;
 /*  these are not needed for encoding or decoding, but for measuring */  
 /*  time and quality, there in nothing specific to XviD in these     */  
 /*                                                                   */  
 /*********************************************************************/  
173    
174  double msecond()          double enctime;
175  /* return the current time in seconds(!)  */          double totalenctime = 0.;
 {  
         struct timeval  tv;  
         gettimeofday(&tv, 0);  
         return tv.tv_sec + tv.tv_usec * 1.0e-6;  
 }  
176    
177  /*********************************************************************/          int totalsize;
178  /*                    input and output functions                     */          int result;
179  /*                                                                   */          int m4v_size;
180  /* the are small and simple routines to read and write PGM and YUV   */          int key;
181  /* image. It's just for convenience, again nothing specific to XviD  */          int stats_type;
182  /*                                                                   */          int stats_quant;
183  /*********************************************************************/          int stats_length;
184            int use_assembler = 0;
185    
186  int read_pgmheader(FILE* handle)          int input_num;
187  {          int output_num;
         int bytes,xsize,ysize,depth;  
         char dummy[2];  
188    
189          bytes = fread(dummy,1,2,handle);          char filename[256];
190    
191          if ( (bytes < 2) || (dummy[0] != 'P') || (dummy[1] != '5' ))          FILE *in_file = stdin;
192                  return 1;          FILE *out_file = NULL;
193          fscanf(handle,"%d %d %d",&xsize,&ysize,&depth);  
194          if ( (xsize > 1440) || (ysize > 2880 ) || (depth != 255) )          printf("xvid_encraw - raw mpeg4 bitstream encoder ");
195          {          printf("written by Christoph Lampert 2002-2003\n\n");
196                  return 2;  
197    /*****************************************************************************
198     *                            Command line parsing
199     ****************************************************************************/
200    
201            for (i = 1; i < argc; i++) {
202    
203                    if (strcmp("-asm", argv[i]) == 0) {
204                            use_assembler = 1;
205                    } else if (strcmp("-w", argv[i]) == 0 && i < argc - 1) {
206                            i++;
207                            XDIM = atoi(argv[i]);
208                    } else if (strcmp("-h", argv[i]) == 0 && i < argc - 1) {
209                            i++;
210                            YDIM = atoi(argv[i]);
211                    } else if (strcmp("-bitrate", argv[i]) == 0 && i < argc - 1) {
212                            i++;
213                            ARG_BITRATE = atoi(argv[i]);
214                    } else if (strcmp("-pass1", argv[i]) == 0 && i < argc - 1) {
215                            i++;
216                            ARG_PASS1 = argv[i];
217                    } else if (strcmp("-pass2", argv[i]) == 0 && i < argc - 2) {
218                            i++;
219                            ARG_PASS1 = argv[i];
220                            i++;
221                            ARG_PASS2 = argv[i];
222                    } else if (strcmp("-max_bframes", argv[i]) == 0 && i < argc - 1) {
223                            i++;
224                            ARG_MAXBFRAMES = atoi(argv[i]);
225                    } else if (strcmp("-packed", argv[i]) == 0) {
226                            ARG_PACKED = 1;
227                    } else if (strcmp("-bquant_ratio", argv[i]) == 0 && i < argc - 1) {
228                            i++;
229                            ARG_BQRATIO = atoi(argv[i]);
230                    } else if (strcmp("-bquant_offset", argv[i]) == 0 && i < argc - 1) {
231                            i++;
232                            ARG_BQOFFSET = atoi(argv[i]);
233                    } else if (strcmp("-quality", argv[i]) == 0 && i < argc - 1) {
234                            i++;
235                            ARG_QUALITY = atoi(argv[i]);
236                    } else if (strcmp("-framerate", argv[i]) == 0 && i < argc - 1) {
237                            i++;
238                            ARG_FRAMERATE = (float) atof(argv[i]);
239                    } else if (strcmp("-i", argv[i]) == 0 && i < argc - 1) {
240                            i++;
241                            ARG_INPUTFILE = argv[i];
242                    } else if (strcmp("-stats", argv[i]) == 0) {
243                            ARG_STATS = 1;
244                    } else if (strcmp("-dump", argv[i]) == 0) {
245                            ARG_DUMP = 1;
246                    } else if (strcmp("-lumimasking", argv[i]) == 0) {
247                            ARG_LUMIMASKING = 1;
248                    } else if (strcmp("-type", argv[i]) == 0 && i < argc - 1) {
249                            i++;
250                            ARG_INPUTTYPE = atoi(argv[i]);
251                    } else if (strcmp("-nframes", argv[i]) == 0 && i < argc - 1) {
252                            i++;
253                            ARG_MAXFRAMENR = atoi(argv[i]);
254                    } else if (strcmp("-quant", argv[i]) == 0 && i < argc - 1) {
255                            i++;
256                            ARG_QUANTI = (float) atof(argv[i]);
257                    } else if (strcmp("-save", argv[i]) == 0) {
258                            ARG_SAVEMPEGSTREAM = 1;
259                    } else if (strcmp("-debug", argv[i]) == 0) {
260                            ARG_DEBUG = 1;
261                    } else if (strcmp("-o", argv[i]) == 0 && i < argc - 1) {
262                            i++;
263                            ARG_OUTPUTFILE = argv[i];
264                    } else if (strcmp("-help", argv[i])) {
265                            usage();
266                            return (0);
267                    } else {
268                            usage();
269                            exit(-1);
270                    }
271    
272            }
273    
274    /*****************************************************************************
275     *                            Arguments checking
276     ****************************************************************************/
277    
278            if (XDIM <= 0 || XDIM >= 2048 || YDIM <= 0 || YDIM >= 2048) {
279                    fprintf(stderr,
280                                    "Trying to retreive width and height from PGM header\n");
281                    ARG_INPUTTYPE = 1;              /* pgm */
282            }
283    
284            if (ARG_QUALITY < 0 || ARG_QUALITY > 5) {
285                    fprintf(stderr, "Wrong Quality\n");
286                    return (-1);
287            }
288    
289            if (ARG_FRAMERATE <= 0) {
290                    fprintf(stderr, "Wrong Framerate %s \n", argv[5]);
291                    return (-1);
292            }
293    
294            if (ARG_MAXFRAMENR <= 0) {
295                    fprintf(stderr, "Wrong number of frames\n");
296                    return (-1);
297            }
298    
299            if (ARG_INPUTFILE == NULL || strcmp(ARG_INPUTFILE, "stdin") == 0) {
300                    in_file = stdin;
301            } else {
302    
303                    in_file = fopen(ARG_INPUTFILE, "rb");
304                    if (in_file == NULL) {
305                            fprintf(stderr, "Error opening input file %s\n", ARG_INPUTFILE);
306                            return (-1);
307                    }
308            }
309    
310            if (ARG_INPUTTYPE) {
311                    if (read_pgmheader(in_file)) {
312                            fprintf(stderr,
313                                            "Wrong input format, I want YUV encapsulated in PGM\n");
314                            return (-1);
315          }          }
         if ( (XDIM==0) || (YDIM==0) )  
         {       XDIM=xsize;  
                 YDIM=ysize;  
316          }          }
317    
318          return 0;          /* now we know the sizes, so allocate memory */
319  }          in_buffer = (unsigned char *) malloc(IMAGE_SIZE(XDIM, YDIM));
320            if (!in_buffer)
321                    goto free_all_memory;
322    
323  int read_pgmdata(FILE* handle, unsigned char *image)          /* this should really be enough memory ! */
324  {          mp4_buffer = (unsigned char *) malloc(IMAGE_SIZE(XDIM, YDIM) * 2);
325          int i,status;          if (!mp4_buffer)
326          char dummy;                  goto free_all_memory;
327    
328          unsigned char* buff1_ptr2 = image + XDIM*YDIM;  /*****************************************************************************
329          unsigned char* buff1_ptr3 = image + XDIM*YDIM + XDIM/2*YDIM/2;   *                            XviD PART  Start
330     ****************************************************************************/
331    
         fread(image,XDIM*YDIM,1,stdin); // read Y component of picture  
332    
333          for (i=0;i<YDIM/2;i++)          result = enc_init(use_assembler);
334          {          if (result) {
335                  fread(buff1_ptr2,XDIM/2,1,stdin);        // read U                  fprintf(stderr, "Encore INIT problem, return value %d\n", result);
336                  buff1_ptr2 += XDIM/2;                  goto release_all;
                 fread(buff1_ptr3,XDIM/2,1,stdin);        // read V  
                 buff1_ptr3 += XDIM/2;  
337          }          }
338          fread(&dummy,1,1,handle);       //  I don't know why, but this seems needed  
339          return 0;  /*****************************************************************************
340     *                            Main loop
341     ****************************************************************************/
342    
343            if (ARG_SAVEMPEGSTREAM && ARG_OUTPUTFILE) {
344    
345                    if ((out_file = fopen(ARG_OUTPUTFILE, "w+b")) == NULL) {
346                            fprintf(stderr, "Error opening output file %s\n", ARG_OUTPUTFILE);
347                            goto release_all;
348  }  }
349    
350  int read_yuvdata(FILE* handle, unsigned char *image)          } else {
351  {       int i;                  out_file = NULL;
352          char dummy;          }
353    
354          unsigned char* buff1_ptr2 = image + XDIM*YDIM;  /*****************************************************************************
355          unsigned char* buff1_ptr3 = image + XDIM*YDIM + XDIM/2*YDIM/2;   *                       Encoding loop
356     ****************************************************************************/
357    
358          if (fread(image,XDIM,YDIM*3/2,stdin) != YDIM*3/2)          totalsize = 0;
359                  return 1;  
360          else          result = 0;
361                  return 0;  
362            input_num = 0;                          /* input frame counter */
363            output_num = 0;                         /* output frame counter */
364    
365            do {
366    
367                    char *type;
368                    int sse[3];
369    
370                    if (input_num >= ARG_MAXFRAMENR) {
371                            result = 1;
372  }  }
373    
374  int write_pgm(char *filename, unsigned char *image)                  if (!result) {
375  {                          if (ARG_INPUTTYPE) {
376          FILE *filehandle;                                  /* read PGM data (YUV-format) */
377          filehandle=fopen(filename,"wb");                                  result = read_pgmdata(in_file, in_buffer);
378          if (filehandle)                          } else {
379          {                                  /* read raw data (YUV-format) */
380                  fprintf(filehandle,"P5\n\n");           //                                  result = read_yuvdata(in_file, in_buffer);
                 fprintf(filehandle,"%d %d 255\n",XDIM,YDIM*3/2);  
                 fwrite(image,XDIM,YDIM*3/2,filehandle);  
                 fclose(filehandle);  
                 return 0;  
381          }          }
         else  
                 return 1;  
382  }  }
383    
384  /*********************************************************************/  /*****************************************************************************
385  /* Routines for encoding: init encoder, frame step, release encoder  */   *                       Encode and decode this frame
386  /*********************************************************************/   ****************************************************************************/
387    
388  #define FRAMERATE_INCR 1001                  enctime = msecond();
389                    m4v_size =
390                            enc_main(!result ? in_buffer : 0, mp4_buffer, &key, &stats_type,
391                                             &stats_quant, &stats_length, sse);
392                    enctime = msecond() - enctime;
393    
394                    /* Write the Frame statistics */
395    
396  int enc_init(int use_assembler)                  printf("%5d: key=%i, time=%6.0f, length=%7d", !result ? input_num : -1,
397  {       /* initialize encoder for first use, pass all needed parameters to the codec */                             key, (float) enctime, (int) m4v_size);
         int xerr;  
398    
399          XVID_INIT_PARAM xinit;                  if (stats_type > 0) {   /* !XVID_TYPE_NOTHING */
         XVID_ENC_PARAM xparam;  
400    
401          if(use_assembler)                          switch (stats_type) {
402                            case XVID_TYPE_IVOP:
403                                    type = "I";
404                                    break;
405                            case XVID_TYPE_PVOP:
406                                    type = "P";
407                                    break;
408                            case XVID_TYPE_BVOP:
409                                    type = "B";
410                                    break;
411                            case XVID_TYPE_SVOP:
412                                    type = "S";
413                                    break;
414                            default:
415                                    type = "U";
416                                    break;
417                            }
418    
419  #ifdef ARCH_IA64                          printf(" | type=%s, quant=%2d, length=%7d", type, stats_quant,
420                  xinit.cpu_flags = XVID_CPU_FORCE | XVID_CPU_IA64;                                     stats_length);
 #else  
                 xinit.cpu_flags = 0;  
 #endif  
421    
422          else  #define SSE2PSNR(sse, width, height) ((!(sse))?0.0f : 48.131f - 10*(float)log10((float)(sse)/((float)((width)*(height)))))
                 xinit.cpu_flags = XVID_CPU_FORCE;  
423    
424          xvid_init(NULL, 0, &xinit, NULL);                          if (ARG_STATS) {
425                                    printf(", psnr y = %2.2f, psnr u = %2.2f, psnr v = %2.2f",
426                                               SSE2PSNR(sse[0], XDIM, YDIM), SSE2PSNR(sse[1], XDIM / 2,
427                                                                                                                              YDIM / 2),
428                                               SSE2PSNR(sse[2], XDIM / 2, YDIM / 2));
429                            }
430    
         xparam.width = XDIM;  
         xparam.height = YDIM;  
         if ((ARG_FRAMERATE - (int)ARG_FRAMERATE) < SMALL_EPS)  
         {  
                 xparam.fincr = 1;  
                 xparam.fbase = (int)ARG_FRAMERATE;  
431          }          }
432          else  #undef SSE2PSNR
433          {  
434                  xparam.fincr = FRAMERATE_INCR;                  printf("\n");
435                  xparam.fbase = (int)(FRAMERATE_INCR * ARG_FRAMERATE);  
436                    if (m4v_size < 0) {
437                            break;
438          }          }
         xparam.rc_reaction_delay_factor = 16;  
         xparam.rc_averaging_period = 100;  
         xparam.rc_buffer = 10;  
         xparam.rc_bitrate = ARG_BITRATE*1000;  
         xparam.min_quantizer = 1;  
         xparam.max_quantizer = 31;  
         xparam.max_key_interval = (int)ARG_FRAMERATE*10;  
   
 #ifdef BFRAMES  
         xparam.global = XVID_GLOBAL_DX50BVOP;  
         xparam.max_bframes = ARG_MAXBFRAMES;  
         xparam.bquant_ratio = ARG_BQUANTRATIO;  
         xparam.frame_drop_ratio=0;  
 #endif  
439    
440          /* I use a small value here, since will not encode whole movies,                  /* Update encoding time stats */
441                  but short clips */                  totalenctime += enctime;
442                    totalsize += m4v_size;
443    
444          xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xparam, NULL);  /*****************************************************************************
445          enc_handle=xparam.handle;   *                       Save stream to file
446     ****************************************************************************/
447    
448          return xerr;                  if (m4v_size > 0 && ARG_SAVEMPEGSTREAM) {
449  }                          /* Save single files */
450                            if (out_file == NULL) {
451                                    sprintf(filename, "%sframe%05d.m4v", filepath, output_num);
452                                    out_file = fopen(filename, "wb");
453                                    fwrite(mp4_buffer, m4v_size, 1, out_file);
454                                    fclose(out_file);
455                                    out_file = NULL;
456                                    output_num++;
457                            } else {
458    
459  int  enc_stop()                                  /* Write mp4 data */
460  {       int xerr;                                  fwrite(mp4_buffer, 1, m4v_size, out_file);
461    
462          xerr = xvid_encore(enc_handle, XVID_ENC_DESTROY, NULL, NULL);                          }
         return xerr;  
463  }  }
464    
465  int  enc_main(unsigned char* image, unsigned char* bitstream, int *streamlength, int* frametype)                  input_num++;
 {       int xerr;  
466    
467          XVID_ENC_FRAME xframe;                  /* Read the header if it's pgm stream */
468          XVID_ENC_STATS xstats;                  if (!result && ARG_INPUTTYPE)
469                            result = read_pgmheader(in_file);
470    
471          xframe.bitstream = bitstream;          } while (1);
         xframe.length = -1;     // this is written by the routine  
472    
         xframe.image = image;  
         xframe.colorspace = XVID_CSP_YV12;      // defined in <xvid.h>  
473    
         xframe.intra = -1; // let the codec decide between I-frame (1) and P-frame (0)  
474    
475          xframe.quant = ARG_QUANTI;      // is quant != 0, use a fixed quant (and ignore bitrate)  /*****************************************************************************
476     *         Calculate totals and averages for output, print results
477     ****************************************************************************/
478    
479          xframe.motion = motion_presets[ARG_QUALITY];          printf("Tot: enctime(ms) =%7.2f,               length(bytes) = %7d\n",
480          xframe.general = general_presets[ARG_QUALITY];                     totalenctime, (int) totalsize);
         xframe.quant_intra_matrix = xframe.quant_inter_matrix = NULL;  
481    
482  #ifdef BFRAMES          if (input_num > 0) {
483          xframe.bquant = 0;                  totalsize /= input_num;
484  #endif                  totalenctime /= input_num;
485            } else {
486                    totalsize = -1;
487                    totalenctime = -1;
488            }
489    
490          xerr = xvid_encore(enc_handle, XVID_ENC_ENCODE, &xframe, &xstats);          printf("Avg: enctime(ms) =%7.2f, fps =%7.2f, length(bytes) = %7d\n",
491                       totalenctime, 1000 / totalenctime, (int) totalsize);
492    
 /*              enc_result->is_key_frame = xframe.intra;  
                 enc_result->quantizer = xframe.quant;  
                 enc_result->total_bits = xframe.length * 8;  
                 enc_result->motion_bits = xstats.hlength * 8;  
                 enc_result->texture_bits = enc_result->total_bits - enc_result->motion_bits;  
 */  
493    
494  /*  This is statictical data, e.g. for 2-pass.  /*****************************************************************************
495      If you are not interested in any of this, you can use   *                            XviD PART  Stop
496          NULL instead of &xstats   ****************************************************************************/
 */  
         *frametype = xframe.intra;  
         *streamlength = xframe.length;  
497    
498          return xerr;    release_all:
 }  
499    
500  /*********************************************************************/          if (enc_handle) {
501  /*                          Main program                             */                  result = enc_stop();
502  /*********************************************************************/                  if (result)
503                            fprintf(stderr, "Encore RELEASE problem return value %d\n",
504                                            result);
505            }
506    
507  int main(int argc, char *argv[])          if (in_file)
508  {                  fclose(in_file);
509    unsigned char *divx_buffer = NULL;          if (out_file)
510    unsigned char *in_buffer = NULL;                  fclose(out_file);
511    
512    double enctime;    free_all_memory:
513    double totalenctime=0.;          free(out_buffer);
514            free(mp4_buffer);
515            free(in_buffer);
516    
517    long totalsize=0;          return (0);
   int status;  
518    
519    int m4v_size;  }
   int frame_type[ABS_MAXFRAMENR];  
   int Iframes=0, Pframes=0, Bframes=0;  
   int use_assembler=1;  
520    
   char filename[256];  
521    
522    FILE *filehandle;  /*****************************************************************************
523     *                        "statistical" functions
524     *
525     *  these are not needed for encoding or decoding, but for measuring
526     *  time and quality, there in nothing specific to XviD in these
527     *
528     *****************************************************************************/
529    
530  /* read YUV in pgm format from stdin */  /* Return time elapsed time in miliseconds since the program started */
531    if (!pgmflag)  static double
532    msecond()
533    {    {
534          pgmflag = 1;  #ifndef WIN32
535            struct timeval tv;
536    
537  //      if (argc==2 && !strcmp(argv[1],"-noasm"))          gettimeofday(&tv, 0);
538  //        use_assembler = 0;          return (tv.tv_sec * 1.0e3 + tv.tv_usec * 1.0e-3);
539    #else
540            clock_t clk;
541    
542          if (argc>=3)          clk = clock();
543          {       XDIM = atoi(argv[1]);          return (clk * 1000 / CLOCKS_PER_SEC);
544                  YDIM = atoi(argv[2]);  #endif
                 if ( (XDIM <= 0) || (XDIM >= 2048) || (YDIM <=0) || (YDIM >= 2048) )  
                 {       fprintf(stderr,"Wrong frames size %d %d, trying PGM \n",XDIM, YDIM);  
545                  }                  }
546                  else  
547    /*****************************************************************************
548     *                             Usage message
549     *****************************************************************************/
550    
551    static void
552    usage()
553    {
554            fprintf(stderr, "Usage : xvid_stat [OPTIONS]\n\n");
555            fprintf(stderr, "Input options:\n");
556            fprintf(stderr, " -i       string : input filename (default=stdin)\n");
557            fprintf(stderr, " -type    integer: input data type (yuv=0, pgm=1)\n");
558            fprintf(stderr, " -w       integer: frame width ([1.2048])\n");
559            fprintf(stderr, " -h       integer: frame height ([1.2048])\n");
560            fprintf(stderr, " -nframes integer: number of frames to encode\n");
561            fprintf(stderr, "\n");
562            fprintf(stderr, "Output options:\n");
563            fprintf(stderr, " -dump    : save decoder output\n");
564            fprintf(stderr, " -save    : save mpeg4 raw stream\n");
565            fprintf(stderr, " -o string: output filename\n");
566            fprintf(stderr, "\n");
567            fprintf(stderr, "BFrames options:\n");
568            fprintf(stderr, " -max_bframes   integer: max bframes (default=0)\n");
569            fprintf(stderr, " -bquant_ratio  integer: bframe quantizer ratio (default=150)\n");
570            fprintf(stderr, " -bquant_offset integer: bframe quantizer offset (default=100)\n");
571            fprintf(stderr, "\n");
572            fprintf(stderr, "Rate control options:\n");
573            fprintf(stderr, " -framerate float               : target framerate (>0 | default=25.0)\n");
574            fprintf(stderr, " -bitrate   integer             : bitrate -- for CBR/VBR pass2\n");
575            fprintf(stderr, " -quant     float               : quantizer -- for \"Fixed\" quantizer RC\n");
576            fprintf(stderr, " -pass1     filename            : stats filename\n");
577            fprintf(stderr, " -pass2     filename1 filename2 : first pass stats and scaled stats filename\n");
578            fprintf(stderr, "\n");
579            fprintf(stderr, "Other options\n");
580            fprintf(stderr, " -asm            : use assembly optmized code\n");
581            fprintf(stderr, " -quality integer: quality ([0..5])\n");
582            fprintf(stderr, " -packed         : packed mode\n");
583            fprintf(stderr, " -lumimasking    : use lumimasking algorithm\n");
584            fprintf(stderr, " -stats          : print stats about encoded frames\n");
585            fprintf(stderr, " -debug          : print all MB dquants\n");
586            fprintf(stderr, " -help           : prints this help message\n");
587    }
588    
589    /*****************************************************************************
590     *                       Input and output functions
591     *
592     *      the are small and simple routines to read and write PGM and YUV
593     *      image. It's just for convenience, again nothing specific to XviD
594     *
595     *****************************************************************************/
596    
597    static int
598    read_pgmheader(FILE * handle)
599                  {                  {
600                          YDIM = YDIM*3/2; /* for YUV */          int bytes, xsize, ysize, depth;
601                          pgmflag = 0;          char dummy[2];
602    
603            bytes = fread(dummy, 1, 2, handle);
604    
605            if ((bytes < 2) || (dummy[0] != 'P') || (dummy[1] != '5'))
606                    return (1);
607    
608            fscanf(handle, "%d %d %d", &xsize, &ysize, &depth);
609            if ((xsize > 1440) || (ysize > 2880) || (depth != 255)) {
610                    fprintf(stderr, "%d %d %d\n", xsize, ysize, depth);
611                    return (2);
612                  }                  }
613            if ((XDIM == 0) || (YDIM == 0)) {
614                    XDIM = xsize;
615                    YDIM = ysize * 2 / 3;
616          }          }
617    
618            return (0);
619    }    }
620    
621    if (pgmflag)  static int
622    {     if (read_pgmheader(stdin))  read_pgmdata(FILE * handle,
623                             unsigned char *image)
624              {              {
625                fprintf(stderr,"Wrong input format, I want YUV encapsulated in PGM\n");          int i;
626                return 1;          char dummy;
627              }  
628    }          unsigned char *y = image;
629    if (argc>=4)          unsigned char *u = image + XDIM * YDIM;
630    {     ARG_QUALITY = atoi(argv[3]);          unsigned char *v = image + XDIM * YDIM + XDIM / 2 * YDIM / 2;
631          if ( (ARG_QUALITY < 0) || (ARG_QUALITY > 6) )  
632                  { fprintf(stderr,"Wrong Quality\n"); return -1; }          /* read Y component of picture */
633          else          fread(y, 1, XDIM * YDIM, handle);
634                    fprintf(stderr,"Quality %d\n",ARG_QUALITY);  
635            for (i = 0; i < YDIM / 2; i++) {
636                    /* read U */
637                    fread(u, 1, XDIM / 2, handle);
638    
639                    /* read V */
640                    fread(v, 1, XDIM / 2, handle);
641    
642                    /* Update pointers */
643                    u += XDIM / 2;
644                    v += XDIM / 2;
645    }    }
646    if (argc>=5)  
647    {     ARG_BITRATE = atoi(argv[4]);          /*  I don't know why, but this seems needed */
648          if ( (ARG_BITRATE <= 0) )          fread(&dummy, 1, 1, handle);
649                  { fprintf(stderr,"Wrong Bitrate\n"); return -1; }  
650          if ( (ARG_BITRATE < 32) )          return (0);
                 { ARG_QUANTI = ARG_BITRATE;  
                   ARG_BITRATE=0;  
                   fprintf(stderr,"Quantizer %d\n",ARG_QUANTI);  
651                  }                  }
652    
653    static int
654    read_yuvdata(FILE * handle,
655                             unsigned char *image)
656    {
657    
658            if (fread(image, 1, IMAGE_SIZE(XDIM, YDIM), handle) !=
659                    (unsigned int) IMAGE_SIZE(XDIM, YDIM))
660                    return (1);
661          else          else
662                    fprintf(stderr,"Bitrate %d kbps\n",ARG_BITRATE);                  return (0);
663    }    }
   if (argc>=6)  
   {     ARG_FRAMERATE = (float)atof(argv[5]);  
         if ( (ARG_FRAMERATE <= 0) )  
                 { fprintf(stderr,"Wrong Fraterate %s \n",argv[5]); return -1; }  
         fprintf(stderr,"Framerate %6.3f fps\n",ARG_FRAMERATE);  
   }  
   
   if (argc>=7)  
   {     ARG_MAXFRAMENR = atoi(argv[6]);  
         if ( (ARG_MAXFRAMENR <= 0) )  
          { fprintf(stderr,"Wrong number of frames\n"); return -1; }  
         fprintf(stderr,"max. Framenr. %d\n",ARG_MAXFRAMENR);  
   }  
   
 #ifdef BFRAMES  
   if (argc>=8)  
   {     ARG_MAXBFRAMES = atoi(argv[7]);  
         if ( (ARG_MAXBFRAMES < -1) || ( ARG_MAXBFRAMES > ARG_FRAMERATE) )  
          { fprintf(stderr,"Wrong maximumnumber of bframes\n"); return -1; }  
         fprintf(stderr,"max. B-frames %d\n",ARG_MAXBFRAMES);  
   }  
   
   if (argc>=9)  
   {     ARG_MAXFRAMENR = atoi(argv[8]);  
         if ( (ARG_BQUANTRATIO <= 0) )  
          { fprintf(stderr,"Wrong B-frames Quantizer ratio \n"); return -1; }  
         fprintf(stderr,"B-frames quant-ratio %d\n",ARG_BQUANTRATIO);  
   }  
 #endif  
664    
665  /* now we know the sizes, so allocate memory */  /*****************************************************************************
666     *     Routines for encoding: init encoder, frame step, release encoder
667     ****************************************************************************/
668    
669    in_buffer = (unsigned char *) malloc(XDIM*YDIM);  /* sample plugin */
   if (!in_buffer)  
     goto free_all_memory;  
670    
671    divx_buffer = (unsigned char *) malloc(XDIM*YDIM*2);  int
672    if (!divx_buffer)  rawenc_debug(void *handle,
673      goto free_all_memory;                           int opt,
674                             void *param1,
675                             void *param2)
676    {
677            switch (opt) {
678            case XVID_PLG_INFO:
679                    {
680                            xvid_plg_info_t *info = (xvid_plg_info_t *) param1;
681    
682    YDIM = YDIM*2/3; // PGM is YUV 4:2:0 format, so real image height is *2/3 of PGM picture                          info->flags = XVID_REQDQUANTS;
683                            return 0;
684                    }
685    
686  /*********************************************************************/          case XVID_PLG_CREATE:
687  /*                         XviD PART  Start                          */          case XVID_PLG_DESTROY:
688  /*********************************************************************/          case XVID_PLG_BEFORE:
689                    return 0;
690    
691    status = enc_init(use_assembler);          case XVID_PLG_AFTER:
         if (status)  
692          {          {
693                  fprintf(stderr,"Encore INIT problem, return value %d\n", status);                          xvid_plg_data_t *data = (xvid_plg_data_t *) param1;
694                  goto release_all;                          int i, j;
         }  
695    
696  /*********************************************************************/                          printf("---[ frame: %5i   quant: %2i   length: %6i ]---\n",
697  /*                               Main loop                           */                                     data->frame_num, data->quant, data->length);
698  /*********************************************************************/                          for (j = 0; j < data->mb_height; j++) {
699                                    for (i = 0; i < data->mb_width; i++)
700                                            printf("%2i ", data->dquant[j * data->dquant_stride + i]);
701                                    printf("\n");
702                            }
703    
704    do                          return 0;
705      {                  }
706          if (pgmflag)          }
               status = read_pgmdata(stdin, in_buffer);  // read PGM data (YUV-format)  
         else  
               status = read_yuvdata(stdin, in_buffer);  // read raw data (YUV-format)  
707    
708      if (status)          return XVID_ERR_FAIL;
         {  
           // Couldn't read image, most likely end-of-file  
           continue;  
709          }          }
710    
711    
712      if (save_ref_flag)  #define FRAMERATE_INCR 1001
713    
714    
715    /* Initialize encoder for first use, pass all needed parameters to the codec */
716    static int
717    enc_init(int use_assembler)
718          {          {
719                  sprintf(filename, "%s%05d.pgm", filepath, filenr);          int xerr;
720                  write_pgm(filename,in_buffer);          xvid_plugin_cbr_t cbr;
721            xvid_plugin_2pass1_t rc2pass1;
722            xvid_plugin_2pass2_t rc2pass2;
723            xvid_plugin_fixed_t rcfixed;
724            xvid_enc_plugin_t plugins[7];
725            xvid_gbl_init_t xvid_gbl_init;
726            xvid_enc_create_t xvid_enc_create;
727    
728            /*------------------------------------------------------------------------
729             * XviD core initialization
730             *----------------------------------------------------------------------*/
731    
732            /* Set version -- version checking will done by xvidcore */
733            memset(&xvid_gbl_init, 0, sizeof(xvid_gbl_init));
734            xvid_gbl_init.version = XVID_VERSION;
735    
736    
737            /* Do we have to enable ASM optimizations ? */
738            if (use_assembler) {
739    
740    #ifdef ARCH_IS_IA64
741                    xvid_gbl_init.cpu_flags = XVID_CPU_FORCE | XVID_CPU_IA64;
742    #else
743                    xvid_gbl_init.cpu_flags = 0;
744    #endif
745            } else {
746                    xvid_gbl_init.cpu_flags = XVID_CPU_FORCE;
747          }          }
748    
749            /* Initialize XviD core -- Should be done once per __process__ */
750            xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL);
751    
752  /*********************************************************************/          /*------------------------------------------------------------------------
753  /*               analyse this frame before encoding                  */           * XviD encoder initialization
754  /*********************************************************************/           *----------------------------------------------------------------------*/
755    
756  //      nothing is done here at the moment, but you could e.g. create          /* Version again */
757  //      histograms or measure entropy or apply preprocessing filters...          memset(&xvid_enc_create, 0, sizeof(xvid_enc_create));
758            xvid_enc_create.version = XVID_VERSION;
759    
760  /*********************************************************************/          /* Width and Height of input frames */
761  /*               encode and decode this frame                        */          xvid_enc_create.width = XDIM;
762  /*********************************************************************/          xvid_enc_create.height = YDIM;
763    
764          enctime = -msecond();          /* init plugins  */
         status = enc_main(in_buffer, divx_buffer, &m4v_size, &frame_type[filenr]);  
         enctime += msecond();  
765    
766          totalenctime += enctime;          xvid_enc_create.plugins = plugins;
767          totalsize += m4v_size;          xvid_enc_create.num_plugins = 0;
768    
769          fprintf(stderr,"Frame %5d: intra %d, enctime =%6.1f ms length=%7d bytes\n",          if (ARG_BITRATE) {
770                   filenr, frame_type[filenr], enctime*1000, m4v_size);                  cbr.version = XVID_VERSION;
771                    memset(&cbr, 0, sizeof(xvid_plugin_cbr_t));
772                    cbr.bitrate = ARG_BITRATE;
773    
774          if (save_m4v_flag)                  plugins[xvid_enc_create.num_plugins].func = xvid_plugin_cbr;
775          {                  plugins[xvid_enc_create.num_plugins].param = &cbr;
776                  fwrite(divx_buffer, m4v_size, 1, stdout);                  xvid_enc_create.num_plugins++;
777          }          }
778    
779          if (pgmflag)          if (ARG_QUANTI) {
780                  status = read_pgmheader(stdin);                  rcfixed.version = XVID_VERSION;
781                                  // because if this was the last PGM, stop now                  /* We will use a 1/10 precision, just to make sure it works */
782                    rcfixed.quant_base = 10;
783                    rcfixed.quant_increment = (int) (ARG_QUANTI * 10);
784    
785          filenr++;                  plugins[xvid_enc_create.num_plugins].func = xvid_plugin_fixed;
786                    plugins[xvid_enc_create.num_plugins].param = &rcfixed;
787                    xvid_enc_create.num_plugins++;
788            }
789    
790     } while ( (!status) && (filenr<ARG_MAXFRAMENR) );          if (ARG_PASS1 && ARG_PASS2) {
791                    rc2pass2.version = XVID_VERSION;
792                    memset(&rc2pass2, 0, sizeof(xvid_plugin_2pass2_t));
793                    rc2pass2.filename1 = ARG_PASS1;
794                    rc2pass2.filename2 = ARG_PASS2;
795    
796                    plugins[xvid_enc_create.num_plugins].func = xvid_plugin_2pass2;
797                    plugins[xvid_enc_create.num_plugins].param = &rc2pass2;
798                    xvid_enc_create.num_plugins++;
799            } else if (ARG_PASS1) {
800                    rc2pass1.version = XVID_VERSION;
801                    memset(&rc2pass1, 0, sizeof(xvid_plugin_2pass1_t));
802                    rc2pass1.filename = ARG_PASS1;
803    
804                    plugins[xvid_enc_create.num_plugins].func = xvid_plugin_2pass1;
805                    plugins[xvid_enc_create.num_plugins].param = &rc2pass1;
806                    xvid_enc_create.num_plugins++;
807            }
808    
809  /*********************************************************************/          if (ARG_LUMIMASKING) {
810  /*     calculate totals and averages for output, print results       */                  plugins[xvid_enc_create.num_plugins].func = xvid_plugin_lumimasking;
811  /*********************************************************************/                  plugins[xvid_enc_create.num_plugins].param = NULL;
812                    xvid_enc_create.num_plugins++;
813            }
814    
815          totalsize    /= filenr;          if (ARG_DUMP) {
816          totalenctime /= filenr;                  plugins[xvid_enc_create.num_plugins].func = xvid_plugin_dump;
817                    plugins[xvid_enc_create.num_plugins].param = NULL;
818                    xvid_enc_create.num_plugins++;
819            }
820    
821          for (i=0;i<filenr;i++)          if (ARG_DEBUG) {
822          {                  plugins[xvid_enc_create.num_plugins].func = rawenc_debug;
823                  switch (frame_type[i])                  plugins[xvid_enc_create.num_plugins].param = NULL;
824                  {                  xvid_enc_create.num_plugins++;
                 case 0:  
                         Pframes++;  
                         break;  
                 case 1:  
                         Iframes++;  
                         break;  
                 case 2:  
                 default:  
                         Bframes++;  
                         break;  
825                  }                  }
826    
827            /* No fancy thread tests */
828            xvid_enc_create.num_threads = 0;
829    
830            /* Frame rate - Do some quick float fps = fincr/fbase hack */
831            if ((ARG_FRAMERATE - (int) ARG_FRAMERATE) < SMALL_EPS) {
832                    xvid_enc_create.fincr = 1;
833                    xvid_enc_create.fbase = (int) ARG_FRAMERATE;
834            } else {
835                    xvid_enc_create.fincr = FRAMERATE_INCR;
836                    xvid_enc_create.fbase = (int) (FRAMERATE_INCR * ARG_FRAMERATE);
837          }          }
838    
839          fprintf(stderr,"Avg: enctime %5.2f ms, %5.2f fps, filesize =%d\n",          /* Maximum key frame interval */
840                  1000*totalenctime, 1./totalenctime, totalsize);          xvid_enc_create.max_key_interval = (int) ARG_FRAMERATE *10;
841    
842  /*********************************************************************/          /* Bframes settings */
843  /*                         XviD PART  Stop                           */          xvid_enc_create.max_bframes = ARG_MAXBFRAMES;
844  /*********************************************************************/          xvid_enc_create.bquant_ratio = ARG_BQRATIO;
845            xvid_enc_create.bquant_offset = ARG_BQOFFSET;
846    
847  release_all:          /* Dropping ratio frame -- we don't need that */
848            xvid_enc_create.frame_drop_ratio = 0;
849    
850            /* Global encoder options */
851            xvid_enc_create.global = 0;
852    
853            if (ARG_PACKED)
854                    xvid_enc_create.global |=XVID_PACKED;
855    
856          if (enc_handle)          if (ARG_STATS)
857                    xvid_enc_create.global |=XVID_EXTRASTATS_ENABLE;
858    
859            /* I use a small value here, since will not encode whole movies, but short clips */
860            xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
861    
862            /* Retrieve the encoder instance from the structure */
863            enc_handle = xvid_enc_create.handle;
864    
865            return (xerr);
866    }
867    
868    static int
869    enc_stop()
870          {          {
871                  status = enc_stop();          int xerr;
872                  if (status)  
873                          fprintf(stderr,"Encore RELEASE problem return value %d\n", status);          /* Destroy the encoder instance */
874            xerr = xvid_encore(enc_handle, XVID_ENC_DESTROY, NULL, NULL);
875    
876            return (xerr);
877          }          }
878    
879  free_all_memory:  static int
880          free(divx_buffer);  enc_main(unsigned char *image,
881          free(in_buffer);                   unsigned char *bitstream,
882                     int *key,
883                     int *stats_type,
884                     int *stats_quant,
885                     int *stats_length,
886                     int sse[3])
887    {
888            int ret;
889    
890            xvid_enc_frame_t xvid_enc_frame;
891            xvid_enc_stats_t xvid_enc_stats;
892    
893            /* Version for the frame and the stats */
894            memset(&xvid_enc_frame, 0, sizeof(xvid_enc_frame));
895            xvid_enc_frame.version = XVID_VERSION;
896    
897            memset(&xvid_enc_stats, 0, sizeof(xvid_enc_stats));
898            xvid_enc_stats.version = XVID_VERSION;
899    
900            /* Bind output buffer */
901            xvid_enc_frame.bitstream = bitstream;
902            xvid_enc_frame.length = -1;
903    
904            /* Initialize input image fields */
905            if (image) {
906                    xvid_enc_frame.input.plane[0] = image;
907                    xvid_enc_frame.input.csp = XVID_CSP_I420;
908                    xvid_enc_frame.input.stride[0] = XDIM;
909            } else {
910                    xvid_enc_frame.input.csp = XVID_CSP_NULL;
911            }
912    
913            /* Set up core's general features */
914            xvid_enc_frame.vol_flags = vol_presets[ARG_QUALITY];
915            if (ARG_STATS)
916                    xvid_enc_frame.vol_flags |= XVID_EXTRASTATS;
917    
918            /* Set up core's general features */
919            xvid_enc_frame.vop_flags = vop_presets[ARG_QUALITY];
920    
921            /* Frame type -- let core decide for us */
922            xvid_enc_frame.type = XVID_TYPE_AUTO;
923    
924            /* Force the right quantizer -- It is internally managed by RC plugins */
925            xvid_enc_frame.quant = 0;
926    
927            /* Set up motion estimation flags */
928            xvid_enc_frame.motion = motion_presets[ARG_QUALITY];
929    
930            /* We don't use special matrices */
931            xvid_enc_frame.quant_intra_matrix = NULL;
932            xvid_enc_frame.quant_inter_matrix = NULL;
933    
934            /* Encode the frame */
935            ret =
936                    xvid_encore(enc_handle, XVID_ENC_ENCODE, &xvid_enc_frame,
937                                            &xvid_enc_stats);
938    
939            *key = (xvid_enc_frame.out_flags & XVID_KEYFRAME);
940            *stats_type = xvid_enc_stats.type;
941            *stats_quant = xvid_enc_stats.quant;
942            *stats_length = xvid_enc_stats.length;
943            sse[0] = xvid_enc_stats.sse_y;
944            sse[1] = xvid_enc_stats.sse_u;
945            sse[2] = xvid_enc_stats.sse_v;
946    
947    return 0;          return (ret);
948  }  }
Legend:
Removed from v.376  
changed lines
  Added in v.944
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4