ffmpeg 0.6.3 能用的tutorial06

编译命令：
gcc -o tutorial04 tutorial04.c -lavformat -lavcodec -lz -lm -lswscale `sdl-config --cflags --libs`

点击(此处)折叠或打开

1. // tutorial06.c
   
2. // A pedagogical video player that really 
   
3. //
   
4. // Code based on FFplay, Copyright (c) 2003 Fabrice Bellard, 
   
5. // and a tutorial by Martin Bohme (boehme@inb.uni-luebeckREMOVETHIS.de)
   
6. // Tested on Gentoo, CVS version 5/01/07 compiled with GCC 4.1.1
   
7. // Use
   
8. //
   
9. // gcc -o tutorial02 tutorial02.c -lavformat -lavcodec -lz -lm `sdl-config --cflags --libs`
   
10. // to build (assuming libavformat and libavcodec are correctly installed, 
    
11. // and assuming you have sdl-config. Please refer to SDL docs for your installation.)
    
12. //
    
13. // Run using
    
14. // tutorial06 myvideofile.mpg
    
15. //
    
16. // to play the video.
    
17. 
    
18. #include <libavcodec/avcodec.h> 
    
19. #include <libavformat/avformat.h> 
    
20. #include <libswscale/swscale.h> 
    
21. 
    
22. #include <SDL.h>
    
23. #include <SDL_thread.h>
    
24. 
    
25. #ifdef __MINGW32__
    
26. #undef main /* Prevents SDL from overriding main() */
    
27. #endif
    
28. 
    
29. #include <stdio.h>
    
30. #include <math.h>
    
31. 
    
32. #define SDL_AUDIO_BUFFER_SIZE 1024
    
33. 
    
34. #define MAX_AUDIOQ_SIZE (5 * 16 * 1024)
    
35. #define MAX_VIDEOQ_SIZE (5 * 256 * 1024)
    
36. 
    
37. #define AV_SYNC_THRESHOLD 0.01
    
38. #define AV_NOSYNC_THRESHOLD 10.0
    
39. 
    
40. #define SAMPLE_CORRECTION_PERCENT_MAX 10
    
41. #define AUDIO_DIFF_AVG_NB 20
    
42. 
    
43. #define FF_ALLOC_EVENT (SDL_USEREVENT)
    
44. #define FF_REFRESH_EVENT (SDL_USEREVENT + 1)
    
45. #define FF_QUIT_EVENT (SDL_USEREVENT + 2)
    
46. 
    
47. #define VIDEO_PICTURE_QUEUE_SIZE 1
    
48. 
    
49. #define DEFAULT_AV_SYNC_TYPE AV_SYNC_VIDEO_MASTER
    
50. 
    
51. typedef struct PacketQueue {
    
52.   AVPacketList *first_pkt, *last_pkt;
    
53.   int nb_packets;
    
54.   int size;
    
55.   SDL_mutex *mutex;
    
56.   SDL_cond *cond;
    
57. } PacketQueue;
    
58. 
    
59. 
    
60. typedef struct VideoPicture {
    
61.   SDL_Overlay *bmp;
    
62.   int width, height; /* source height & width */
    
63.   int allocated;
    
64.   double pts;
    
65. } VideoPicture;
    
66. 
    
67. typedef struct VideoState {
    
68. 
    
69.   AVFormatContext *pFormatCtx;
    
70.   int videoStream, audioStream;
    
71. 
    
72.   int av_sync_type;
    
73.   double external_clock; /* external clock base */
    
74.   int64_t external_clock_time;
    
75. 
    
76.   double audio_clock;
    
77.   AVStream *audio_st;
    
78.   PacketQueue audioq;
    
79.   uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];
    
80.   unsigned int audio_buf_size;
    
81.   unsigned int audio_buf_index;
    
82.   AVPacket audio_pkt;
    
83.   uint8_t *audio_pkt_data;
    
84.   int audio_pkt_size;
    
85.   int audio_hw_buf_size; 
    
86.   double audio_diff_cum; /* used for AV difference average computation */
    
87.   double audio_diff_avg_coef;
    
88.   double audio_diff_threshold;
    
89.   int audio_diff_avg_count;
    
90.   double frame_timer;
    
91.   double frame_last_pts;
    
92.   double frame_last_delay;
    
93.   double video_clock; ///<pts of last decoded frame / predicted pts of next decoded frame
    
94.   double video_current_pts; ///<current displayed pts (different from video_clock if frame fifos are used)
    
95.   int64_t video_current_pts_time; ///<time (av_gettime) at which we updated video_current_pts - used to have running video pts
    
96.   AVStream *video_st;
    
97.   PacketQueue videoq;
    
98. 
    
99.   VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];
    
100.   int pictq_size, pictq_rindex, pictq_windex;
     
101.   SDL_mutex *pictq_mutex;
     
102.   SDL_cond *pictq_cond;
     
103.   
     
