[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 558, Sat Sep 28 14:26:53 2002 UTC branches/dev-api-4/xvidcore/examples/xvid_encraw.c revision 919, Thu Mar 13 11:07:20 2003 UTC
# Line 3  Line 3 
3   *  XVID MPEG-4 VIDEO CODEC   *  XVID MPEG-4 VIDEO CODEC
4   *  - Console based test application  -   *  - Console based test application  -
5   *   *
6   *  Copyright(C) 2002 Christoph Lampert   *  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 19  Line 19 
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  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 $   * $Id: xvid_encraw.c,v 1.11.2.5 2003-03-13 11:07:20 suxen_drol Exp $
23   *   *
24   ****************************************************************************/   ****************************************************************************/
25    
26  /*****************************************************************************  /*****************************************************************************
27   *  Application notes :   *  Application notes :
28   *   *
29   *  A sequence of YUV pics in PGM file format is encoded and decoded   *  A sequence of raw YUV I420 pics or YUV I420 PGM file format is encoded
30   *  The speed is measured and PSNR of decoded picture is calculated.   *  The speed is measured and frames' PSNR are taken from core.
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.   *  and maths-lib.
# Line 36  Line 36 
36    
37  #include <stdio.h>  #include <stdio.h>
38  #include <stdlib.h>  #include <stdlib.h>
39    #include <string.h>
40  #include <math.h>  #include <math.h>
41  #ifndef _MSC_VER  #ifndef WIN32
42  #include <sys/time.h>  #include <sys/time.h>
43  #else  #else
44  #include <time.h>  #include <time.h>
# Line 49  Line 50 
50   *                            Quality presets   *                            Quality presets
51   ****************************************************************************/   ****************************************************************************/
52    
53  static int const motion_presets[7] = {  static xvid_motion_t const motion_presets[] = {
54          0,                                                        // Q 0          0,
55          PMV_EARLYSTOP16,                                          // Q 1          PMV_HALFPELREFINE16,
56          PMV_EARLYSTOP16,                                          // Q 2          PMV_HALFPELREFINE16,
57          PMV_EARLYSTOP16 | PMV_HALFPELREFINE16,                    // Q 3          PMV_HALFPELREFINE16 | PMV_HALFPELREFINE8,
58          PMV_EARLYSTOP16 | PMV_HALFPELREFINE16,                    // Q 4          PMV_HALFPELREFINE16 | PMV_HALFPELREFINE8 | PMV_EXTSEARCH16 | PMV_USESQUARES16,
59          PMV_EARLYSTOP16 | PMV_HALFPELREFINE16 | PMV_EARLYSTOP8 |  // Q 5          PMV_HALFPELREFINE16 | PMV_HALFPELREFINE8 | PMV_EXTSEARCH16 | PMV_USESQUARES16 | PMV_CHROMA16 | PMV_CHROMA8,
         PMV_HALFPELREFINE8,  
         PMV_EARLYSTOP16 | PMV_HALFPELREFINE16 | PMV_EXTSEARCH16 | // Q 6  
         PMV_USESQUARES16 | PMV_EARLYSTOP8 | PMV_HALFPELREFINE8  
60  };  };
61    
62  static int const general_presets[7] = {  static xvid_vol_t const vol_presets[] = {
63          XVID_H263QUANT,                               // Q 0          XVID_MPEGQUANT,
64          XVID_MPEGQUANT,                               // Q 1          0,
65          XVID_H263QUANT,                               // Q 2          0,
66          XVID_H263QUANT | XVID_HALFPEL,                // Q 3          XVID_QUARTERPEL,
67          XVID_H263QUANT | XVID_HALFPEL | XVID_INTER4V, // Q 4          XVID_QUARTERPEL | XVID_GMC,
68          XVID_H263QUANT | XVID_HALFPEL | XVID_INTER4V, // Q 5          XVID_QUARTERPEL | XVID_GMC
         XVID_H263QUANT | XVID_HALFPEL | XVID_INTER4V  // Q 6  
69  };  };
70    
71    static xvid_vop_t const vop_presets[] = {
72            XVID_DYNAMIC_BFRAMES,
73            XVID_DYNAMIC_BFRAMES,
74            XVID_DYNAMIC_BFRAMES | XVID_HALFPEL,
75            XVID_DYNAMIC_BFRAMES | XVID_HALFPEL | XVID_INTER4V,
76            XVID_DYNAMIC_BFRAMES | XVID_HALFPEL | XVID_INTER4V | XVID_HQACPRED,
77            XVID_DYNAMIC_BFRAMES | XVID_HALFPEL | XVID_INTER4V | XVID_HQACPRED | XVID_MODEDECISION_BITS
78    };
79    
80  /*****************************************************************************  /*****************************************************************************
81   *                     Command line global variables   *                     Command line global variables
# Line 79  Line 84 
84  /* Maximum number of frames to encode */  /* Maximum number of frames to encode */
85  #define ABS_MAXFRAMENR 9999  #define ABS_MAXFRAMENR 9999
86    
87    static int   ARG_STATS = 0;
88  static int   ARG_BITRATE = 900;  static int   ARG_BITRATE = 900;
89  static int   ARG_QUANTI = 0;  static int   ARG_QUANTI = 0;
90  static int   ARG_QUALITY = 6;  static int   ARG_QUALITY = 5;
91  static int   ARG_MINQUANT = 1;  static int   ARG_MINQUANT = 1;
92  static int   ARG_MAXQUANT = 31;  static int   ARG_MAXQUANT = 31;
93  static float ARG_FRAMERATE = 25.00f;  static float ARG_FRAMERATE = 25.00f;
# Line 89  Line 95 
95  static char *ARG_INPUTFILE = NULL;  static char *ARG_INPUTFILE = NULL;
96  static int   ARG_INPUTTYPE = 0;  static int   ARG_INPUTTYPE = 0;
97  static int   ARG_SAVEMPEGSTREAM = 0;  static int   ARG_SAVEMPEGSTREAM = 0;
 static int   ARG_OUTPUTTYPE = 0;  
98  static char *ARG_OUTPUTFILE = NULL;  static char *ARG_OUTPUTFILE = NULL;
99  static int   XDIM = 0;  static int   XDIM = 0;
100  static int   YDIM = 0;  static int   YDIM = 0;
101    static int   ARG_BQRATIO = 150;
102    static int   ARG_BQOFFSET = 100;
103    static int   ARG_MAXBFRAMES = 0;
104    static int   ARG_PACKED = 0;
105  #define IMAGE_SIZE(x,y) ((x)*(y)*3/2)  #define IMAGE_SIZE(x,y) ((x)*(y)*3/2)
106    
107  #define MAX(A,B) ( ((A)>(B)) ? (A) : (B) )  #define MAX(A,B) ( ((A)>(B)) ? (A) : (B) )
108  #define SMALL_EPS 1e-10  #define SMALL_EPS (1e-10)
   
 #define LONG_PACK(a,b,c,d) ((long) (((long)(a))<<24) | (((long)(b))<<16) | \  
                                    (((long)(c))<<8)  |((long)(d)))  
