ffmpeg学习---10.4Spawning Threads(更新版)

http://dranger.com/ffmpeg/tutorial04.html
1. 流程

1. main中创建线程decode_thread,作用是从视频文件中分离出vidoe与sound帧
   
2. decode_thread
   
3. {
   
4.     stream_component_open(is, audio_index); --> audio_callback
   
5.     stream_component_open(is, video_index); --> video_thread
   
6.     while(1)
   
7.     {
   
8.         av_read_frame();
   
9.         将video的数据 put_queue
   
10.         将sound的数据 put_queue
    
11.     }
    
12. }
    
13. 
    
14. audio_callback
    
15. {
    
16.     audio的流程不变
    
17. }
    
18. 
    
19. video_thread
    
20. {
    
21.     a.从video的帧队列中packet_queue_get
    
22.     b. decode_video2解码
    
23.     c. queue_picture显示
    
24. }
    
25. queue_picture
    
26. {
    
27. a. 等侍信号pictq_cond
    
28. b. 如果是第1次需要初始化SDL_screeen
    
29. c. 转换图片格式sws_scale
    
30. }
    
31. 
    
32. video_refresh_timer
    
33. {
    
34. a. SDL_DisplayYUVOverlay显示图像
    
35. b. 显示完成后发送信号pictq_cond
    
36. }

2.代码

1. cong@msi:/work/ffmpeg/test/4spawn$ cat spawn.c 
   
2. #include "utils.h"
   
3. #include <libavcodec/avcodec.h>
   
4. #include <libavformat/avformat.h>
   
5. #include <libswscale/swscale.h>
   
6. #include <libswresample/swresample.h>
   
7. #include <libavutil/avstring.h>
   
8. #include <libavutil/pixfmt.h>
   
9. #include <libavutil/log.h>
   
10. #include <SDL/SDL.h>
    
11. #include <SDL/SDL_thread.h>
    
12. #include <stdio.h>
    
13. #include <math.h>
    
14. 
    
15. #define SDL_AUDIO_BUFFER_SIZE 4096
    
16. #define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000
    
17. 
    
18. #define MAX_AUDIOQ_SIZE (5 * 16 * 1024)
    
19. #define MAX_VIDEOQ_SIZE (5 * 256 * 1024)
    
20. 
    
21. 
    
22. #define FF_REFRESH_EVENT (SDL_USEREVENT)
    
23. #define FF_QUIT_EVENT (SDL_USEREVENT + 1)
    
24. 
    
25. typedef struct PacketQueue
    
26. {
    
27.     AVPacketList * first_pkt, *last_pkt;
    
28.     int nb_packets;
    
29.     int size;
    
30.     SDL_mutex *mutex;
    
31.     SDL_cond * cond;
    
32. }PacketQueue;
    
33. 
    
34. static int signal_quit = 0;
    
35. SDL_mutex *affmutex;
    
36. SDL_Event sdlevent;
    
37. 
    
38. #define VIDEO_PICTURE_QUEUE_SIZE 1
    
39. 
    
40. typedef struct VideoState {
    
41.     int videoindex;
    
42.     int sndindex;
    
43.     int frameFinished;
    
44.     int wanted_freq;
    
45.     int wanted_samples;
    
46.     int wanted_channels;
    
47.     char filename[1024];
    
48.     int pictq_size, pictq_rindex, pictq_windex;
    
49.     SDL_Thread* video_tid;
    
50.     AVFormatContext* pFormatCtx;
    
51.     AVCodecContext* vdoCodecCtx;
    
52.     AVCodecContext* sndCodecCtx;
    
53.     AVCodec* vdoCodec;
    
54.     AVCodec* sndCodec;
    
55.     AVFrame* pFrameYUV;
    
56.     AVPacket* packet;
    
57.     struct SwsContext *img_convert_ctx;
    
58.     struct SwrContext *swr_ctx;
    
59.     SDL_mutex *pictq_mutex;
    
60.     SDL_cond *pictq_cond;
    
61.     SDL_Surface* psscreen;
    
62.     SDL_Overlay* overlay;
    
63.     SDL_Rect rect;
    
64.     SDL_mutex *screen_mutex;
    
65.     enum AVSampleFormat wanted_fmt;
    
66.     int64_t wanted_channel_layout;
    
67.     PacketQueue audioq;
    
68.     PacketQueue videoq;
    
69.     DECLARE_ALIGNED(16,uint8_t,audio_buf2) [AVCODEC_MAX_AUDIO_FRAME_SIZE * 4];
    
70. }VideoState;
    