104.   SDL_Thread *parse_tid;
     
105.   SDL_Thread *video_tid;
     
106. 
     
107.   char filename[1024];
     
108.   int quit;
     
109.   struct SwsContext *img_convert_ctx; 
     
110. } VideoState;
     
111. 
     
112. enum {
     
113.   AV_SYNC_AUDIO_MASTER,
     
114.   AV_SYNC_VIDEO_MASTER,
     
115.   AV_SYNC_EXTERNAL_MASTER,
     
116. };
     
117. 
     
118. SDL_Surface *screen;
     
119. 
     
120. /* Since we only have one decoding thread, the Big Struct
     
121.    can be global in case we need it. */
     
122. VideoState *global_video_state;
     
123. 
     
124. void packet_queue_init(PacketQueue *q) {
     
125.   memset(q, 0, sizeof(PacketQueue));
     
126.   q->mutex = SDL_CreateMutex();
     
127.   q->cond = SDL_CreateCond();
     
128. }
     
129. int packet_queue_put(PacketQueue *q, AVPacket *pkt) {
     
130. 
     
131.   AVPacketList *pkt1;
     
132.   if(av_dup_packet(pkt) < 0) {
     
133.     return -1;
     
134.   }
     
135.   pkt1 = av_malloc(sizeof(AVPacketList));
     
136.   if (!pkt1)
     
137.     return -1;
     
138.   pkt1->pkt = *pkt;
     
139.   pkt1->next = NULL;
     
140.   
     
141.   SDL_LockMutex(q->mutex);
     
142. 
     
143.   if (!q->last_pkt)
     
144.     q->first_pkt = pkt1;
     
145.   else
     
146.     q->last_pkt->next = pkt1;
     
147.   q->last_pkt = pkt1;
     
148.   q->nb_packets++;
     
149.   q->size += pkt1->pkt.size;
     
150.   SDL_CondSignal(q->cond);
     
151.   
     
152.   SDL_UnlockMutex(q->mutex);
     
153.   return 0;
     
154. }
     
155. static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
     
156. {
     
157.   AVPacketList *pkt1;
     
158.   int ret;
     
159. 
     
160.   SDL_LockMutex(q->mutex);
     
161.   
     
162.   for(;;) {
     
163.     
     
164.     if(global_video_state->quit) {
     
165.       ret = -1;
     
166.       break;
     
167.     }
     
168. 
     
169.     pkt1 = q->first_pkt;
     
170.     if (pkt1) {
     
171.       q->first_pkt = pkt1->next;
     
172.       if (!q->first_pkt)
     
173.     q->last_pkt = NULL;
     
174.       q->nb_packets--;
     
175.       q->size -= pkt1->pkt.size;
     
176.       *pkt = pkt1->pkt;
     
177.       av_free(pkt1);
     
178.       ret = 1;
     
179.       break;
     
180.     } else if (!block) {
     
181.       ret = 0;
     
182.       break;
     
183.     } else {
     
184.       SDL_CondWait(q->cond, q->mutex);
     
185.     }
     
186.   }
     
187.   SDL_UnlockMutex(q->mutex);
     
188.   return ret;
     
189. }
     
190. double get_audio_clock(VideoState *is) {
     
191.   double pts;
     
192.   int hw_buf_size, bytes_per_sec, n;
     
193. 
     
194.   pts = is->audio_clock; /* maintained in the audio thread */
     
195.   hw_buf_size = is->audio_buf_size - is->audio_buf_index;
     
196.   bytes_per_sec = 0;
     
197.   n = is->audio_st->codec->channels * 2;
     
198.   if(is->audio_st) {
     
199.     bytes_per_sec = is->audio_st->codec->sample_rate * n;
     
200.   }
     
201.   if(bytes_per_sec) {
     
202.     pts -= (double)hw_buf_size / bytes_per_sec;
     
203.   }
     
204.   return pts;
     
205. }
     
206. double get_video_clock(VideoState *is) {
     
207.   double delta;
     
208. 
     
209.   delta = (av_gettime() - is->video_current_pts_time) / 1000000.0;
     
210.   return is->video_current_pts + delta;
     
211. }
     
212. double get_external_clock(VideoState *is) {
     
213.   return av_gettime() / 1000000.0;
     
214. }
     
215. 
     
216. double get_master_clock(VideoState *is) {
     
217.   if(is->av_sync_type == AV_SYNC_VIDEO_MASTER) {
     
218.     return get_video_clock(is);
     
219.   } else if(is->av_sync_type == AV_SYNC_AUDIO_MASTER) {
     
220.     return get_audio_clock(is);
     
221.   } else {
     
222.     return get_external_clock(is);
     
223.   }
     
224. }
     
225. /* Add or subtract samples to get a better sync, return new
     
226.    audio buffer size */
     
