ffmpeg 0.6.3 能用的tutorial06

最新推荐文章于 2017-07-04 19:10:27 发布
转载 最新推荐文章于 2017-07-04 19:10:27 发布 · 529 阅读 · 0

本文介绍了一个基于FFmpeg的教育视频播放器实现，通过解析音视频数据并同步播放，涉及音视频同步处理、视频解码显示及音频解码播放等关键技术。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

编译命令：
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.

  18. #include <libavcodec/avcodec.h> 
  19. #include <libavformat/avformat.h> 
  20. #include <libswscale/swscale.h> 

  22. #include <SDL.h>
  23. #include <SDL_thread.h>

  25. #ifdef __MINGW32__
  26. #undef main /* Prevents SDL from overriding main() */
  27. #endif

  29. #include <stdio.h>
  30. #include <math.h>

  32. #define SDL_AUDIO_BUFFER_SIZE 1024

  34. #define MAX_AUDIOQ_SIZE (5 * 16 * 1024)
  35. #define MAX_VIDEOQ_SIZE (5 * 256 * 1024)

  37. #define AV_SYNC_THRESHOLD 0.01
  38. #define AV_NOSYNC_THRESHOLD 10.0

  40. #define SAMPLE_CORRECTION_PERCENT_MAX 10
  41. #define AUDIO_DIFF_AVG_NB 20

  43. #define FF_ALLOC_EVENT (SDL_USEREVENT)
  44. #define FF_REFRESH_EVENT (SDL_USEREVENT + 1)
  45. #define FF_QUIT_EVENT (SDL_USEREVENT + 2)

  47. #define VIDEO_PICTURE_QUEUE_SIZE 1

  49. #define DEFAULT_AV_SYNC_TYPE AV_SYNC_VIDEO_MASTER

  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;


  60. typedef struct VideoPicture {
  61.   SDL_Overlay *bmp;
  62.   int width, height; /* source height & width */
  63.   int allocated;
  64.   double pts;
  65. } VideoPicture;

  67. typedef struct VideoState {

  69.   AVFormatContext *pFormatCtx;
  70.   int videoStream, audioStream;

  72.   int av_sync_type;
  73.   double external_clock; /* external clock base */
  74.   int64_t external_clock_time;

  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;

  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;

  107.   char filename[1024];
  108.   int quit;
  109.   struct SwsContext *img_convert_ctx; 
  110. } VideoState;

  112. enum {
  113.   AV_SYNC_AUDIO_MASTER,
  114.   AV_SYNC_VIDEO_MASTER,
  115.   AV_SYNC_EXTERNAL_MASTER,
  116. };

  118. SDL_Surface *screen;

  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;

  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) {

  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);

  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;

  160.   SDL_LockMutex(q->mutex);
  161.   
  162.   for(;;) {
  163.     
  164.     if(global_video_state->quit) {
  165.       ret = -1;
  166.       break;
  167.     }

  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;

  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;

  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. }

  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;

  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;

  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;

  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. }

  287. int audio_decode_frame(VideoState *is, uint8_t *audio_buf, int buf_size, double *pts_ptr) {

  289.   int len1, data_size, n;
  290.   AVPacket *pkt = &is->audio_pkt;
  291.   double pts;

  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);

  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);

  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. }

  338. void audio_callback(void *userdata, Uint8 *stream, int len) {

  340.   VideoState *is = (VideoState *)userdata;
  341.   int len1, audio_size;
  342.   double pts;

  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. }

  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. }

  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. }

  382. void video_display(VideoState *is) {

  384.   SDL_Rect rect;
  385.   VideoPicture *vp;
  386.   AVPicture pict;
  387.   float aspect_ratio;
  388.   int w, h, x, y;
  389.   int i;

  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. }

  420. void video_refresh_timer(void *userdata) {

  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];

  432.       is->video_current_pts = vp->pts;
  433.       is->video_current_pts_time = av_gettime();

  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;

  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.       }

  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));

  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) {

  489.   VideoState *is = (VideoState *)userdata;
  490.   VideoPicture *vp;

  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);

  510. }

  512. int queue_picture(VideoState *is, AVFrame *pFrame, double pts) {

  514.   VideoPicture *vp;
  515.   int dst_pix_fmt;
  516.   AVPicture pict;

  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);

  526.   if(is->quit)
  527.     return -1;

  529.   // windex is set to 0 initially
  530.   vp = &is->pictq[is->pictq_windex];

  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;

  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);

  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? */


  559.   if(vp->bmp) {

  561.     SDL_LockYUVOverlay(vp->bmp);
  562.     
  563.     dst_pix_fmt = PIX_FMT_YUV420P;
  564.     /* point pict at the queue */

  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;

  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. }

  601. double synchronize_video(VideoState *is, AVFrame *src_frame, double pts) {

  603.   double frame_delay;

  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. }

  620. uint64_t global_video_pkt_pts = AV_NOPTS_VALUE;

  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. }

  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;

  645.   pFrame = avcodec_alloc_frame();

  647.   for(;;) {
  648.     if(packet_queue_get(&is->videoq, packet, 1) < 0) {
  649.       // means we quit getting packets
  650.       break;
  651.     }
  652.     pts = 0;

  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);

  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. }

  682. int stream_component_open(VideoState *is, int stream_index) {

  684.   AVFormatContext *pFormatCtx = is->pFormatCtx;
  685.   AVCodecContext *codecCtx;
  686.   AVCodec *codec;
  687.   SDL_AudioSpec wanted_spec, spec;

  689.   if(stream_index < 0 || stream_index >= pFormatCtx->nb_streams) {
  690.     return -1;
  691.   }

  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.   }

  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;

  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];

  748.     is->frame_timer = (double)av_gettime() / 1000000.0;
  749.     is->frame_last_delay = 40e-3;
  750.     is->video_current_pts_time = av_gettime();

  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.   }


  762. }

  764. int decode_interrupt_cb(void) {
  765.   return (global_video_state && global_video_state->quit);
  766. }

  768. int decode_thread(void *arg) {

  770.   VideoState *is = (VideoState *)arg;
  771.   AVFormatContext *pFormatCtx;
  772.   AVPacket pkt1, *packet = &pkt1;

  774.   int video_index = -1;
  775.   int audio_index = -1;
  776.   int i;

  778.   is->videoStream=-1;
  779.   is->audioStream=-1;

  781.   global_video_state = is;
  782.   // will interrupt blocking functions if we 
  783.   url_set_interrupt_cb(decode_interrupt_cb);

  785.   // Open video file
  786.   if(av_open_input_file(&pFormatCtx, is->filename, NULL, 0, NULL)!=0)
  787.     return -1; // Couldn't open file

  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

  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.   } 

  817.   if(is->videoStream < 0 || is->audioStream < 0) {
  818.     fprintf(stderr, "%s: could not open codecs\n", is->filename);
  819.     goto fail;
  820.   }

  822.   // main decode loop

  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.   }

  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. }

  866. int main(int argc, char *argv[]) {

  868.   SDL_Event event;

  870.   VideoState *is;

  872.   is = av_mallocz(sizeof(VideoState));

  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.   }

  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.   }

  897.   av_strlcpy(is->filename, argv[1], sizeof(is->filename));

  899.   is->pictq_mutex = SDL_CreateMutex();
  900.   is->pictq_cond = SDL_CreateCond();

  902.   schedule_refresh(is, 40);

  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(;;) {

  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;

  932. }

