贡献出LINUX MPEG4 DVR源代码给SIR,另外还包括一个可以跨平台运行的MPEG4 播放器

realtang

版权声明:
本代码版权属于本人，您可以在遵循GPL授权的条件下加以使用。
一.LINUX DVR源码

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <stdint.h>
   
5. #include <errno.h>
   
6. #include <fcntl.h>
   
7. #include <signal.h>
   
8. #include <sys/ioctl.h>
   
9. #include <sys/mman.h>
   
10. #include <linux/videodev.h>
    
11. #include "xvid.h"
    
12. #define FRAMERATE_INCR 1001
    
13. #define SMALL_EPS (1e-10)
    
14. #define VIDEO "/dev/video"
    
15. #define INDEX 0
    
16. #define IOCTL(fd, req, addr ) \
    
17. ((-1==ioctl(fd,req,addr))?(perror(#req),close(fd),exit(EXIT_FAILURE)):0)
    
18. 
    
19. static float ARG_FRAMERATE = 25.00f;
    
20. static int ARG_QUALITY = 4;
    
21. static int ARG_MAXKEYINTERVAL = 250;
    
22. static char * ARG_OUTPUTFILE= "out.m4u";
    
23. static FILE * fp = NULL;
    
24. static int done = 0;
    
25. static const int motion_presets[] = {
    
26.         /* quality 0 */
    
27.         0,
    
28. 
    
29.         /* quality 1 */
    
30.         XVID_ME_ADVANCEDDIAMOND16,
    
31. 
    
32.         /* quality 2 */
    
33.         XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16,
    
34. 
    
35.         /* quality 3 */
    
36.         XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16 |
    
37.         XVID_ME_ADVANCEDDIAMOND8 | XVID_ME_HALFPELREFINE8,
    
38. 
    
39.         /* quality 4 */
    
40.         XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16 |
    
41.         XVID_ME_ADVANCEDDIAMOND8 | XVID_ME_HALFPELREFINE8 |
    
42.         XVID_ME_CHROMA_PVOP | XVID_ME_CHROMA_BVOP,
    
43. 
    
44.         /* quality 5 */
    
45.         XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16 |
    
46.         XVID_ME_ADVANCEDDIAMOND8 | XVID_ME_HALFPELREFINE8 |
    
47.         XVID_ME_CHROMA_PVOP | XVID_ME_CHROMA_BVOP,
    
48. 
    
49.         /* quality 6 */
    
50.         XVID_ME_ADVANCEDDIAMOND16 | XVID_ME_HALFPELREFINE16 | XVID_ME_EXTSEARCH16 |
    
51.         XVID_ME_ADVANCEDDIAMOND8 | XVID_ME_HALFPELREFINE8 | XVID_ME_EXTSEARCH8 |
    
52.         XVID_ME_CHROMA_PVOP | XVID_ME_CHROMA_BVOP,
    
53. 
    
54. };
    
55. static const int vop_presets[] = {
    
56.         /* quality 0 */
    
57.         0,
    
58. 
    
59.         /* quality 1 */
    
60.         0,
    
61. 
    
62.         /* quality 2 */
    
63.         XVID_VOP_HALFPEL,
    
64. 
    
65.         /* quality 3 */
    
66.         XVID_VOP_HALFPEL | XVID_VOP_INTER4V,
    
67. 
    
68.         /* quality 4 */
    
69.         XVID_VOP_HALFPEL | XVID_VOP_INTER4V,
    
70. 
    
71.         /* quality 5 */
    
72.         XVID_VOP_HALFPEL | XVID_VOP_INTER4V |
    
73.         XVID_VOP_TRELLISQUANT,
    
74. 
    
75.         /* quality 6 */
    
76.         XVID_VOP_HALFPEL | XVID_VOP_INTER4V |
    
77.         XVID_VOP_TRELLISQUANT | XVID_VOP_HQACPRED,
    
78. 
    
79. };
    
80. 
    
81. static int XDIM=352,YDIM=288;
    
82. static use_assembler = 0;
    
83. static void *enc_handle = NULL;
    
84. 
    
85. static int enc_init(int use_assembler);
    
86. static int enc_main(unsigned char *image,
    
87.                                         unsigned char *bitstream,
    
88.                                         int *key,
    
89.                                         int *stats_type,
    
90.                                         int *stats_quant,
    
91.                                         int *stats_length,
    
92.                                         int stats[3]);
    
93. static int enc_stop();
    
94. //signal act method defination
    
95. static void clean(int signum)
    
96. {
    
97.     done=1;
    
98. }
    
99. int
    
100. main(int argc,char *argv[])
     
101. {
     
102.     //register SIGINT action method ,to save the m4u file
     
103.     signal(SIGINT,clean);
     
104.     int fd;
     
105.     struct v4l2_capability cap;   
     
106.     struct v4l2_format format;
     
107.     struct v4l2_requestbuffers reqbuf;
     
108.     struct v4l2_buffer buffer;
     
109.     struct v4l2_input input;
     
110.     int index=0,i;
     
111.         for (i=1; i< argc; i++) {
     
112. 
     
113.                 if (strcmp("-asm", argv[i]) == 0 ) {
     
114.                         use_assembler = 1;
     
115.                 }else if(strcmp("-f", argv[i]) == 0 && i < argc -1){
     
116.             i++;
     
117.             ARG_OUTPUTFILE = argv[i];
     
118.         }else if(strcmp("-i", argv[i]) == 0 && i < argc -1){
     
119.             i++;
     
120.             index = atoi(argv[i]);
     
121.         } else if(strcmp("-w", argv[i]) == 0 && i < argc -1){
     
122.             i++;
     
123.             XDIM = atoi(argv[i]);
     
124.         } else if(strcmp("-h", argv[i]) == 0 && i < argc -1){
     
125.             i++;
     
126.             YDIM = atoi(argv[i]);
     
127.         }
     
128.         }
     
129.    
     
130.         //init capture card
     
131.    
     
132.     fd = open(VIDEO,O_RDWR);
     
133.     if(fd<0)
     
134.     {
     
135.         perror("Can't open /dev/video device");
     
136.         exit(errno);
     
137.     }
     
138.     //if card can't support video capture and by means of steamio,exit
     
139.    
     
140.     IOCTL(fd, VIDIOC_QUERYCAP, &cap);
     
141.     if ( !(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)
     
142.          &&!(cap.capabilities & V4L2_CAP_STREAMING))
     
143.     {
     
144.         fprintf(stderr, "Couldn't use the card \n");
     
145.         exit(3);
     
146.     }               
     
147.    
     
148.         //query input and select the desired input
     
149.        
     
150.         IOCTL(fd, VIDIOC_G_INPUT, &index);
     
151.     input.index = index;
     
152.     IOCTL(fd, VIDIOC_ENUMINPUT, &input);
     
153.     printf ("Current input: Index %i,Name %s\n", index,input.name);   
     
154.     for(i=0;;i++)
     
155.     {
     
156.         if(i!=index)
     
157.         {
     
158.             input.index = i;
     
159.             if(-1==ioctl(fd, VIDIOC_ENUMINPUT, &input))
     
160.                 break;
     
161.             else
     
162.                 printf ("Other input: Index %i,Name %s\n",i,input.name);
     
163.         }
     
164.     }
     
165.         IOCTL(fd, VIDIOC_S_INPUT, &index);
     
166.        
     
167.     //get current video format,set the desired format
     
168.    
     
169.     format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
170.     IOCTL(fd,VIDIOC_G_FMT,&format);
     
171.     format.fmt.pix.width = XDIM;
     
172.     format.fmt.pix.height = YDIM;
     
173.     format.fmt.pix.pixelformat = V4L2_PIX_FMT_YVU420;
     
174.     format.fmt.pix.field = V4L2_FIELD_ANY;//V4L2_FIELD_INTERLACED
     
175.    
     
176.         IOCTL(fd,VIDIOC_S_FMT,&format);
     
177. 
     
178.     XDIM = format.fmt.pix.width;
     
179.     printf("Gotten width %d\n",XDIM);
     
180.     YDIM = format.fmt.pix.height;
     
181.     printf("Gotten height %d\n",YDIM);
     
182.    
     
183.         //let driver get the buffers
     
184.    
     
185.     reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
186.     reqbuf.memory = V4L2_MEMORY_MMAP;
     
187.     reqbuf.count = 4;
     
188.     IOCTL(fd,VIDIOC_REQBUFS,&reqbuf );
     
189.     if (reqbuf.count < 4)
     
190.     {
     
191.        printf ("Not enough buffer memory for driver\n");
     
192.        exit (5);
     
193.     }
     
194. 
     
195. //mmap the driver's buffer to application address
     
196.    
     
197.     //create relative buffers struct to be used by mmap
     
198. 
     
199.     struct
     
200.     {
     
201.         void * start;
     
202.         size_t length;
     
203.     } buffers[reqbuf.count];
     
204.    
     
205.         //mmap the driver's kernel buffer into application
     
206.        
     
207.         for (i=0;i<reqbuf.count;i++)
     
208.     {
     
209.         buffer.type = reqbuf.type;
     
210.         buffer.index =i ;
     
211.         
     
212.         //query the status of one buffer ,mmap the driver buffer
     
213.         
     
214.         IOCTL(fd,VIDIOC_QUERYBUF,&buffer);
     
215.         buffers[i].length = buffer.length;
     
216.         buffers[i].start = mmap (NULL,buffer.length,
     
217.                                  PROT_READ | PROT_WRITE,
     
218.                                  MAP_SHARED,
     
219.                                  fd,buffer.m.offset);
     
220.         if (buffers[i].start == MAP_FAILED)
     
221.         {
     
222.            close(fd);
     
223.            perror ("mmap");
     
224.            exit(errno);
     
225.         }
     
226.     }
     
227.     //begin video capture
     
228.    
     
229.     IOCTL(fd,VIDIOC_STREAMON,&reqbuf.type);         
     
230.    
     
231.     //enqueue all driver buffers
     
232.     for (i=0;i<reqbuf.count;i++)
     
233.     {        
     
234.         buffer.type = reqbuf.type;
     
235.         buffer.index = i;
     
236.         IOCTL(fd,VIDIOC_QUERYBUF, &buffer);
     
237.         IOCTL(fd,VIDIOC_QBUF,&buffer);
     
238.     }
     
239.     //init xvid
     
240.    
     
241.     int result;
     
242.     result = enc_init(1);
     
243.     if(result!=0)
     
244.     {
     
245.         fprintf(stderr, "Encore INIT problem, return value %d\n", result);
     
246.         goto clean_all;           
     
247.     }
     
248.    
     
249.     //get mem of mpg4 frame
     
250.    
     
251.     uint8_t *mp4_buffer = NULL;   
     
252.         mp4_buffer = (unsigned char *) malloc(XDIM*YDIM);
     
253.         if (mp4_buffer==NULL)
     
254.     {
     
255.         fprintf(stderr,"malloc error");
     
256.         goto clean_all;
     
257.     }
     
258.            int key;
     
259.         int stats_type;
     
260.         int stats_quant;
     
261.         int stats_length;
     
262.     int sse[3];            
     
263.    
     
264.         //create store mp4 file
     
265.        
     
266.         fp= fopen(ARG_OUTPUTFILE, "rb");
     
267.     if (fp== NULL) {
     
268.             perror("Error opening output file.");
     
269.                 exit(-1);
     
270.     }                
     
271. 
     
272. //main loop ,frame capture,compressed
     
273. 
     
274.     i = 0;
     
275.     int outbytes,m4v_size;
     
276.     while(!done)
     
277.     {
     
278.         //dequeue one frame
     
279.             
     
280.         buffer.type = reqbuf.type;
     
281.         buffer.index = i;
     
282.         IOCTL(fd, VIDIOC_QUERYBUF, &buffer);
     
283.         IOCTL(fd, VIDIOC_DQBUF, &buffer);
     
284.         /*debug info
     
285.         printf("current frame's unix time seconds :%d\n",buffer.timestamp.tv_sec);
     
286.         printf("current frame's unix time mcicoseconds :%d\n",buffer.timestamp.tv_usec);
     
287.         */
     
288.       
     
289.         //compress a frame
     
290.         
     
291.         m4v_size = enc_main((uint8_t *)buffers[i].start,
     
292.                              mp4_buffer+16,
     
293.                              &key, &stats_type,&stats_quant, &stats_length, sse);
     
294.                
     
295.                 //store into output file
     
296.                 outbytes = fwrite(mp4_buffer, 1, m4v_size, fp);
     
297.                 if(outbytes != m4v_size)
     
298.                 {
     
299.                     fprintf(stderr,"Error writing the m4u file\n");
     
300.                     exit(7);
     
301.                 }
     
302.                
     
303.                 //enqueue one frame
     
304.             
     
305.         buffer.type = reqbuf.type;
     
306.         buffer.index = i;
     
307.         IOCTL(fd, VIDIOC_QUERYBUF, &buffer );
     
308.         IOCTL(fd, VIDIOC_QBUF, &buffer );
     
309.         i++;            
     
310.         if( i >= reqbuf.count )
     
311.             i = 0;
     
312.     }
     
313. clean_all:
     
314.     fclose(fp);
     
315.         enc_stop();   
     
316.     //stop capture
     
317.     IOCTL(fd, VIDIOC_STREAMOFF, &reqbuf.type );
     
318.     //unmmap the apllication buffer
     
319.     for (i=0;i<reqbuf.count;i++)
     
320.         munmap (buffers[i].start,buffers[i].length);   
     
321.     //release the dynamic mem
     
322.     close(fd);
     
323.         return 0;
     
324. }
     
325. 
     
326. int
     
327. enc_init(int use_assembler)
     
328. {
     
329.         int xerr;
     
330.         //xvid_plugin_cbr_t cbr;
     
331.     xvid_plugin_single_t single;
     
332.         xvid_plugin_2pass1_t rc2pass1;
     
333.         xvid_plugin_2pass2_t rc2pass2;
     
334.         //xvid_plugin_fixed_t rcfixed;
     
335.         xvid_enc_plugin_t plugins[7];
     
336.         xvid_gbl_init_t xvid_gbl_init;
     
337.         xvid_enc_create_t xvid_enc_create;
     
338. 
     
339.         /*------------------------------------------------------------------------
     
340.          * XviD core initialization
     
341.          *----------------------------------------------------------------------*/
     
342. 
     
343.         /* Set version -- version checking will done by xvidcore */
     
344.         memset(&xvid_gbl_init, 0, sizeof(xvid_gbl_init));
     
345.         xvid_gbl_init.version = XVID_VERSION;
     
346.     xvid_gbl_init.debug = 0;
     
347. 
     
348. 
     
349.         /* Do we have to enable ASM optimizations ? */
     
350.         if (use_assembler) {
     
351.                 xvid_gbl_init.cpu_flags = 0;
     
352.         }
     
353. 
     
354.         /* Initialize XviD core -- Should be done once per __process__ */
     
355.         xvid_global(NULL, XVID_GBL_INIT, &xvid_gbl_init, NULL);
     
356. 
     
357.         /*------------------------------------------------------------------------
     
358.          * XviD encoder initialization
     
359.          *----------------------------------------------------------------------*/
     
360. 
     
361.         /* Version again */
     
362.         memset(&xvid_enc_create, 0, sizeof(xvid_enc_create));
     
363.         xvid_enc_create.version = XVID_VERSION;
     
364. 
     
365.         /* Width and Height of input frames */
     
366.         xvid_enc_create.width = XDIM;
     
367.         xvid_enc_create.height = YDIM;
     
368.         xvid_enc_create.profile = XVID_PROFILE_S_L3;
     
369. 
     
370.         /* init plugins  */
     
371.     xvid_enc_create.zones = NULL;
     
372.     xvid_enc_create.num_zones = 0;
     
373. 
     
374.         xvid_enc_create.plugins = NULL;
     
375.         xvid_enc_create.num_plugins = 0;
     
376. 
     
377.         /* No fancy thread tests */
     
378.         xvid_enc_create.num_threads = 0;
     
379. 
     
380.         /* Frame rate - Do some quick float fps = fincr/fbase hack */
     
381.         if ((ARG_FRAMERATE - (int) ARG_FRAMERATE) < SMALL_EPS) {
     
382.                 xvid_enc_create.fincr = 1;
     
383.                 xvid_enc_create.fbase = (int) ARG_FRAMERATE;
     
384.         } else {
     
385.                 xvid_enc_create.fincr = FRAMERATE_INCR;
     
386.                 xvid_enc_create.fbase = (int) (FRAMERATE_INCR * ARG_FRAMERATE);
     
387.         }
     
388. 
     
389.         /* Maximum key frame interval */
     
390.     if (ARG_MAXKEYINTERVAL > 0) {
     
391.         xvid_enc_create.max_key_interval = ARG_MAXKEYINTERVAL;
     
392.     }else {
     
393.             xvid_enc_create.max_key_interval = (int) ARG_FRAMERATE *10;
     
394.     }
     
395. 
     
396.         /* Bframes settings */
     
397.         xvid_enc_create.max_bframes = 0;
     
398.         xvid_enc_create.bquant_ratio = 150;
     
399.         xvid_enc_create.bquant_offset = 100;
     
400. 
     
401.         /* Dropping ratio frame -- we don't need that */
     
402.         xvid_enc_create.frame_drop_ratio = 0;
     
403. 
     
404.         /* Global encoder options */
     
405.         xvid_enc_create.global = 0;
     
406. 
     
407.         /* I use a small value here, since will not encode whole movies, but short clips */
     
408.         xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
     
409. 
     
410.         /* Retrieve the encoder instance from the structure */
     
411.         enc_handle = xvid_enc_create.handle;
     
412. 
     
413.         return (xerr);
     
414. }
     
415. 
     
416. int
     
417. enc_main(unsigned char *image,
     
418.                  unsigned char *bitstream,
     
419.                  int *key,
     
420.                  int *stats_type,
     
421.                  int *stats_quant,
     
422.                  int *stats_length,
     
423.                  int sse[3])
     
424. {
     
425.         int ret;
     
426. 
     
427.         xvid_enc_frame_t xvid_enc_frame;
     
428.         xvid_enc_stats_t xvid_enc_stats;
     
429. 
     
430.         /* Version for the frame and the stats */
     
431.         memset(&xvid_enc_frame, 0, sizeof(xvid_enc_frame));
     
432.         xvid_enc_frame.version = XVID_VERSION;
     
433. 
     
434.         memset(&xvid_enc_stats, 0, sizeof(xvid_enc_stats));
     
435.         xvid_enc_stats.version = XVID_VERSION;
     
436. 
     
437.         /* Bind output buffer */
     
438.         xvid_enc_frame.bitstream = bitstream;
     
439.         xvid_enc_frame.length = -1;
     
440. 
     
441.         /* Initialize input image fields */
     
442.         if (image) {
     
443.                 xvid_enc_frame.input.plane[0] = image;
     
444.                 xvid_enc_frame.input.csp = XVID_CSP_I420;
     
445.                 xvid_enc_frame.input.stride[0] = XDIM;
     
446.         } else {
     
447.                 xvid_enc_frame.input.csp = XVID_CSP_NULL;
     
448.         }
     
449. 
     
450.         /* Set up core's general features */
     
451.         xvid_enc_frame.vol_flags = 0;
     
452. 
     
453.         /* Set up core's general features */
     
454.         xvid_enc_frame.vop_flags = vop_presets[ARG_QUALITY];
     
455. 
     
456.         /* Frame type -- let core decide for us */
     
457.         xvid_enc_frame.type = XVID_TYPE_AUTO;
     
458. 
     
459.         /* Force the right quantizer -- It is internally managed by RC plugins */
     
460.         xvid_enc_frame.quant = 3;
     
461. 
     
462.         /* Set up motion estimation flags */
     
463.         xvid_enc_frame.motion = motion_presets[ARG_QUALITY];
     
464. 
     
465.         /* We don't use special matrices */
     
466.         xvid_enc_frame.quant_intra_matrix = NULL;
     
467.         xvid_enc_frame.quant_inter_matrix = NULL;
     
468. 
     
469.         /* Encode the frame */
     
470.         ret = xvid_encore(enc_handle, XVID_ENC_ENCODE, &xvid_enc_frame,
     
471.                                           &xvid_enc_stats);
     
472. 
     
473.         *key = (xvid_enc_frame.out_flags & XVID_KEYFRAME);
     
474.         *stats_type = xvid_enc_stats.type;
     
475.         *stats_quant = xvid_enc_stats.quant;
     
476.         *stats_length = xvid_enc_stats.length;
     
477.         sse[0] = xvid_enc_stats.sse_y;
     
478.         sse[1] = xvid_enc_stats.sse_u;
     
479.         sse[2] = xvid_enc_stats.sse_v;
     
480.         return (ret);
     
481. }
     
482. 
     
483. int
     
484. enc_stop()
     
485. {
     
486.         int xerr;
     
487. 
     
488.         /* Destroy the encoder instance */
     
489.         xerr = xvid_encore(enc_handle, XVID_ENC_DESTROY, NULL, NULL);
     
490. 
     
491.         return (xerr);
     
492. }                                                                          
     
493.                                                  
     
494. 
     

复制代码

realtang

下面是基于SDL的跨平台MPEG4播放器源代码,支持硬件YUV加速

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

复制代码

Linux_Lyb

好东西，谢谢~！

kj501

不错，加精！

dyte200

楼主请问怎样编译？

JBug

非常不错, 有空看看

MatthewGong

楼主能做一个包吗？
方便大家下载与编译。

其需要xvid与SDL开发库？

realtang

Post by MatthewGong
楼主能做一个包吗？
方便大家下载与编译。

其需要xvid与SDL开发库？

没错，需要XVID与SDL开发库包。

dyte200

xvid可以解压什么样的格式？和ffmpeg的关系？

# file bbb.m4v
bbb.m4v: MPEG sequence, v4, video, simple @ L1
# file aaa.mpeg
aaa.mpeg: MPEG sequence, v1, system multiplex
同样内容的两文件，结果
#ls -l bbb.m4v aaa.mpeg
-rw-r--r--  1 root root 408K 2006-03-04 15:12 aaa.mpeg
-rw-r--r--  1 root root 419K 2006-03-09 11:49 bbb.m4v
用m4v格式大小反而变大了？

dyte200

楼主的播放器代码是在xvid源码包中的xvid_decraw.c代码基础上加SDL显示得到的？