227. int synchronize_audio(VideoState *is, short *samples,
     
228.          int samples_size, double pts) {
     
229.   int n;
     
230.   double ref_clock;
     
231. 
     
232.   n = 2 * is->audio_st->codec->channels;
     
233.   
     
234.   if(is->av_sync_type != AV_SYNC_AUDIO_MASTER) {
     
235.     double diff, avg_diff;
     
236.     int wanted_size, min_size, max_size, nb_samples;
     
237.     
     
238.     ref_clock = get_master_clock(is);
     
239.     diff = get_audio_clock(is) - ref_clock;
     
240. 
     
241.     if(diff < AV_NOSYNC_THRESHOLD) {
     
242.       // accumulate the diffs
     
243.       is->audio_diff_cum = diff + is->audio_diff_avg_coef
     
244.     * is->audio_diff_cum;
     
245.       if(is->audio_diff_avg_count < AUDIO_DIFF_AVG_NB) {
     
246.     is->audio_diff_avg_count++;
     
247.       } else {
     
248.     avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
     
249.     if(fabs(avg_diff) >= is->audio_diff_threshold) {
     
250.      wanted_size = samples_size + ((int)(diff * is->audio_st->codec->sample_rate) * n);
     
251.      min_size = samples_size * ((100 - SAMPLE_CORRECTION_PERCENT_MAX) / 100);
     
252.      max_size = samples_size * ((100 + SAMPLE_CORRECTION_PERCENT_MAX) / 100);
     
253.      if(wanted_size < min_size) {
     
254.      wanted_size = min_size;
     
255.      } else if (wanted_size > max_size) {
     
256.      wanted_size = max_size;
     
257.      }
     
258.      if(wanted_size < samples_size) {
     
259.      /* remove samples */
     
260.      samples_size = wanted_size;
     
261.      } else if(wanted_size > samples_size) {
     
262.      uint8_t *samples_end, *q;
     
263.      int nb;
     
264. 
     
265.      /* add samples by copying final sample*/
     
266.      nb = (samples_size - wanted_size);
     
267.      samples_end = (uint8_t *)samples + samples_size - n;
     
268.      q = samples_end + n;
     
269.      while(nb > 0) {
     
270.      memcpy(q, samples_end, n);
     
271.      q += n;
     
272.      nb -= n;
     
273.      }
     
274.      samples_size = wanted_size;
     
275.      }
     
276.     }
     
277.       }
     
278.     } else {
     
279.       /* difference is TOO big; reset diff stuff */
     
280.       is->audio_diff_avg_count = 0;
     
281.       is->audio_diff_cum = 0;
     
282.     }
     
283.   }
     
284.   return samples_size;
     
285. }
     
286. 
     
287. int audio_decode_frame(VideoState *is, uint8_t *audio_buf, int buf_size, double *pts_ptr) {
     
288. 
     
289.   int len1, data_size, n;
     
290.   AVPacket *pkt = &is->audio_pkt;
     
291.   double pts;
     
292. 
     
293.   for(;;) {
     
294.     while(is->audio_pkt_size > 0) {
     
295.       data_size = buf_size;
     
296.       len1 = avcodec_decode_audio2(is->audio_st->codec, 
     
297.                  (int16_t *)audio_buf, &data_size, 
     
298.                  is->audio_pkt_data, is->audio_pkt_size);
     
299.       if(len1 < 0) {
     
300.     /* if error, skip frame */
     
301.     is->audio_pkt_size = 0;
     
302.     break;
     
303.       }
     
304.       is->audio_pkt_data += len1;
     
305.       is->audio_pkt_size -= len1;
     
306.       if(data_size <= 0) {
     
307.     /* No data yet, get more frames */
     
308.     continue;
     
309.       }
     
310.       pts = is->audio_clock;
     
311.       *pts_ptr = pts;
     
312.       n = 2 * is->audio_st->codec->channels;
     
313.       is->audio_clock += (double)data_size /
     
314.     (double)(n * is->audio_st->codec->sample_rate);
     
315. 
     
316.       /* We have data, return it and come back for more later */
     
317.       return data_size;
     
318.     }
     
319.     if(pkt->data)
     
320.       av_free_packet(pkt);
     
321. 
     
322.     if(is->quit) {
     
323.       return -1;
     
324.     }
     
325.     /* next packet */
     
326.     if(packet_queue_get(&is->audioq, pkt, 1) < 0) {
     
327.       return -1;
     
328.     }
     
329.     is->audio_pkt_data = pkt->data;
     
330.     is->audio_pkt_size = pkt->size;
     
331.     /* if update, update the audio clock w/pts */
     
332.     if(pkt->pts != AV_NOPTS_VALUE) {
     
333.       is->audio_clock = av_q2d(is->audio_st->time_base)*pkt->pts;
     
334.     }
     
335.   }
     
336. }
     
337. 
     