利用ffmpeg0.6.1把.h264纯码流打包成.mp4 .avi等格式
zhuqing_739的专栏
07-27 1万+
一直比较困惑一个问题，都说ffmpeg功能很强大，但是自己一直没有去研究一下，今天终于见识了一下它的强大之处了！ 首先当然是在linux下编译和安装成功ffmpeg，关于具体的安装流程，可以参考我前面的一篇博文！ 这里就直接介绍怎么把.h264纯码流打包成.mp4 .avi等格式，我想这个问题也一定有很多网友在研究中，希望可以帮助到大家！ 说白了，其实只要ffmpeg安装成功，打成各种格式一
[免费高清PDF]FFmpeg Tutorial.pdf(中文版).rar
05-07
[免费高清PDF]FFmpeg Tutorial.pdf(中文版).rar
An ffmpeg and SDL Tutorial 学习笔记（七）
STN_LCD的专栏
07-04 477
官网： http://dranger.com/ffmpeg/tutorial07.html Tutorial 07: Seeking Code: tutorial07.c Handling the seek command Now we're going to add some seeking capabilities to our player, because it's
ffmpeg0.6例程
12-17 462
ffmpeg0.6例程 gcc -o test tutorial01.c-lavcodec -lavformat -lswscale -lavutil -I/opt/ffmpeg-x86/include-L/opt/ffmpeg-x86/lib ./test input.avi // tutorial01.c // Code based on a tutor
ffmpeg的tutorial中文版学习笔记(七)
坤哥的学习笔记
07-15 1774
指导7：快进快退 处理快进快退命令 现在我们来为我们的播放器加入一些快进和快退的功能，因为如果你不能全局搜索一部电影是很让人讨厌的。同时，这将告诉你av_seek_frame函数是多么容易使用。 我们将在电影播放中使用左方向键和右方向键来表示向后和向前一小段，使用向上和向下键来表示向前和向后一大段。这里一小段是10秒，一大段是60 秒。所以 我们需要设置我们的主循环来捕捉键盘
ffmpeg-0.6 linux下编译安装
12-18 701
最近学习ffmpeg，需要安装ffmpeg  ubuntu10.04,环境中成功安装，记录一下。 1.安装编译环境  1)gcc/gcc-c++/gdb/make等工具   sudo apt-get install build-essential  2)    sudo apt-get install automake  3)   sudo apt-get install libto
ffmpeg 0.6.3 能用的tutorial07
w_ww_w的专栏
12-19 1106
编译命令： gcc -o tutorial04 tutorial04.c -lavformat -lavcodec -lz -lm -lswscale `sdl-config --cflags --libs` 点击(此处)折叠或打开 // tutorial07.c // A pedagogical video player that really
ffmpeg 0.6.3 能用的tutorial01
w_ww_w的专栏
12-19 581
使用编译命令： gcc -o tutorial01 tutorial01.c -lavutil -lavformat -lavcodec -lswscale 源程序如下： #include    #include    #include       #include       #define debug() fprintf(stderr,"%s#%i\n",__func
ffmpeg 0.6.3 能用的tutorial03
w_ww_w的专栏
12-19 500
编译totorial03.c的命令为： gcc -o tutorial03 tutorial03.c -lavformat -lavcodec -lz -lm -lswscale `sdl-config --cflags --libs` 点击(此处)折叠或打开 #include libavcodec/avcodec.h>      #include
ffmpeg-0.6.3.zip_ffmpeg 0.6_ffmpeg 0.6.3_ffmpeg-0.6.3
09-14
FFmpeg 是一个强大的开源多媒体处理工具，用于处理音频和视频文件。...总的来说，学习和研究"ffmpeg-0.6.3.zip"不仅能够提升个人在多媒体处理领域的专业技能，也能为开发自定义的多媒体应用打下坚实基础。
ffmpeg 0.6.3
11-20
Fmpeg is a complete, cross-platform solution to record, convert and stream audio and video. It includes libavcodec - the leading audio/video codec library
ffmpeg 0.6.3源代码优化学习分享
资源摘要信息: "ffmpeg-0.6.3.zip_ffmpeg 0.6_ffmpeg 0.6.3_ffmpeg-0.6.3" 知识点: 1. FFmpeg简介 FFmpeg是一个开源的多媒体框架，用于记录、转换数字音频、视频，并能够将其流化。它提供了录制、转换（视频、...
FFmpeg 0.6.3：Windows开发环境配置指南及资源下载
FFmpeg作为一个强大的媒体处理框架，不仅广泛应用于商业软件中，也常被开发者用在开源项目中。它强大的功能和灵活性使其成为处理音视频流和文件的事实标准。开发者们可以利用FFmpeg来实现各种媒体处理功能，如音视频...
FFmpeg 0.6.3 代码修改与VS2005环境配置详解
“ffmpeg_0.6.3_window.txt”文件很可能是提供给用户关于如何在Windows环境下使用和编译FFmpeg的说明文档。在软件开发中，文档的提供是十分重要的，它有助于开发者快速了解如何设置开发环境，以及如何进行软件的编译...
ffmpeg编译安装v0.6.3
w_ww_w的专栏
12-19 833
在http://www.ffmpeg.org/download.html 下载ffmpeg0.6.3版本或使用上传的文件 终端下依次运行以下命令： 1 2 3 4 5 #tar zxvf ffmpeg-0.6.3.tar.gz #cd ffmpeg-0.6.3 #./configure --pre
电赛历年试题&经验分享.7z
08-12
电赛历年试题&经验分享.7z
PLC立体车库智能仿真系统：基于博途V15的西门子1200PLC控制与触摸屏操作 - PLC编程 v1.5
08-12
基于博途V15软件平台构建的3×2立体车库智能仿真系统。该系统采用西门子1200PLC进行控制，配备触摸屏操作界面，实现了自动出入库、电梯式小车移动以及变频器输出等功能。文中展示了详细的程序注释和模块化编程方法，如使用TON定时器实现载车板升降的速度控制，利用FC块封装车辆检测模块，通过GRAPH语言编写自动出入库逻辑等。此外，还提到了系统的IO表设计和故障处理机制，以及未来可能加入AI算法进行智能车位分配的设想。 适合人群：对PLC编程、工业自动化控制系统感兴趣的工程师和技术爱好者。 使用场景及目标：适用于学习和研究PLC编程技巧、工业自动化控制系统的仿真开发，帮助理解和掌握PLC控制逻辑、触摸屏交互设计、变频器仿真等关键技术。 其他说明：该项目不仅提供了完整的源代码和详细的注释，还能在博途PLCSIM Advanced环境中进行全仿真测试，为实际工程应用提供宝贵的经验和参考。
LuWu-陆吾，一个简单的无代码深度学习平台
08-12
资源下载链接为： https://pan.quark.cn/s/2f73b93e37c3 LuWu——陆吾，一个简单的无代码深度学习平台。（最新、最全版本！打开链接下载即可用！）
Python自动化测试框架pytest入门与实战.doc
最新发布
08-12
Python自动化测试框架pytest入门与实战.doc
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值