71. 
    
72. void video_refresh_timer(void* arg);
    
73. 
    
74. static int sdl_event_thread(void* data)
    
75. {
    
76.     while((0==signal_quit))
    
77.     {
    
78.         SDL_LockMutex(affmutex);
    
79.         while(SDL_PollEvent(&sdlevent))
    
80.         {
    
81.             switch(sdlevent.type)
    
82.             {
    
83.                 case FF_QUIT_EVENT:
    
84.                 case SDL_QUIT:
    
85.                     {
    
86.                         dbmsg("next change signal_quit to 1");
    
87.                         signal_quit = 1;
    
88.                         SDL_Quit();
    
89.                     }
    
90.                     break;
    
91.                 case FF_REFRESH_EVENT:
    
92.                   video_refresh_timer(sdlevent.user.data1);
    
93.                   break;
    
94.                 default:
    
95.                     break;
    
96.             }
    
97.         }
    
98.         SDL_UnlockMutex(affmutex);
    
99.     }
    
100. }
     
101. 
     
102. void packet_queue_init(PacketQueue *q)
     
103. {
     
104.     memset(q, 0, sizeof(PacketQueue));
     
105.     q->mutex = SDL_CreateMutex();
     
106.     q->cond = SDL_CreateCond();
     
107. }
     
108. 
     
109. int packet_queue_put(PacketQueue *q, AVPacket *pkt)
     
110. {
     
111.     AVPacketList *pkt1;
     
112.     if(av_dup_packet(pkt) < 0)
     
113.         return -1;
     
114.     pkt1 = av_malloc(sizeof(AVPacketList));
     
115.     if (!pkt1)
     
116.         return -1;
     
117.     pkt1->pkt = *pkt;
     
118.     pkt1->next = NULL;
     
119. 
     
120.     SDL_LockMutex(q->mutex);
     
121.     if (!q->last_pkt)
     
122.         q->first_pkt = pkt1;
     
123.     else
     
124.         q->last_pkt->next = pkt1;
     
125.     q->last_pkt = pkt1;
     
126.     q->nb_packets++;
     
127.     q->size += pkt1->pkt.size;
     
128.     //dbmsg("put_queue and send singal");
     
129.     SDL_CondSignal(q->cond);
     
130.     SDL_UnlockMutex(q->mutex);
     
131.     return 0;
     
132. }
     
133. 
     
134. static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
     
135. {
     
136.     AVPacketList *pkt1;
     
137.     int ret;
     
138.     SDL_LockMutex(q->mutex);
     
139.     for(;;)
     
140.     {
     
141.         pkt1 = q->first_pkt;
     
142.         if (pkt1)
     
143.         {
     
144.             q->first_pkt = pkt1->next;
     
145.             if (!q->first_pkt)
     
146.                 q->last_pkt = NULL;
     
147.             q->nb_packets--;
     
148.             q->size -= pkt1->pkt.size;
     
149.             *pkt = pkt1->pkt;
     
150.             av_free(pkt1);
     
151.             ret = 1;
     
152.             break;
     
153.         } else if (!block) {
     
154.             ret = 0;
     
155.             break;
     
156.         } else {
     
157.             SDL_CondWait(q->cond, q->mutex);
     
158.             dbmsg("get_queue and get singal");
     
159.         }
     
160.     }
     
161.     SDL_UnlockMutex(q->mutex);
     
162.     return ret;
     
163. }
     