338. void audio_callback(void *userdata, Uint8 *stream, int len) {
     
339. 
     
340.   VideoState *is = (VideoState *)userdata;
     
341.   int len1, audio_size;
     
342.   double pts;
     
343. 
     
344.   while(len > 0) {
     
345.     if(is->audio_buf_index >= is->audio_buf_size) {
     
346.       /* We have already sent all our data; get more */
     
347.       audio_size = audio_decode_frame(is, is->audio_buf, sizeof(is->audio_buf), &pts);
     
348.       if(audio_size < 0) {
     
349.     /* If error, output silence */
     
350.     is->audio_buf_size = 1024;
     
351.     memset(is->audio_buf, 0, is->audio_buf_size);
     
352.       } else {
     
353.     audio_size = synchronize_audio(is, (int16_t *)is->audio_buf,
     
354.                  audio_size, pts);
     
355.     is->audio_buf_size = audio_size;
     
356.       }
     
357.       is->audio_buf_index = 0;
     
358.     }
     
359.     len1 = is->audio_buf_size - is->audio_buf_index;
     
360.     if(len1 > len)
     
361.       len1 = len;
     
362.     memcpy(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1);
     
363.     len -= len1;
     
364.     stream += len1;
     
365.     is->audio_buf_index += len1;
     
366.   }
     
367. }
     
368. 
     
369. static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) {
     
370.   SDL_Event event;
     
371.   event.type = FF_REFRESH_EVENT;
     
372.   event.user.data1 = opaque;
     
373.   SDL_PushEvent(&event);
     
374.   return 0; /* 0 means stop timer */
     
375. }
     
376. 
     
377. /* schedule a video refresh in 'delay' ms */
     
378. static void schedule_refresh(VideoState *is, int delay) {
     
379.   SDL_AddTimer(delay, sdl_refresh_timer_cb, is);
     
380. }
     
381. 
     
382. void video_display(VideoState *is) {
     
383. 
     
384.   SDL_Rect rect;
     
385.   VideoPicture *vp;
     
386.   AVPicture pict;
     
387.   float aspect_ratio;
     
388.   int w, h, x, y;
     
389.   int i;
     
390. 
     
391.   vp = &is->pictq[is->pictq_rindex];
     
392.   if(vp->bmp) {
     
393.     if(is->video_st->codec->sample_aspect_ratio.num == 0) {
     
394.       aspect_ratio = 0;
     
395.     } else {
     
396.       aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio) *
     
397.     is->video_st->codec->width / is->video_st->codec->height;
     
398.     }
     
399.     if(aspect_ratio <= 0.0) {
     
400.       aspect_ratio = (float)is->video_st->codec->width /
     
401.     (float)is->video_st->codec->height;
     
402.     }
     
403.     h = screen->h;
     
404.     w = ((int)rint(h * aspect_ratio)) & -3;
     
405.     if(w > screen->w) {
     
406.       w = screen->w;
     
407.       h = ((int)rint(w / aspect_ratio)) & -3;
     
408.     }
     
409.     x = (screen->w - w) / 2;
     
410.     y = (screen->h - h) / 2;
     
411.     
     
412.     rect.x = x;
     
413.     rect.y = y;
     
414.     rect.w = w;
     
415.     rect.h = h;
     
416.     SDL_DisplayYUVOverlay(vp->bmp, &rect);
     
417.   }
     
418. }
     
419. 
     
420. void video_refresh_timer(void *userdata) {
     
421. 
     
422.   VideoState *is = (VideoState *)userdata;
     
423.   VideoPicture *vp;
     
424.   double actual_delay, delay, sync_threshold, ref_clock, diff;
     
425.   
     
426.   if(is->video_st) {
     
427.     if(is->pictq_size == 0) {
     
428.       schedule_refresh(is, 1);
     
429.     } else {
     
430.       vp = &is->pictq[is->pictq_rindex];
     
431. 
     
432.       is->video_current_pts = vp->pts;
     
433.       is->video_current_pts_time = av_gettime();
     
434. 
     
435.       delay = vp->pts - is->frame_last_pts; /* the pts from last time */
     
436.       if(delay <= 0 || delay >= 1.0) {
     
437.     /* if incorrect delay, use previous one */
     
438.     delay = is->frame_last_delay;
     
439.       }
     
440.       /* save for next time */
     
441.       is->frame_last_delay = delay;
     
442.       is->frame_last_pts = vp->pts;
     
443. 
     
444.       /* update delay to sync to audio if not master source */
     
445.       if(is->av_sync_type != AV_SYNC_VIDEO_MASTER) {
     
446.     ref_clock = get_master_clock(is);
     
447.     diff = vp->pts - ref_clock;
     
448.     
     
449.     /* Skip or repeat the frame. Take delay into account
     
450.      FFPlay still doesn't "know if this is the best guess." */
     
451.     sync_threshold = (delay > AV_SYNC_THRESHOLD) ? delay : AV_SYNC_THRESHOLD;
     
452.     if(fabs(diff) < AV_NOSYNC_THRESHOLD) {
     
453.      if(diff <= -sync_threshold) {
     
454.      delay = 0;
     
455.      } else if(diff >= sync_threshold) {
     
456.      delay = 2 * delay;
     
457.      }
     
458.     }
     
459.       }
     
460. 
     
461.       is->frame_timer += delay;
     
462.       /* computer the REAL delay */
     
463.       actual_delay = is->frame_timer - (av_gettime() / 1000000.0);
     
464.       if(actual_delay < 0.010) {
     
465.     /* Really it should skip the picture instead */
     
466.     actual_delay = 0.010;
     
467.       }
     
468.       schedule_refresh(is, (int)(actual_delay * 1000 + 0.5));
     
469. 
     
470.       /* show the */
     
471.       video_display(is);
     
472.       
     
473.       /* update queue for next */
     
474.       if(++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE) {
     
475.     is->pictq_rindex = 0;
     
476.       }
     
477.       SDL_LockMutex(is->pictq_mutex);
     
478.       is->pictq_size--;
     
479.       SDL_CondSignal(is->pictq_cond);
     
480.       SDL_UnlockMutex(is->pictq_mutex);
     
481.     }
     
482.   } else {
     
483.     schedule_refresh(is, 100);
     
484.   }
     
485. }
     