109    
110  #define SWAP(a) ( (((a)&0x000000ff)<<24) | (((a)&0x0000ff00)<<8) | \  #define SWAP(a) ( (((a)&0x000000ff)<<24) | (((a)&0x0000ff00)<<8) | \
111                    (((a)&0x00ff0000)>>8)  | (((a)&0xff000000)>>24) )                    (((a)&0x00ff0000)>>8)  | (((a)&0xff000000)>>24) )
# Line 134  Line 140 
140  /* Encoder related functions */  /* Encoder related functions */
141  static int enc_init(int use_assembler);  static int enc_init(int use_assembler);
142  static int enc_stop();  static int enc_stop();
143  static int enc_main(unsigned char* image, unsigned char* bitstream,  static int enc_main(unsigned char* image,
144                                          int *streamlength, int* frametype);                                          unsigned char* bitstream,
145                        int *key,
146                                            int *stats_type,
147                        int *stats_quant,
148                        int *stats_length,
149                                            int stats[3]);
150    
151  /*****************************************************************************  /*****************************************************************************
152   *               Main function   *               Main function
# Line 151  Line 162 
162          double enctime;          double enctime;
163          double totalenctime=0.;          double totalenctime=0.;
164    
165          long totalsize;          int totalsize;
166          int status;          int status;
         int frame_type;  
         int bigendian;  
   
167          int m4v_size;          int m4v_size;
168        int key;
169            int stats_type;
170        int stats_quant;
171        int stats_length;
172          int use_assembler=0;          int use_assembler=0;
173    
174          char filename[256];          char filename[256];
# Line 164  Line 176 
176          FILE *in_file = stdin;          FILE *in_file = stdin;
177          FILE *out_file = NULL;          FILE *out_file = NULL;
178    
179          printf("xvid_decraw - raw mpeg4 bitstream encoder ");          printf("xvid_encraw - raw mpeg4 bitstream encoder ");
180          printf("written by Christoph Lampert 2002\n\n");          printf("written by Christoph Lampert 2002-2003\n\n");
181    
182  /*****************************************************************************  /*****************************************************************************
183   *                            Command line parsing   *                            Command line parsing
# Line 188  Line 200 
200                          i++;                          i++;
201                          ARG_BITRATE = atoi(argv[i]);                          ARG_BITRATE = atoi(argv[i]);
202                  }                  }
203                    else if (strcmp("-bn", argv[i]) == 0 && i < argc - 1 ) {
204                            i++;
205                            ARG_MAXBFRAMES = atoi(argv[i]);
206                    }
207                    else if (strcmp("-p", argv[i]) == 0) {
208                ARG_PACKED = 1;
209                    }
210                    else if (strcmp("-bqr", argv[i]) == 0 && i < argc - 1 ) {
211                            i++;
212                            ARG_BQRATIO = atoi(argv[i]);
213                    }
214                    else if (strcmp("-bqo", argv[i]) == 0 && i < argc - 1 ) {
215                            i++;
216                            ARG_BQOFFSET = atoi(argv[i]);
217                    }
218                  else if (strcmp("-q", argv[i]) == 0 && i < argc - 1 ) {                  else if (strcmp("-q", argv[i]) == 0 && i < argc - 1 ) {
219                          i++;                          i++;
220                          ARG_QUALITY = atoi(argv[i]);                          ARG_QUALITY = atoi(argv[i]);
# Line 200  Line 227 
227                          i++;                          i++;
228                          ARG_INPUTFILE = argv[i];                          ARG_INPUTFILE = argv[i];
229                  }                  }
230                    else if (strcmp("-s", argv[i]) == 0) {
231                            ARG_STATS = 1;
232                    }
233                  else if (strcmp("-t", argv[i]) == 0 && i < argc - 1 ) {                  else if (strcmp("-t", argv[i]) == 0 && i < argc - 1 ) {
234                          i++;                          i++;
235                          ARG_INPUTTYPE = atoi(argv[i]);                          ARG_INPUTTYPE = atoi(argv[i]);
# Line 212  Line 242 
242                          i++;                          i++;
243                          ARG_QUANTI = atoi(argv[i]);                          ARG_QUANTI = atoi(argv[i]);
244                  }                  }
245                  else if (strcmp("-m", argv[i]) == 0 && i < argc - 1 ) {                  else if (strcmp("-m", argv[i]) == 0) {
246                          i++;                          ARG_SAVEMPEGSTREAM = 1;
                         ARG_SAVEMPEGSTREAM = atoi(argv[i]);  
                 }  
                 else if (strcmp("-mt", argv[i]) == 0 && i < argc - 1 ) {  
                         i++;  
                         ARG_OUTPUTTYPE = atoi(argv[i]);  
247                  }                  }
248                  else if (strcmp("-o", argv[i]) == 0 && i < argc - 1 ) {                  else if (strcmp("-o", argv[i]) == 0 && i < argc - 1 ) {
249                          i++;                          i++;
# Line 244  Line 269 
269                  ARG_INPUTTYPE = 1; /* pgm */                  ARG_INPUTTYPE = 1; /* pgm */
270          }          }
271    
272          if ( ARG_QUALITY < 0 || ARG_QUALITY > 6) {          if ( ARG_QUALITY < 0 || ARG_QUALITY > 5) {
273                  fprintf(stderr,"Wrong Quality\n");                  fprintf(stderr,"Wrong Quality\n");
274                  return -1;                  return(-1);
275          }          }
276    
277          if ( ARG_BITRATE <= 0 && ARG_QUANTI == 0) {          if ( ARG_BITRATE <= 0 && ARG_QUANTI == 0) {
278                  fprintf(stderr,"Wrong Bitrate\n");                  fprintf(stderr,"Wrong Bitrate\n");
279                  return -1;                  return(-1);
280          }          }
281    
282          if ( ARG_FRAMERATE <= 0) {          if ( ARG_FRAMERATE <= 0) {
283                  fprintf(stderr,"Wrong Framerate %s \n",argv[5]);                  fprintf(stderr,"Wrong Framerate %s \n",argv[5]);
284                  return -1;                  return(-1);
285          }          }
286    
287          if ( ARG_MAXFRAMENR <= 0) {          if ( ARG_MAXFRAMENR <= 0) {
288                  fprintf(stderr,"Wrong number of frames\n");                  fprintf(stderr,"Wrong number of frames\n");
289                  return -1;                  return(-1);
290          }          }
291    
292          if ( ARG_INPUTFILE == NULL || strcmp(ARG_INPUTFILE, "stdin") == 0) {          if ( ARG_INPUTFILE == NULL || strcmp(ARG_INPUTFILE, "stdin") == 0) {
# Line 272  Line 297 
297                  in_file = fopen(ARG_INPUTFILE, "rb");                  in_file = fopen(ARG_INPUTFILE, "rb");
298                  if (in_file == NULL) {                  if (in_file == NULL) {
299                          fprintf(stderr, "Error opening input file %s\n", ARG_INPUTFILE);                          fprintf(stderr, "Error opening input file %s\n", ARG_INPUTFILE);
300                          return -1;                          return(-1);
301                  }                  }
302          }          }
303    
304          if (ARG_INPUTTYPE) {          if (ARG_INPUTTYPE) {
305                  if (read_pgmheader(in_file)) {                  if (read_pgmheader(in_file)) {
306                          fprintf(stderr, "Wrong input format, I want YUV encapsulated in PGM\n");                          fprintf(stderr, "Wrong input format, I want YUV encapsulated in PGM\n");
307                          return -1;                          return(-1);
308                  }                  }
309          }          }
310    
311          /* now we know the sizes, so allocate memory */          /* now we know the sizes, so allocate memory */
   