164. 
     
165. int audio_decode_frame(VideoState* is)
     
166. {
     
167.     int i;
     
168.     int len1,len2, data_size, got_frame;
     
169.     int new_packet;
     
170.     int64_t dec_channel_layout;
     
171.     uint8_t *out[] = { is->audio_buf2 };
     
172.     AVPacket *pkt = av_mallocz(sizeof(AVPacket));
     
173.     AVPacket *pkt_temp = av_mallocz(sizeof(AVPacket));
     
174.     AVFrame *frame = av_frame_alloc();
     
175.     for(;;)
     
176.     {
     
177.         while(pkt_temp->size>0 || (!pkt_temp->data && new_packet))
     
178.         {
     
179.             if(frame)
     
180.             {
     
181.                 //dbmsg("av_get default frame");
     
182.                 av_frame_unref(frame); //reset frame
     
183.             }
     
184.             new_packet = 0;
     
185.             len1 = avcodec_decode_audio4(is->sndCodecCtx, frame, &got_frame, pkt_temp); //decode data is store in frame
     
186.             if(len1 < 0)
     
187.             {
     
188.                 pkt_temp->size = 0;
     
189.                 break;
     
190.             }
     
191.             //dbmsg("len1=%d, linesize=%d",len1, frame->linesize[0]);
     
192. 
     
193.             pkt_temp->data += len1;
     
194.             pkt_temp->size -= len1;
     
195. 
     
196.             if(got_frame <= 0) /* No data yet, get more frames */
     
197.                 continue;
     
198.             data_size = av_samples_get_buffer_size(NULL, is->sndCodecCtx->channels, frame->nb_samples, is->sndCodecCtx->sample_fmt, 1);
     
199.             dec_channel_layout = (frame->channel_layout && frame->channels==av_get_channel_layout_nb_channels(frame->channel_layout))?
     
200.                 frame->channel_layout: is->wanted_channel_layout;
     
201. #if 0
     
202.             dbmsg("format=%d:%d,layout=%lld:%lld,rate=%d:%d,samples=%d:%d",frame->format,is->wanted_fmt,
     
203.                    (long long) dec_channel_layout,(long long)av_get_default_channel_layout(is->wanted_channels),
     
204.               frame->sample_rate,is->wanted_freq,frame->nb_samples,is->wanted_samples );
     
205. 
     
206.             dbmsg("wanted_channel_layout=%lld", (long long)is->wanted_channel_layout);
     
207.             dbmsg("wanted_fmt=%d", is->wanted_fmt);
     
208.             dbmsg("spec.freq=%d", is->wanted_freq);
     
209. #endif
     
210.             //check: format,channel_layout,rate,sample
     
211.             if((NULL==is->swr_ctx) && ( (frame->format!=is->wanted_fmt) || (dec_channel_layout!=av_get_default_channel_layout(is->wanted_channels)) ||
     
212.               (frame->sample_rate!=is->wanted_freq) || (frame->nb_samples!=is->wanted_samples)) )
     
213.             {
     
214.                 if(is->swr_ctx != NULL)
     
215.                     swr_free(&is->swr_ctx);
     
216. #if 0
     
217.                 dbmsg("wanted_channel_layout=%lld, wanted_fmt=%d, wanted_sample=%d, dec_channel_layout=%lld, frame->format=%d, frame->sample_rate=%d",
     
218.                 (long long)is->wanted_channel_layout, is->wanted_fmt, is->wanted_samples, (long long)dec_channel_layout, frame->format, frame->sample_rate);
     
219. #endif
     
220.                 is->swr_ctx = swr_alloc_set_opts(NULL, is->wanted_channel_layout, is->wanted_fmt, is->wanted_freq, dec_channel_layout, frame->format, frame->sample_rate, 0, NULL);
     
221.                 if(is->swr_ctx == NULL)
     
222.                 {
     
223.                     dbmsg("swr_ctx == NULL");
     
224.                 }
     
225.                 swr_init(is->swr_ctx);
     
226.             }
     
227.             if(is->swr_ctx)
     
228.             {
     
229.                 len2 = swr_convert(is->swr_ctx, out, sizeof(is->audio_buf2)/is->wanted_channels/av_get_bytes_per_sample(frame->format),(const uint8_t **)frame->extended_data, frame->nb_samples);
     
230.                 data_size = len2 * is->wanted_channels * av_get_bytes_per_sample(is->wanted_fmt);
     
231.             }else {
     
232.                 memcpy(is->audio_buf2, frame->data[0], frame->linesize[0]);
     
233.             }
     
234. 
     
235.             return data_size;
     
236.         }
     
237.         if(pkt->data)
     
238.             av_free_packet(pkt);
     
239.         memset(pkt_temp, 0, sizeof(*pkt_temp));
     
240.         if(signal_quit)
     
241.             return -1;
     
242.         if((new_packet = packet_queue_get(&is->audioq, pkt, 1)) < 0)
     
243.         {
     
244.             dbmsg("get packet=%d", new_packet);
     
245.             return -1;
     
246.         }
     
247. 
     
248.         *pkt_temp = *pkt;
     
249.     }
     
250. }
     