486.       
     
487. void alloc_picture(void *userdata) {
     
488. 
     
489.   VideoState *is = (VideoState *)userdata;
     
490.   VideoPicture *vp;
     
491. 
     
492.   vp = &is->pictq[is->pictq_windex];
     
493.   if(vp->bmp) {
     
494.     // we already have one make another, bigger/smaller
     
495.     SDL_FreeYUVOverlay(vp->bmp);
     
496.   }
     
497.   // Allocate a place to put our YUV image on that screen
     
498.   vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width,
     
499.                  is->video_st->codec->height,
     
500.                  SDL_YV12_OVERLAY,
     
501.                  screen);
     
502.   vp->width = is->video_st->codec->width;
     
503.   vp->height = is->video_st->codec->height;
     
504.   
     
505.   SDL_LockMutex(is->pictq_mutex);
     
506.   vp->allocated = 1;
     
507.   SDL_CondSignal(is->pictq_cond);
     
508.   SDL_UnlockMutex(is->pictq_mutex);
     
509. 
     
510. }
     
511. 
     
512. int queue_picture(VideoState *is, AVFrame *pFrame, double pts) {
     
513. 
     
514.   VideoPicture *vp;
     
515.   int dst_pix_fmt;
     
516.   AVPicture pict;
     
517. 
     
518.   /* wait until we have space for a new pic */
     
519.   SDL_LockMutex(is->pictq_mutex);
     
520.   while(is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE &&
     
521.     !is->quit) {
     
522.     SDL_CondWait(is->pictq_cond, is->pictq_mutex);
     
523.   }
     
524.   SDL_UnlockMutex(is->pictq_mutex);
     
525. 
     
526.   if(is->quit)
     
527.     return -1;
     
528. 
     
529.   // windex is set to 0 initially
     
530.   vp = &is->pictq[is->pictq_windex];
     
531. 
     
532.   /* allocate or resize the */
     
533.   if(!vp->bmp ||
     
534.      vp->width != is->video_st->codec->width ||
     
535.      vp->height != is->video_st->codec->height) {
     
536.     SDL_Event event;
     
537. 
     
538.     vp->allocated = 0;
     
539.     /* we have to do it in the main thread */
     
540.     event.type = FF_ALLOC_EVENT;
     
541.     event.user.data1 = is;
     
542.     SDL_PushEvent(&event);
     
543. 
     
544.     /* wait until we have a picture allocated */
     
545.     SDL_LockMutex(is->pictq_mutex);
     
546.     while(!vp->allocated && !is->quit) {
     
547.       SDL_CondWait(is->pictq_cond, is->pictq_mutex);
     
548.     }
     
549.     SDL_UnlockMutex(is->pictq_mutex);
     
550.     if(is->quit) {
     
551.       return -1;
     
552.     }
     
553.   }
     
554.   /* We have a place to put our picture on the queue */
     
555.   /* If we are skipping a frame, do we set this to null 
     
556.      but still return vp->allocated = 1? */
     
557. 
     
558. 
     
559.   if(vp->bmp) {
     
560. 
     
561.     SDL_LockYUVOverlay(vp->bmp);
     
562.     
     
563.     dst_pix_fmt = PIX_FMT_YUV420P;
     
564.     /* point pict at the queue */
     
565. 
     
566.     pict.data[0] = vp->bmp->pixels[0];
     
567.     pict.data[1] = vp->bmp->pixels[2];
     
568.     pict.data[2] = vp->bmp->pixels[1];
     
569.     
     
570.     pict.linesize[0] = vp->bmp->pitches[0];
     
571.     pict.linesize[1] = vp->bmp->pitches[2];
     
572.     pict.linesize[2] = vp->bmp->pitches[1];
     
573.     
     
574.     // Convert the image into YUV format that SDL uses
     
575.     /*
     
576.     img_convert(&pict, dst_pix_fmt,
     
577.         (AVPicture *)pFrame, is->video_st->codec->pix_fmt, 
     
578.         is->video_st->codec->width, is->video_st->codec->height);
     
579.     */
     
580.     sws_scale(is->img_convert_ctx, 
     
581.           pFrame->data, 
     
582.           pFrame->linesize, 0, 
     
583.           is->video_st->codec->height, 
     
584.           pict.data, 
     
585.           pict.linesize);
     
586.     
     
587.     SDL_UnlockYUVOverlay(vp->bmp);
     
588.     vp->pts = pts;
     
589. 
     
590.     /* now we inform our display thread that we have a pic ready */
     
591.     if(++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE) {
     
592.       is->pictq_windex = 0;
     
593.     }
     
594.     SDL_LockMutex(is->pictq_mutex);
     
595.     is->pictq_size++;
     
596.     SDL_UnlockMutex(is->pictq_mutex);
     
597.   }
     
598.   return 0;
     
599. }
     