312          in_buffer = (unsigned char *) malloc(IMAGE_SIZE(XDIM,YDIM));          in_buffer = (unsigned char *) malloc(IMAGE_SIZE(XDIM,YDIM));
313          if (!in_buffer)          if (!in_buffer)
314                  goto free_all_memory;                  goto free_all_memory;
# Line 310  Line 334 
334   *                            Main loop   *                            Main loop
335   ****************************************************************************/   ****************************************************************************/
336    
337          if (ARG_SAVEMPEGSTREAM && (ARG_OUTPUTTYPE || ARG_OUTPUTFILE)) {          if (ARG_SAVEMPEGSTREAM && ARG_OUTPUTFILE) {
   
                 if (ARG_OUTPUTFILE == NULL && ARG_OUTPUTTYPE)  
                         ARG_OUTPUTFILE = "stream.mp4u";  
                 else if(ARG_OUTPUTFILE == NULL && !ARG_OUTPUTTYPE)  
                         ARG_OUTPUTFILE = "stream.m4v";  
338    
339                  if((out_file = fopen(ARG_OUTPUTFILE, "w+b")) == NULL) {                  if((out_file = fopen(ARG_OUTPUTFILE, "w+b")) == NULL) {
340                          fprintf(stderr, "Error opening output file %s\n", ARG_OUTPUTFILE);                          fprintf(stderr, "Error opening output file %s\n", ARG_OUTPUTFILE);
341                          goto release_all;                          goto release_all;
342                  }                  }
343    
                 /* Write header */  
                 if (ARG_OUTPUTTYPE) {  
                         char *ptr;  
                         long test;  
   
                         test = LONG_PACK('M','P','4','U');  
                         ptr = (unsigned char *)&test;  
                         if(*ptr == 'M')  
                                 bigendian = 1;  
                         else  
                                 bigendian = 0;  
   
                         test = (!bigendian)?SWAP(test):test;  
   
                         fwrite(&test, sizeof(test), 1, out_file);  
   
                 }  
   
344          }          }
345          else {          else {
346                  out_file = NULL;                  out_file = NULL;
# Line 353  Line 354 
354    
355          do {          do {
356    
357                  if (ARG_INPUTTYPE)                  char *type;
358                          status = read_pgmdata(in_file, in_buffer);      // read PGM data (YUV-format)                  int stats[3];
                 else  
                         status = read_yuvdata(in_file, in_buffer);      // read raw data (YUV-format)  
359    
360                  if (status)                  if(ARG_INPUTTYPE) {
361                  {                          /* read PGM data (YUV-format) */
362                            status = read_pgmdata(in_file, in_buffer);
363                    } else {
364                            /* read raw data (YUV-format) */
365                            status = read_yuvdata(in_file, in_buffer);
366                    }
367    
368                    if(status) {
369                          /* Couldn't read image, most likely end-of-file */                          /* Couldn't read image, most likely end-of-file */
370                          continue;                          continue;
371                  }                  }
# Line 369  Line 375 
375   ****************************************************************************/   ****************************************************************************/
376    
377                  enctime = msecond();                  enctime = msecond();
378                  status = enc_main(in_buffer, mp4_buffer, &m4v_size, &frame_type);                  m4v_size = enc_main(in_buffer, mp4_buffer, &key, &stats_type, &stats_quant, &stats_length, stats);
379                  enctime = msecond() - enctime;                  enctime = msecond() - enctime;
380    
381                    /* Write the Frame statistics */
382    
383                    printf("Frame %5d: key=%i, time(ms)=%6.1f, length=%7d",
384                               (int)filenr,
385                               key,
386                               (float)enctime,
387                               (int)m4v_size);
388    
389            if (stats_type > 0) {   /* !XVID_TYPE_NOTHING */
390    
391                    switch(stats_type) {
392                    case XVID_TYPE_IVOP:
393                            type = "I";
394                            break;
395                    case XVID_TYPE_PVOP:
396                            type = "P";
397                            break;
398                    case XVID_TYPE_BVOP:
399                            type = "B";
400                            break;
401                    case XVID_TYPE_SVOP:
402                            type = "S";
403                            break;
404                    default:
405                            type = "U";
406                            break;
407                    }
408    
409                printf(" | type=%s quant=%2d, length=%7d", type, stats_quant, stats_length);
410    
411                if(ARG_STATS) {
412                            printf(", psnr y = %2.2f, psnr u = %2.2f, psnr v = %2.2f",
413                                       (stats[0] == 0)? 0.0f: 48.131f - 10*(float)log10((float)stats[0]/((float)(XDIM)*(YDIM))),
414                                       (stats[1] == 0)? 0.0f: 48.131f - 10*(float)log10((float)stats[1]/((float)(XDIM)*(YDIM)/4)),
415                                       (stats[2] == 0)? 0.0f: 48.131f - 10*(float)log10((float)stats[2]/((float)(XDIM)*(YDIM)/4)));
416                }
417                    }
418    
419                    printf("\n");
420    
421    
422                    /* Update encoding time stats */
423                  totalenctime += enctime;                  totalenctime += enctime;
424                  totalsize += m4v_size;                  totalsize += m4v_size;
425    
426                  printf("Frame %5d: intra %1d, enctime=%6.1f ms, size=%6dbytes\n",          /* Not coded frames return 0 */
427                             (int)filenr, (int)frame_type, (float)enctime, (int)m4v_size);                  if(m4v_size == 0) goto next_frame;
428    
429    
430    /*****************************************************************************
431     *                       Save stream to file
432     ****************************************************************************/
433    
434                  if (ARG_SAVEMPEGSTREAM)                  if (ARG_SAVEMPEGSTREAM)
435                  {                  {
# Line 389  Line 442 
442                                  out_file = NULL;                                  out_file = NULL;
443                          }                          }
444                          else {                          else {
                                 /* Using mp4u container */  
                                 if (ARG_OUTPUTTYPE) {  
                                         long size = m4v_size;  
                                         size = (!bigendian)?SWAP(size):size;  
                                         fwrite(&size, sizeof(size), 1, out_file);  
                                 }  
445    
446                                  /* Write mp4 data */                                  /* Write mp4 data */
447                                  fwrite(mp4_buffer, m4v_size, 1, out_file);                                  fwrite(mp4_buffer, 1, m4v_size, out_file);
448    
449                          }                          }
450                  }                  }
451    
452                    filenr++;
453    
454            next_frame:
455                  /* Read the header if it's pgm stream */                  /* Read the header if it's pgm stream */
456                  if (ARG_INPUTTYPE)                  if (ARG_INPUTTYPE)
457                          status = read_pgmheader(in_file);                          status = read_pgmheader(in_file);
458    
                 filenr++;  
   
459          } while ( (!status) && (filenr<ARG_MAXFRAMENR) );          } while ( (!status) && (filenr<ARG_MAXFRAMENR) );
460    
461    
# Line 419  Line 467 
467          totalsize    /= filenr;          totalsize    /= filenr;
468          totalenctime /= filenr;          totalenctime /= filenr;
469    
470          printf("Avg: enctime %5.2f ms, %5.2f fps, filesize %7d bytes\n",          printf("Avg: enctime(ms) =%7.2f, fps =%7.2f, length(bytes) = %7d\n",
471                     totalenctime, 1000/totalenctime, (int)totalsize);                     totalenctime, 1000/totalenctime, (int)totalsize);
472    
473    
474  /*****************************************************************************  /*****************************************************************************
475   *                            XviD PART  Stop   *                            XviD PART  Stop
476   ****************************************************************************/   ****************************************************************************/
# Line 435  Line 484 
484                          fprintf(stderr, "Encore RELEASE problem return value %d\n", status);                          fprintf(stderr, "Encore RELEASE problem return value %d\n", status);
485          }          }
486    
487            if(in_file)
488          fclose(in_file);          fclose(in_file);
489          if(out_file)          if(out_file)
490                  fclose(out_file);                  fclose(out_file);
# Line 444  Line 494 
494          free(mp4_buffer);          free(mp4_buffer);
495          free(in_buffer);          free(in_buffer);
496    
497          return 0;          return(0);
498    
499  }  }
500    
# Line 460  Line 510 
510  /* Return time elapsed time in miliseconds since the program started */  /* Return time elapsed time in miliseconds since the program started */
511  static double msecond()  static double msecond()
512  {  {
513  #ifndef _MSC_VER  #ifndef WIN32
514          struct timeval  tv;          struct timeval  tv;
515          gettimeofday(&tv, 0);          gettimeofday(&tv, 0);
516          return tv.tv_sec*1.0e3 + tv.tv_usec * 1.0e-3;          return(tv.tv_sec*1.0e3 + tv.tv_usec * 1.0e-3);
517  #else  #else
518          clock_t clk;          clock_t clk;
519          clk = clock();          clk = clock();
520          return clk * 1000 / CLOCKS_PER_SEC;          return(clk * 1000 / CLOCKS_PER_SEC);
521  #endif  #endif
522  }  }
523    
# Line 483  Line 533 
533          fprintf(stderr, " -w integer     : frame width ([1.2048])\n");          fprintf(stderr, " -w integer     : frame width ([1.2048])\n");
534          fprintf(stderr, " -h integer     : frame height ([1.2048])\n");          fprintf(stderr, " -h integer     : frame height ([1.2048])\n");
535          fprintf(stderr, " -b integer     : target bitrate (>0 | default=900kbit)\n");          fprintf(stderr, " -b integer     : target bitrate (>0 | default=900kbit)\n");
536            fprintf(stderr, " -bn integer    : max bframes (default=0)\n");
537        fprintf(stderr, " -p             : packed mode\n");
538            fprintf(stderr, " -bqr integer   : bframe quantizer ratio (default=150)\n");
539            fprintf(stderr, " -bqo integer   : bframe quantizer offset (default=100)\n");
540          fprintf(stderr, " -f float       : target framerate (>0)\n");          fprintf(stderr, " -f float       : target framerate (>0)\n");
541          fprintf(stderr, " -i string      : input filename (default=stdin)\n");          fprintf(stderr, " -i string      : input filename (default=stdin)\n");
542            fprintf(stderr, " -s             : print stats about encoded frames\n");
543          fprintf(stderr, " -t integer     : input data type (yuv=0, pgm=1)\n");          fprintf(stderr, " -t integer     : input data type (yuv=0, pgm=1)\n");
544          fprintf(stderr, " -n integer     : number of frames to encode\n");          fprintf(stderr, " -n integer     : number of frames to encode\n");
545          fprintf(stderr, " -q integer     : quality ([0..5])\n");          fprintf(stderr, " -q integer     : quality ([0..5])\n");
546          fprintf(stderr, " -d boolean     : save decoder output (0 False*, !=0 True)\n");          fprintf(stderr, " -d boolean     : save decoder output (0 False*, !=0 True)\n");
547          fprintf(stderr, " -m boolean     : save mpeg4 raw stream (0 False*, !=0 True)\n");          fprintf(stderr, " -m             : save mpeg4 raw stream\n");
548          fprintf(stderr, " -o string      : output container filename (only usefull when -m 1 is used) :\n");          fprintf(stderr, " -o string      : output container filename (only usefull when -m 1 is used) :\n");
549          fprintf(stderr, "                  When this option is not used : one file per encoded frame\n");          fprintf(stderr, "                  When this option is not used : one file per encoded frame\n");
550          fprintf(stderr, "                  When this option is used :\n");          fprintf(stderr, "                  When this option is used : save to 'string' file\n");
         fprintf(stderr, "                    + stream.m4v with -mt 0\n");  
         fprintf(stderr, "                    + stream.mp4u with -mt 1\n");  
         fprintf(stderr, " -mt integer    : output type (m4v=0, mp4u=1)\n");  