251. 
     
252. void audio_callback(void *userdata, Uint8 *stream, int len)
     
253. {
     
254.     int i;
     
255.     VideoState* is = (VideoState*)userdata;
     
256.     int len1, audio_size;
     
257. 
     
258.     static unsigned int audio_buf_size = 0;
     
259.     static unsigned int audio_buf_index = 0;
     
260. 
     
261.     while(len > 0)
     
262.     {
     
263.         if(audio_buf_index >= audio_buf_size)
     
264.         {
     
265.             audio_size = audio_decode_frame(is); //decode data is store in is->audio_buf2
     
266.             //dbmsg("audio_size=%d", audio_size);
     
267.             if(audio_size < 0)
     
268.             {
     
269.                 /* If error, output silence */
     
270.                 audio_buf_size = 1024;
     
271.                 memset(is->audio_buf2, 0, audio_buf_size);
     
272.             } else {
     
273.                 audio_buf_size = audio_size;
     
274.             }
     
275.             audio_buf_index = 0;
     
276.         }
     
277.         //dbmsg("len=%d, audio_buf_size=%d, audio_buf_index=%d", len, audio_buf_size, audio_buf_index);
     
278.         len1 = audio_buf_size - audio_buf_index;
     
279.         //dbmsg("len1=%d", len1);
     
280.         if(len1 > len)
     
281.             len1 = len;
     
282.         //dbmsg("len1 = %d", len1);
     
283.         memcpy(stream, (uint8_t *)is->audio_buf2 + audio_buf_index, len1);
     
284.         len -= len1;
     
285.         stream += len1;
     
286.         audio_buf_index += len1;
     
287.     }
     
288. }
     
289. 
     
290. static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) {
     
291.   SDL_Event event;
     
292.   event.type = FF_REFRESH_EVENT;
     
293.   event.user.data1 = opaque;
     
294.   SDL_PushEvent(&event);
     
295.   return 0; /* 0 means stop timer */
     
296. }
     
297. 
     
298. /* schedule a video refresh in 'delay' ms */
     
299. static void schedule_refresh(VideoState *is, int delay) {
     
300.   SDL_AddTimer(delay, sdl_refresh_timer_cb, is);
     
301. }
     
302. 
     
303. void video_display(VideoState *is) {
     
304.     SDL_LockMutex(is->screen_mutex);
     
305.     SDL_DisplayYUVOverlay(is->overlay, &is->rect);
     
306.     SDL_UnlockMutex(is->screen_mutex);
     
307. }
     