600. 
     
601. double synchronize_video(VideoState *is, AVFrame *src_frame, double pts) {
     
602. 
     
603.   double frame_delay;
     
604. 
     
605.   if(pts != 0) {
     
606.     /* if we have pts, set video clock to it */
     
607.     is->video_clock = pts;
     
608.   } else {
     
609.     /* if we aren't given a pts, set it to the clock */
     
610.     pts = is->video_clock;
     
611.   }
     
612.   /* update the video clock */
     
613.   frame_delay = av_q2d(is->video_st->codec->time_base);
     
614.   /* if we are repeating a frame, adjust clock accordingly */
     
615.   frame_delay += src_frame->repeat_pict * (frame_delay * 0.5);
     
616.   is->video_clock += frame_delay;
     
617.   return pts;
     
618. }
     
619. 
     
620. uint64_t global_video_pkt_pts = AV_NOPTS_VALUE;
     
621. 
     
622. /* These are called whenever we allocate a frame
     
623.  * buffer. We use this to store the global_pts in
     
624.  * a frame at the time it is allocated.
     
625.  */
     
626. int our_get_buffer(struct AVCodecContext *c, AVFrame *pic) {
     
627.   int ret = avcodec_default_get_buffer(c, pic);
     
628.   uint64_t *pts = av_malloc(sizeof(uint64_t));
     
629.   *pts = global_video_pkt_pts;
     
630.   pic->opaque = pts;
     
631.   return ret;
     
632. }
     
633. void our_release_buffer(struct AVCodecContext *c, AVFrame *pic) {
     
634.   if(pic) av_freep(&pic->opaque);
     
635.   avcodec_default_release_buffer(c, pic);
     
636. }
     
637. 
     
638. int video_thread(void *arg) {
     
639.   VideoState *is = (VideoState *)arg;
     
640.   AVPacket pkt1, *packet = &pkt1;
     
641.   int len1, frameFinished;
     
642.   AVFrame *pFrame;
     
643.   double pts;
     
644. 
     
645.   pFrame = avcodec_alloc_frame();
     
646. 
     
647.   for(;;) {
     
648.     if(packet_queue_get(&is->videoq, packet, 1) < 0) {
     
649.       // means we quit getting packets
     
650.       break;
     
651.     }
     
652.     pts = 0;
     
653. 
     
654.     // Save global pts to be stored in pFrame in first call
     
655.     global_video_pkt_pts = packet->pts;
     
656.     // Decode video frame
     
657.     len1 = avcodec_decode_video(is->video_st->codec, pFrame, &frameFinished, 
     
658.                 packet->data, packet->size);
     
659.     if(packet->dts == AV_NOPTS_VALUE 
     
660.        && pFrame->opaque && *(uint64_t*)pFrame->opaque != AV_NOPTS_VALUE) {
     
661.       pts = *(uint64_t *)pFrame->opaque;
     
662.     } else if(packet->dts != AV_NOPTS_VALUE) {
     
663.       pts = packet->dts;
     
664.     } else {
     
665.       pts = 0;
     
666.     }
     
667.     pts *= av_q2d(is->video_st->time_base);
     
668. 
     
669.     // Did we get a video frame?
     
670.     if(frameFinished) {
     
671.       pts = synchronize_video(is, pFrame, pts);
     
672.       if(queue_picture(is, pFrame, pts) < 0) {
     
673.     break;
     
674.       }
     
675.     }
     
676.     av_free_packet(packet);
     
677.   }
     
678.   av_free(pFrame);
     
679.   return 0;
     
680. }
     
681. 
     