551          fprintf(stderr, " -help          : prints this help message\n");          fprintf(stderr, " -help          : prints this help message\n");
552          fprintf(stderr, " -quant integer : fixed quantizer (disables -b setting)\n");          fprintf(stderr, " -quant integer : fixed quantizer (disables -b setting)\n");
553          fprintf(stderr, " (* means default)\n");          fprintf(stderr, " (* means default)\n");
# Line 518  Line 570 
570          bytes = fread(dummy,1,2,handle);          bytes = fread(dummy,1,2,handle);
571    
572          if ( (bytes < 2) || (dummy[0] != 'P') || (dummy[1] != '5' ))          if ( (bytes < 2) || (dummy[0] != 'P') || (dummy[1] != '5' ))
573                  return 1;                  return(1);
574    
575          fscanf(handle,"%d %d %d",&xsize,&ysize,&depth);          fscanf(handle,"%d %d %d",&xsize,&ysize,&depth);
576          if ( (xsize > 1440) || (ysize > 2880 ) || (depth != 255) )          if ( (xsize > 1440) || (ysize > 2880 ) || (depth != 255) )
577          {          {
578                  fprintf(stderr,"%d %d %d\n",xsize,ysize,depth);                  fprintf(stderr,"%d %d %d\n",xsize,ysize,depth);
579                  return 2;                  return(2);
580          }          }
581          if ( (XDIM==0) || (YDIM==0) )          if ( (XDIM==0) || (YDIM==0) )
582          {          {
# Line 532  Line 584 
584                  YDIM=ysize*2/3;                  YDIM=ysize*2/3;
585          }          }
586    
587          return 0;          return(0);
588  }  }
589    
590  static int read_pgmdata(FILE* handle, unsigned char *image)  static int read_pgmdata(FILE* handle, unsigned char *image)
# Line 563  Line 615 
615      /*  I don't know why, but this seems needed */      /*  I don't know why, but this seems needed */
616          fread(&dummy, 1, 1, handle);          fread(&dummy, 1, 1, handle);
617    
618          return 0;          return(0);
619  }  }
620    
621  static int read_yuvdata(FILE* handle, unsigned char *image)  static int read_yuvdata(FILE* handle, unsigned char *image)
622  {  {
623    
624          if (fread(image, 1, IMAGE_SIZE(XDIM, YDIM), handle) != (unsigned int)IMAGE_SIZE(XDIM, YDIM))          if (fread(image, 1, IMAGE_SIZE(XDIM, YDIM), handle) != (unsigned int)IMAGE_SIZE(XDIM, YDIM))
625                  return 1;                  return(1);
626          else          else
627                  return 0;                  return(0);
628  }  }
629    
630  /*****************************************************************************  /*****************************************************************************
631   *     Routines for encoding: init encoder, frame step, release encoder   *     Routines for encoding: init encoder, frame step, release encoder
632   ****************************************************************************/   ****************************************************************************/
633    
634    /* sample plugin */
635    
636    int rawenc_debug(void * handle, int opt, void * param1, void * param2)
637    {
638        switch(opt)
639        {
640        case XVID_PLG_INFO :
641        case XVID_PLG_CREATE :
642        case XVID_PLG_DESTROY :
643        case XVID_PLG_BEFORE :
644           return 0;
645    
646        case XVID_PLG_AFTER :
647           {
648           xvid_plg_data_t * data = (xvid_plg_data_t*)param1;
649           printf("type=%i, quant=%i, length=%i\n", data->type, data->quant, data->length);
650           return 0;
651           }
652        }
653    
654        return XVID_ERR_FAIL;
655    }
656    
657    
658  #define FRAMERATE_INCR 1001  #define FRAMERATE_INCR 1001
659    
660  /* Initialize encoder for first use, pass all needed parameters to the codec */  /* Initialize encoder for first use, pass all needed parameters to the codec */
# Line 586  Line 662 
662  {  {
663          int xerr;          int xerr;
664    
665          XVID_INIT_PARAM xinit;      /* xvid_enc_plugin_t plugins[1]; */
         XVID_ENC_PARAM xparam;  
666    
667            xvid_gbl_init_t   xvid_gbl_init;
668            xvid_enc_create_t xvid_enc_create;
669    
670            /*------------------------------------------------------------------------
671             * XviD core initialization
672             *----------------------------------------------------------------------*/
673    
674            /* Set version -- version checking will done by xvidcore*/
675        memset(&xvid_gbl_init, 0, sizeof(xvid_gbl_init));
676            xvid_gbl_init.version = XVID_VERSION;
677    
678    
679            /* Do we have to enable ASM optimizations ? */
680          if(use_assembler) {          if(use_assembler) {
681    
682  #ifdef ARCH_IA64  #ifdef ARCH_IS_IA64
683                  xinit.cpu_flags = XVID_CPU_FORCE | XVID_CPU_IA64;                  xvid_gbl_init.cpu_flags = XVID_CPU_FORCE | XVID_CPU_IA64;
684  #else  #else
685                  xinit.cpu_flags = 0;                  xvid_gbl_init.cpu_flags = 0;
686  #endif  #endif
687          }          }
688          else {          else {
689                  xinit.cpu_flags = XVID_CPU_FORCE;                  xvid_gbl_init.cpu_flags = XVID_CPU_FORCE;
690          }          }
691    
692          xvid_init(NULL, 0, &xinit, NULL);          /* Initialize XviD core -- Should be done once per __process__ */
693            xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL);
694    
695          xparam.width = XDIM;          /*------------------------------------------------------------------------
696          xparam.height = YDIM;           * XviD encoder initialization
697          if ((ARG_FRAMERATE - (int)ARG_FRAMERATE) < SMALL_EPS)           *----------------------------------------------------------------------*/
698          {  
699                  xparam.fincr = 1;          /* Version again */
700                  xparam.fbase = (int)ARG_FRAMERATE;      memset(&xvid_enc_create, 0, sizeof(xvid_enc_create));
701          }          xvid_enc_create.version = XVID_VERSION;
702          else  
703          {          /* Width and Height of input frames */
704                  xparam.fincr = FRAMERATE_INCR;          xvid_enc_create.width = XDIM;
705                  xparam.fbase = (int)(FRAMERATE_INCR * ARG_FRAMERATE);          xvid_enc_create.height = YDIM;
706    
707        /* init plugins
708        plugins[0].func =  rawenc_debug;
709        plugins[0].param = NULL;
710        xvid_enc_create.num_plugins = 1;
711        xvid_enc_create.plugins = plugins; */
712    
713            /* No fancy thread tests */
714            xvid_enc_create.num_threads = 0;
715    
716            /* Frame rate - Do some quick float fps = fincr/fbase hack */
717            if ((ARG_FRAMERATE - (int)ARG_FRAMERATE) < SMALL_EPS) {
718                    xvid_enc_create.fincr = 1;
719                    xvid_enc_create.fbase = (int)ARG_FRAMERATE;
720            } else {
721                    xvid_enc_create.fincr = FRAMERATE_INCR;
722                    xvid_enc_create.fbase = (int)(FRAMERATE_INCR * ARG_FRAMERATE);
723          }          }
724          xparam.rc_reaction_delay_factor = 16;  
725      xparam.rc_averaging_period = 100;          /* Maximum key frame interval */
726      xparam.rc_buffer = 10;          xvid_enc_create.max_key_interval = (int)ARG_FRAMERATE*10;
727          xparam.rc_bitrate = ARG_BITRATE*1000;  
728          xparam.min_quantizer = ARG_MINQUANT;          /* Bframes settings */
729          xparam.max_quantizer = ARG_MAXQUANT;          xvid_enc_create.max_bframes = ARG_MAXBFRAMES;
730          xparam.max_key_interval = (int)ARG_FRAMERATE*10;          xvid_enc_create.bquant_ratio = ARG_BQRATIO;
731            xvid_enc_create.bquant_offset = ARG_BQOFFSET;
732    
733            /* Dropping ratio frame -- we don't need that */
734            xvid_enc_create.frame_drop_ratio = 0;
735    
736            /* Global encoder options */
737            xvid_enc_create.global = 0;
738        if (ARG_STATS) xvid_enc_create.global |= XVID_EXTRASTATS_ENABLE;
739        if (ARG_PACKED) xvid_enc_create.global |= XVID_PACKED;
740    
741          /* I use a small value here, since will not encode whole movies, but short clips */          /* I use a small value here, since will not encode whole movies, but short clips */
742            xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
743    
744          xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xparam, NULL);          /* Retrieve the encoder instance from the structure */
745          enc_handle=xparam.handle;          enc_handle = xvid_enc_create.handle;
746    
747          return xerr;          return(xerr);
748  }  }
749    
750  static int enc_stop()  static int enc_stop()
751  {  {
752          int xerr;          int xerr;
753    
754            /* Destroy the encoder instance */
755          xerr = xvid_encore(enc_handle, XVID_ENC_DESTROY, NULL, NULL);          xerr = xvid_encore(enc_handle, XVID_ENC_DESTROY, NULL, NULL);
         return xerr;  
756    
757            return(xerr);
758  }  }
759    
760  static int enc_main(unsigned char* image, unsigned char* bitstream,  static int enc_main(unsigned char* image,
761                                          int *streamlength, int* frametype)                                          unsigned char* bitstream,
762                        int * key,
763                                            int *stats_type,
764                        int *stats_quant,
765                        int *stats_length,
766                                            int stats[3])
767  {  {
768          int xerr;          int ret;
769    
770            xvid_enc_frame_t xvid_enc_frame;
771            xvid_enc_stats_t xvid_enc_stats;
772    
773            /* Version for the frame and the stats */
774        memset(&xvid_enc_frame, 0, sizeof(xvid_enc_frame));
775            xvid_enc_frame.version = XVID_VERSION;
776    
777        memset(&xvid_enc_stats, 0, sizeof(xvid_enc_stats));
778            xvid_enc_stats.version = XVID_VERSION;
779    
780            /* Bind output buffer */
781            xvid_enc_frame.bitstream = bitstream;
782            xvid_enc_frame.length = -1;
783    
784            /* Initialize input image fields */
785            xvid_enc_frame.input.plane[0]  = image;
786            xvid_enc_frame.input.csp       = XVID_CSP_I420;
787            xvid_enc_frame.input.stride[0] = XDIM;
788    
789          XVID_ENC_FRAME xframe;          /* Set up core's general features */
790          XVID_ENC_STATS xstats;          xvid_enc_frame.vol_flags = vol_presets[ARG_QUALITY];
791    
792          xframe.bitstream = bitstream;          /* Set up core's general features */
793          xframe.length = -1;     // this is written by the routine          xvid_enc_frame.vop_flags = vop_presets[ARG_QUALITY];
794    
795          xframe.image = image;          /* Frame type -- let core decide for us */
796          xframe.colorspace = XVID_CSP_YV12;      // defined in <xvid.h>          xvid_enc_frame.type   = XVID_TYPE_AUTO;
797    
798          xframe.intra = -1; // let the codec decide between I-frame (1) and P-frame (0)          /* Force the right quantizer */
799            xvid_enc_frame.quant  = ARG_QUANTI;
800            xvid_enc_frame.bquant = 0;
801    
802          xframe.quant = ARG_QUANTI;      // is quant != 0, use a fixed quant (and ignore bitrate)          /* Set up motion estimation flags */
803            xvid_enc_frame.motion = motion_presets[ARG_QUALITY];
804    
805          xframe.motion = motion_presets[ARG_QUALITY];          /* We don't use special matrices */
806          xframe.general = general_presets[ARG_QUALITY];          xvid_enc_frame.quant_intra_matrix = NULL;
807          xframe.quant_intra_matrix = xframe.quant_inter_matrix = NULL;          xvid_enc_frame.quant_inter_matrix = NULL;
808    
809          xerr = xvid_encore(enc_handle, XVID_ENC_ENCODE, &xframe, &xstats);          /* Encode the frame */
810            xvid_enc_frame.vop_flags |= (ARG_STATS)?XVID_EXTRASTATS:0;
811            ret = xvid_encore(enc_handle, XVID_ENC_ENCODE, &xvid_enc_frame, &xvid_enc_stats);
812    
813          /*      *key = (xvid_enc_frame.out_flags & XVID_KEYFRAME);
814           * This is statictical data, e.g. for 2-pass. If you are not          *stats_type = xvid_enc_stats.type;
815           * interested in any of this, you can use NULL instead of &xstats      *stats_quant = xvid_enc_stats.quant;
816           */      *stats_length = xvid_enc_stats.length;
817          *frametype = xframe.intra;          stats[0]   = xvid_enc_stats.sse_y;
818          *streamlength = xframe.length;          stats[1]   = xvid_enc_stats.sse_u;
819            stats[2]   = xvid_enc_stats.sse_v;
820    
821          return xerr;          return(ret);
822  }  }
Legend:
Removed from v.558  
changed lines
  Added in v.919
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4