308. 
     
309. void video_refresh_timer(void *data)
     
310. {
     
311.     VideoState *is = (VideoState *)data;
     
312.     if(is->pictq_size == 0) {
     
313.         schedule_refresh(is, 1);
     
314.     } else {
     
315.         schedule_refresh(is, 40);
     
316.         video_display(is);
     
317. 
     
318.         SDL_LockMutex(is->pictq_mutex);
     
319.         is->pictq_size--;
     
320.         SDL_CondSignal(is->pictq_cond);
     
321.         SDL_UnlockMutex(is->pictq_mutex);
     
322.     }
     
323. }
     
324. 
     
325. int queue_picture(VideoState *is, AVFrame *pFrame)
     
326. {
     
327.     /* wait until we have space for a new pic */
     
328.     SDL_LockMutex(is->pictq_mutex);
     
329.     while(is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE && (0==signal_quit)) {
     
330.         SDL_CondWait(is->pictq_cond, is->pictq_mutex);
     
331.     }
     
332.     SDL_UnlockMutex(is->pictq_mutex);
     
333. 
     
334.     if(signal_quit)
     
335.       return -1;
     
336. 
     
337.     /* We have a place to put our picture on the queue */
     
338.     SDL_LockYUVOverlay(is->overlay);
     
339.     is->pFrameYUV->data[0] = is->overlay->pixels[0];
     
340.     is->pFrameYUV->data[1] = is->overlay->pixels[2];
     
341.     is->pFrameYUV->data[2] = is->overlay->pixels[1];
     
342.     is->pFrameYUV->linesize[0] = is->overlay->pitches[0];
     
343.     is->pFrameYUV->linesize[1] = is->overlay->pitches[2];
     
344.     is->pFrameYUV->linesize[2] = is->overlay->pitches[1];
     
345.     sws_scale(is->img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0,
     
346.     is->vdoCodecCtx->height, is->pFrameYUV->data, is->pFrameYUV->linesize);
     
347.     SDL_UnlockYUVOverlay(is->overlay);
     
348.     SDL_LockMutex(is->pictq_mutex);
     
349.     is->pictq_size++;
     
350.     SDL_UnlockMutex(is->pictq_mutex);
     
351.     return 0;
     
352. }
     
353. 
     
354. static int video_thread(void* data)
     
355. {
     
356.     VideoState *is = (VideoState *)data;
     
357.     AVPacket pkt1, *packet = &pkt1;
     
358.     int frameFinished;
     
359.     AVFrame *pFrame;
     
360.     int ret;
     
361.     pFrame = av_frame_alloc();
     
362. 
     
363.    for(;;)
     
364.    {
     
365.       if(signal_quit)
     
366.           break;
     
367.       if(packet_queue_get(&is->videoq, packet, 1) < 0) {
     
368.           // means we quit getting packets
     
369.           dbmsg("packet_queue_get < 0");
     
370.           break;
     
371.         }
     
372.         // Decode video frame
     
373.         if((ret=avcodec_decode_video2(is->vdoCodecCtx, pFrame, &is->frameFinished, packet)) < 0)
     
374.         {
     
375.             dbmsg("decocode video error");
     
376.             continue;
     
377.         }
     
378.         if(is->frameFinished) {
     
379.           if(queue_picture(is, pFrame) < 0) {
     
380.             break;
     
381.           }
     
382.         }
     
383.         av_free_packet(packet);
     
384.     }
     
385.     av_frame_free(&pFrame);
     
386.     return 0;
     
387. }
     
388. 
     
389. static int decode_thread(void* data)
     