682. int stream_component_open(VideoState *is, int stream_index) {
     
683. 
     
684.   AVFormatContext *pFormatCtx = is->pFormatCtx;
     
685.   AVCodecContext *codecCtx;
     
686.   AVCodec *codec;
     
687.   SDL_AudioSpec wanted_spec, spec;
     
688. 
     
689.   if(stream_index < 0 || stream_index >= pFormatCtx->nb_streams) {
     
690.     return -1;
     
691.   }
     
692. 
     
693.   // Get a pointer to the codec context for the video stream
     
694.   codecCtx = pFormatCtx->streams[stream_index]->codec;
     
695.     
     
696.     is->img_convert_ctx = sws_getContext(codecCtx->width, 
     
697.                    codecCtx->height, 
     
698.                    codecCtx->pix_fmt, 
     
699.                    codecCtx->width, 
     
700.                    codecCtx->height, 
     
701.                    PIX_FMT_YUV420P, 
     
702.                    SWS_BICUBIC, 
     
703.                    NULL, NULL, NULL); 
     
704.     
     
705.   if(codecCtx->codec_type == CODEC_TYPE_AUDIO) {
     
706.     // Set audio settings from codec info
     
707.     wanted_spec.freq = codecCtx->sample_rate;
     
708.     wanted_spec.format = AUDIO_S16SYS;
     
709.     wanted_spec.channels = codecCtx->channels;
     
710.     wanted_spec.silence = 0;
     
711.     wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
     
712.     wanted_spec.callback = audio_callback;
     
713.     wanted_spec.userdata = is;
     
714.     
     
715.     if(SDL_OpenAudio(&wanted_spec, &spec) < 0) {
     
716.       fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
     
717.       return -1;
     
718.     }
     
719.     is->audio_hw_buf_size = spec.size;
     
720.   }
     
721.   codec = avcodec_find_decoder(codecCtx->codec_id);
     
722.   if(!codec || (avcodec_open(codecCtx, codec) < 0)) {
     
723.     fprintf(stderr, "Unsupported codec!\n");
     
724.     return -1;
     
725.   }
     
726. 
     
727.   switch(codecCtx->codec_type) {
     
728.   case CODEC_TYPE_AUDIO:
     
729.     is->audioStream = stream_index;
     
730.     is->audio_st = pFormatCtx->streams[stream_index];
     
731.     is->audio_buf_size = 0;
     
732.     is->audio_buf_index = 0;
     
733.     
     
734.     /* averaging filter for audio sync */
     
735.     is->audio_diff_avg_coef = exp(log(0.01 / AUDIO_DIFF_AVG_NB));
     
736.     is->audio_diff_avg_count = 0;
     
737.     /* Correct audio only if larger error than this */
     
738.     is->audio_diff_threshold = 2.0 * SDL_AUDIO_BUFFER_SIZE / codecCtx->sample_rate;
     
739. 
     
740.     memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
     
741.     packet_queue_init(&is->audioq);
     
742.     SDL_PauseAudio(0);
     
743.     break;
     
744.   case CODEC_TYPE_VIDEO:
     
745.     is->videoStream = stream_index;
     
746.     is->video_st = pFormatCtx->streams[stream_index];
     
747. 
     
748.     is->frame_timer = (double)av_gettime() / 1000000.0;
     
749.     is->frame_last_delay = 40e-3;
     
750.     is->video_current_pts_time = av_gettime();
     
751. 
     
752.     packet_queue_init(&is->videoq);
     
753.     is->video_tid = SDL_CreateThread(video_thread, is);
     
754.     codecCtx->get_buffer = our_get_buffer;
     
755.     codecCtx->release_buffer = our_release_buffer;
     
756.     break;
     
757.   default:
     
758.     break;
     
759.   }
     
760. 
     
761. 
     
762. }
     
763. 
     
764. int decode_interrupt_cb(void) {
     
765.   return (global_video_state && global_video_state->quit);
     
766. }
     
767. 
     
768. int decode_thread(void *arg) {
     
769. 
     
770.   VideoState *is = (VideoState *)arg;
     
771.   AVFormatContext *pFormatCtx;
     
772.   AVPacket pkt1, *packet = &pkt1;
     
773. 
     
774.   int video_index = -1;
     
775.   int audio_index = -1;
     
776.   int i;
     
777. 
     
778.   is->videoStream=-1;
     
779.   is->audioStream=-1;
     
780. 
     
781.   global_video_state = is;
     
782.   // will interrupt blocking functions if we 
     
783.   url_set_interrupt_cb(decode_interrupt_cb);
     
784. 
     
785.   // Open video file
     
786.   if(av_open_input_file(&pFormatCtx, is->filename, NULL, 0, NULL)!=0)
     
787.     return -1; // Couldn't open file
     
788. 
     
789.   is->pFormatCtx = pFormatCtx;
     
790.   
     
791.   // Retrieve stream information
     
792.   if(av_find_stream_info(pFormatCtx)<0)
     
793.     return -1; // Couldn't find stream information
     
794.   
     
795.   // Dump information about file onto standard error
     
796.   dump_format(pFormatCtx, 0, is->filename, 0);
     
797.   
     
798.   // Find the first video stream
     
799. 
     
800.   for(i=0; i<pFormatCtx->nb_streams; i++) {
     
801.     if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_VIDEO &&
     
802.        video_index < 0) {
     
803.       video_index=i;
     
804.     }
     
805.     if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_AUDIO &&
     
806.        audio_index < 0) {
     
807.       audio_index=i;
     
808.     }
     