390. {
     
391.     VideoState* is = (VideoState*)data;
     
392.     is->packet = (AVPacket*)av_malloc(sizeof(AVPacket));
     
393.     while( (av_read_frame(is->pFormatCtx, is->packet)>=0) && (signal_quit==0))
     
394.     {
     
395.         if(is->packet->stream_index == is->videoindex)
     
396.         {
     
397.             packet_queue_put(&is->videoq, is->packet);
     
398.         }
     
399. 
     
400.         if(is->packet->stream_index == is->sndindex)
     
401.         {
     
402.             packet_queue_put(&is->audioq, is->packet);
     
403.         }
     
404.     }
     
405.     return 0;
     
406. }
     
407. 
     
408. int init_ffmpeg_and_SDL(VideoState* is, char* video_file)
     
409. {
     
410.     int i=0;
     
411.     int ret;
     
412.     SDL_AudioSpec wanted_spec, real_spec;
     
413.     is->videoindex = -1;
     
414.     is->sndindex = -1;
     
415.     if(NULL == video_file)
     
416.     {
     
417.         dbmsg("input file is NULL");
     
418.         return -1;
     
419.     }
     
420.     SDL_Init(SDL_INIT_EVERYTHING);
     
421.     avcodec_register_all();
     
422.     avfilter_register_all();
     
423.     av_register_all();
     
424. 
     
425.     is->pFormatCtx = avformat_alloc_context();
     
426. 
     
427.     if(avformat_open_input(&is->pFormatCtx, video_file, NULL, NULL)!=0)
     
428.         return -1;
     
429. 
     
430.     if(avformat_find_stream_info(is->pFormatCtx, NULL)<0)
     
431.         return -1;
     
432.     av_dump_format(is->pFormatCtx,0, 0, 0);
     
433. 
     
434.     for(i=0; i<is->pFormatCtx->nb_streams; i++)
     
435.     {
     
436.         if(is->pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
     
437.         {
     
438.             is->videoindex= i;
     
439.         }
     
440.         if(is->pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
     
441.         {
     
442.             is->sndindex= i;
     
443.         }
     
444.     }
     
445.     if(is->videoindex== -1)
     
446.         dbmsg("no video stream found!");
     
447.     if(is->sndindex== -1)
     
448.         dbmsg("no sound stream found!");
     
449.     dbmsg("videoindex=%d, sndindex=%d", is->videoindex, is->sndindex);
     
450. 
     
451.     if(is->videoindex != -1)
     
452.     {
     
453.         is->vdoCodecCtx = is->pFormatCtx->streams[is->videoindex]->codec;
     
454.         is->vdoCodec = avcodec_find_decoder(is->vdoCodecCtx->codec_id);
     
455.         if(is->vdoCodec == NULL)
     
456.         {
     
457.             dbmsg("Codec not found");
     
458.             return -1;
     
459.         }
     
460.         if(avcodec_open2(is->vdoCodecCtx, is->vdoCodec, NULL) < 0)
     
461.             return -1;
     
462.         is->pFrameYUV = av_frame_alloc();
     
463.         is->img_convert_ctx = sws_getContext(is->vdoCodecCtx->width, is->vdoCodecCtx->height, is->vdoCodecCtx->pix_fmt,
     
464.               is->vdoCodecCtx->width, is->vdoCodecCtx->height, PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);
     
465.         if(is->img_convert_ctx == NULL)
     
466.         {
     
467.             dbmsg("img_convert error");
     
468.             return -1;
     
469.         }
     
470.         is->psscreen = SDL_SetVideoMode(is->vdoCodecCtx->width, is->vdoCodecCtx->height, 0, SDL_SWSURFACE);
     
471.         SDL_WM_SetCaption( "FFMPEG Window", NULL);
     
472.         is->overlay = SDL_CreateYUVOverlay(is->vdoCodecCtx->width, is->vdoCodecCtx->height, SDL_YV12_OVERLAY, is->psscreen);
     
473.         is->rect.x = 0;
     
474.         is->rect.y = 0;
     
475.      is->rect.w = is->vdoCodecCtx->width;
     
476.         is->rect.h = is->vdoCodecCtx->height;
     
477.         packet_queue_init(&is->videoq);
     
478.         is->video_tid = SDL_CreateThread(video_thread, is);
     
479.     }
     
480.     if(is->sndindex != -1)
     
481.     {
     
482.         is->sndCodecCtx = is->pFormatCtx->streams[is->sndindex]->codec;
     
483.         is->sndCodec = avcodec_find_decoder(is->sndCodecCtx->codec_id);
     
484.         if(is->sndCodec == NULL)
     
485.         {
     
486.             dbmsg("Codec not found");
     
487.             return -1;
     
488.         }
     
489.         if(avcodec_open2(is->sndCodecCtx, is->sndCodec, NULL) < 0)
     
490.             return -1;
     
491. 
     
492.         wanted_spec.freq = is->sndCodecCtx->sample_rate;
     
493.         wanted_spec.format = AUDIO_S16SYS;
     
494.         wanted_spec.channels = is->sndCodecCtx->channels;
     
495.         wanted_spec.silence = 0;
     
496.         wanted_spec.samples = 2048;
     
497.         wanted_spec.callback = audio_callback;
     
498.         wanted_spec.userdata = is;
     
499.         if(SDL_OpenAudio(&wanted_spec, &real_spec) < 0)
     
500.         {
     
501.             dbmsg("SDL_OpenAudio:%s", SDL_GetError());
     
502.             return -1;
     
503.         }
     
504.         //store infomation for audio swr_convert
     
505.         is->wanted_fmt = AV_SAMPLE_FMT_S16; //AUDIO_S16SYS;
     
506.         is->wanted_channel_layout = av_get_default_channel_layout(is->sndCodecCtx->channels);
     
507.         is->wanted_freq = real_spec.freq;
     
508.         is->wanted_samples = real_spec.samples;
     
509.         is->wanted_channels = real_spec.channels;
     
510.         //dbmsg("freq=%d, channels=%d, samples=%d", is->wanted_freq, is->wanted_channels, is->wanted_samples);
     
511.         packet_queue_init(&is->audioq);
     
512.         SDL_PauseAudio(0);
     
513.     }
     
514.     return 0;
     
515. }
     
516. 
     
517. int main(int argc, char **argv)
     
518. {
     
519.     int ret;
     
520.     SDL_Thread* sdl_thread;
     
521.     SDL_Thread* decode_thread_id;
     
522.     VideoState* is = (VideoState*) av_mallocz(sizeof(VideoState));
     
523. 
     
524.     if( (ret=init_ffmpeg_and_SDL(is, argv[1])) != 0)
     
525.     {
     
526.         dbmsg("init_ffmpeg_and SDL error");
     
527.         return -1;
     
528.     }
     
529. 
     
530.     is->pictq_mutex = SDL_CreateMutex();
     
531.     is->pictq_cond = SDL_CreateCond();
     
532. 
     
533.     //sdl get signal quit
     
534.     affmutex = SDL_CreateMutex();
     
535.     decode_thread_id = SDL_CreateThread(decode_thread, is);
     
536.     sdl_thread = SDL_CreateThread(sdl_event_thread, NULL);
     
537. 
     
538.     schedule_refresh(is, 40);
     
539. 
     
540.     SDL_WaitThread(sdl_thread, &ret);
     
541.     SDL_WaitThread(decode_thread_id, &ret);
     
542.     SDL_WaitThread(is->video_tid,&ret);
     
543.     SDL_DestroyMutex(affmutex);
     
544.     av_free_packet(is->packet);
     
545.     av_free(is->pFrameYUV);
     
546.     avcodec_close(is->vdoCodecCtx);
     
547.     avcodec_close(is->sndCodecCtx);
     
548.     avformat_close_input(&is->pFormatCtx);
     
549.     return 0;
     
550. }
     
551. cong@msi:/work/ffmpeg/test/4spawn$

3. 代码打包   
4spawn.rar  (下载后改名为4spawn.tar.gz )