809.   }
     
810.   if(audio_index >= 0) {
     
811.     stream_component_open(is, audio_index);
     
812.   }
     
813.   if(video_index >= 0) {
     
814.     stream_component_open(is, video_index);
     
815.   } 
     
816. 
     
817.   if(is->videoStream < 0 || is->audioStream < 0) {
     
818.     fprintf(stderr, "%s: could not open codecs\n", is->filename);
     
819.     goto fail;
     
820.   }
     
821. 
     
822.   // main decode loop
     
823. 
     
824.   for(;;) {
     
825.     if(is->quit) {
     
826.       break;
     
827.     }
     
828.     // seek stuff goes here
     
829.     if(is->audioq.size > MAX_AUDIOQ_SIZE ||
     
830.        is->videoq.size > MAX_VIDEOQ_SIZE) {
     
831.       SDL_Delay(10);
     
832.       continue;
     
833.     }
     
834.     if(av_read_frame(is->pFormatCtx, packet) < 0) {
     
835.       if(url_ferror(&pFormatCtx->pb) == 0) {
     
836.     SDL_Delay(100); /* no error; wait for user input */
     
837.     continue;
     
838.       } else {
     
839.     break;
     
840.       }
     
841.     }
     
842.     // Is this a packet from the video stream?
     
843.     if(packet->stream_index == is->videoStream) {
     
844.       packet_queue_put(&is->videoq, packet);
     
845.     } else if(packet->stream_index == is->audioStream) {
     
846.       packet_queue_put(&is->audioq, packet);
     
847.     } else {
     
848.       av_free_packet(packet);
     
849.     }
     
850.   }
     
851.   /* all done - wait for it */
     
852.   while(!is->quit) {
     
853.     SDL_Delay(100);
     
854.   }
     
855. 
     
856.  fail:
     
857.   {
     
858.     SDL_Event event;
     
859.     event.type = FF_QUIT_EVENT;
     
860.     event.user.data1 = is;
     
861.     SDL_PushEvent(&event);
     
862.   }
     
863.   return 0;
     
864. }
     
865. 
     
866. int main(int argc, char *argv[]) {
     
867. 
     
868.   SDL_Event event;
     
869. 
     
870.   VideoState *is;
     
871. 
     
872.   is = av_mallocz(sizeof(VideoState));
     
873. 
     
874.   if(argc < 2) {
     
875.     fprintf(stderr, "Usage: test <file>\n");
     
876.     exit(1);
     
877.   }
     
878.   // Register all formats and codecs
     
879.   av_register_all();
     
880.   
     
881.   if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
     
882.     fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
     
883.     exit(1);
     
884.   }
     
885. 
     
886.   // Make a screen to put our video
     
887. #ifndef __DARWIN__
     
888.         screen = SDL_SetVideoMode(640, 480, 0, 0);
     
889. #else
     
890.         screen = SDL_SetVideoMode(640, 480, 24, 0);
     
891. #endif
     
892.   if(!screen) {
     
893.     fprintf(stderr, "SDL: could not set video mode - exiting\n");
     
894.     exit(1);
     
895.   }
     
896. 
     
897.   av_strlcpy(is->filename, argv[1], sizeof(is->filename));
     
898. 
     
899.   is->pictq_mutex = SDL_CreateMutex();
     
900.   is->pictq_cond = SDL_CreateCond();
     
901. 
     
902.   schedule_refresh(is, 40);
     
903. 
     
904.   is->av_sync_type = DEFAULT_AV_SYNC_TYPE;
     
905.   is->parse_tid = SDL_CreateThread(decode_thread, is);
     
906.   if(!is->parse_tid) {
     
907.     av_free(is);
     
908.     return -1;
     
909.   }
     
910.   for(;;) {
     
911. 
     
912.     SDL_WaitEvent(&event);
     
913.     switch(event.type) {
     
914.     case FF_QUIT_EVENT:
     
915.     case SDL_QUIT:
     
916.       is->quit = 1;
     
917.       SDL_Quit();
     
918.       exit(0);
     
919.       break;
     
920.     case FF_ALLOC_EVENT:
     
921.       alloc_picture(event.user.data1);
     
922.       break;
     
923.     case FF_REFRESH_EVENT:
     
924.       video_refresh_timer(event.user.data1);
     
925.       break;
     
926.     default:
     
927.       break;
     
928.     }
     
929.   }
     
930.   return 0;
     
931. 
     
932. }