ffmpeg中时间戳同步问题

jctian

ffmpeg中的正确的pts应该是怎样变化？怎么实现音频同步到视频。。。

孙悟空

1.     if (oc->oformat->flags & AVFMT_RAWPICTURE) {
   
2.         /* Raw video case - directly store the picture in the packet */
   
3.         AVPacket pkt;
   
4.         av_init_packet(&pkt);
   
5. 
   
6.         pkt.flags        |= AV_PKT_FLAG_KEY;
   
7.         pkt.stream_index  = st->index;
   
8.         pkt.data          = dst_picture.data[0];
   
9.         pkt.size          = sizeof(AVPicture);
   
10. 
    
11.         ret = av_interleaved_write_frame(oc, &pkt);
    
12.     } else {
    
13.         AVPacket pkt = { 0 };
    
14.         int got_packet;
    
15.         av_init_packet(&pkt);
    
16. 
    
17.         /* encode the image */
    
18.         ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);  ////看这里
    
19.         if (ret < 0) {
    
20.             fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));
    
21.             exit(1);
    
22.         }
    
23.         /* If size is zero, it means the image was buffered. */
    
24. 
    
25.         if (!ret && got_packet && pkt.size) {
    
26.             pkt.stream_index = st->index;
    
27. 
    
28.             /* Write the compressed frame to the media file. */
    
29.             ret = av_interleaved_write_frame(oc, &pkt);
    
30.         } else {
    
31.             ret = 0;
    
32.         }
    
33.     }
    

复制代码

根据上面的代码可以知道，是在encode 的时候计算出来的pkt的pts的，当然，你也可以在encode以后去修改pts

那么encode怎么得到的pkt呢
可以看encode里面的具体实现

1. int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
   
2.                                               AVPacket *avpkt,
   
3.                                               const AVFrame *frame,
   
4.                                               int *got_packet_ptr)
   
5. {
   
6.     int ret;
   
7.     AVPacket user_pkt = *avpkt;
   
8.     int needs_realloc = !user_pkt.data;
   
9. 
   
10.     *got_packet_ptr = 0;
    
11. 
    
12.     if(CONFIG_FRAME_THREAD_ENCODER &&
    
13.        avctx->internal->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))
    
14.         return ff_thread_video_encode_frame(avctx, avpkt, frame, got_packet_ptr);
    
15. 
    
16.     if ((avctx->flags&CODEC_FLAG_PASS1) && avctx->stats_out)
    
17.         avctx->stats_out[0] = '\0';
    
18. 
    
19.     if (!(avctx->codec->capabilities & CODEC_CAP_DELAY) && !frame) {
    
20.         av_free_packet(avpkt);
    
21.         av_init_packet(avpkt);
    
22.         avpkt->size = 0;
    
23.         return 0;
    
24.     }   
    
25. 
    
26.     if (av_image_check_size(avctx->width, avctx->height, 0, avctx))
    
27.         return AVERROR(EINVAL);
    
28. 
    
29.     av_assert0(avctx->codec->encode2);
    
30. 
    
31.     ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr); ///////看这里
    
32.     av_assert0(ret <= 0);
    
33. 
    
34.     if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
    
35.         needs_realloc = 0;
    
36.         if (user_pkt.data) {
    
37.             if (user_pkt.size >= avpkt->size) {
    
38.                 memcpy(user_pkt.data, avpkt->data, avpkt->size);
    
39.             } else {
    
40.                 av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
    
41.                 avpkt->size = user_pkt.size;
    
42.                 ret = -1;
    
43.             }   
    
44.             avpkt->buf      = user_pkt.buf;

复制代码

这个encode代码是在libavcodec/utils.c里面

在ffmpeg里面这个utils是一个主要的switcher，每一个codec都是以模块的形式加载的，通过这个switcher进入对应的编解码模块中
下面可以假设是mpeg4编码，那么就进入如下接口中

1. 
   
2. AVCodec ff_mpeg4_encoder = {
   
3.     .name           = "mpeg4",
   
4.     .type           = AVMEDIA_TYPE_VIDEO,
   
5.     .id             = AV_CODEC_ID_MPEG4,
   
6.     .priv_data_size = sizeof(MpegEncContext),
   
7.     .init           = encode_init,
   
8.     .encode2        = ff_MPV_encode_picture,  //////进入到这个接口中，这个在registerall的时候就已经注册了
   
9.     .close          = ff_MPV_encode_end,
   
10.     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
    
11.     .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
    
12.     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
    
13.     .priv_class     = &mpeg4enc_class,
    
14. };
    

复制代码

如果使用的mpeg4编码时，前面的可以跟进入这个 ff_MPV_encode_picture中

1. 
   
2.        pkt->pts = s->current_picture.f.pts;
   
3.         if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
   
4.             if (!s->current_picture.f.coded_picture_number)
   
5.                 pkt->dts = pkt->pts - s->dts_delta;
   
6.             else
   
7.                 pkt->dts = s->reordered_pts;
   
8.             s->reordered_pts = pkt->pts;
   
9.         } else
   
10.             pkt->dts = pkt->pts;
    
11.         if (s->current_picture.f.key_frame)
    
12.             pkt->flags |= AV_PKT_FLAG_KEY;
    
13.         if (s->mb_info)
    
14.             av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
    

复制代码

从这段代码可以看出，pts是从s->current_picture.f.pts中获得的，然后根据判断图像是否有延迟，然后进行pts-dts_delta计算得来的
这个 s->current_picture.f.pts即为AVFrame的pts,至于这个AVFrame的pts怎么得到的，可以找到如下实现，也是mpeg4里面计算得到的

1. 
   
2. static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
   
3. {
   
4.     Picture *pic = NULL;
   
5.     int64_t pts;
   
6.     int i, display_picture_number = 0, ret;
   
7.     const int encoding_delay = s->max_b_frames ? s->max_b_frames :
   
8.                                                  (s->low_delay ? 0 : 1);
   
9.     int direct = 1;
   
10. 
    
11.     if (pic_arg) {
    
12.         pts = pic_arg->pts;
    
13.         display_picture_number = s->input_picture_number++;
    
14. 
    
15.         if (pts != AV_NOPTS_VALUE) {
    
16.             if (s->user_specified_pts != AV_NOPTS_VALUE) {
    
17.                 int64_t last = s->user_specified_pts;
    
18. 
    
19.                 if (pts <= last) {
    
20.                     av_log(s->avctx, AV_LOG_ERROR,
    
21.                            "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
    
22.                            pts, last);
    
23.                     return AVERROR(EINVAL);
    
24.                 }
    
25. 
    
26.                 if (!s->low_delay && display_picture_number == 1)
    
27.                     s->dts_delta = pts - last;
    
28.             }
    
29.             s->user_specified_pts = pts;
    
30.         } else {
    
31.             if (s->user_specified_pts != AV_NOPTS_VALUE) {
    
32.                 s->user_specified_pts =
    
33.                 pts = s->user_specified_pts + 1;
    
34.                 av_log(s->avctx, AV_LOG_INFO,
    
35.                        "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
    
36.                        pts);
    
37.             } else {
    
38.                 pts = display_picture_number;
    
39.             }
    
40.         }
    
41.     }
    
42.    if (pic_arg) {
    
43.         if (!pic_arg->buf[0])
    
44.             direct = 0;
    
45.         if (pic_arg->linesize[0] != s->linesize)
    
46.             direct = 0;
    
47.         if (pic_arg->linesize[1] != s->uvlinesize)
    
48.             direct = 0;
    
49.         if (pic_arg->linesize[2] != s->uvlinesize)
    
50.             direct = 0;
    
51. 
    
52.         av_dlog(s->avctx, "%d %d %d %d\n", pic_arg->linesize[0],
    
53.                 pic_arg->linesize[1], s->linesize, s->uvlinesize);
    
54. 
    
55.         if (direct) {
    
56.             i = ff_find_unused_picture(s, 1);
    
57.             if (i < 0)
    
58.                 return i;
    
59. 
    
60.             pic = &s->picture[i];
    
61.             pic->reference = 3;
    
62. 
    
63.             if ((ret = av_frame_ref(&pic->f, pic_arg)) < 0)
    
64.                 return ret;
    
65.             if (ff_alloc_picture(s, pic, 1) < 0) {
    
66.                 return -1;
    
67.             }
    
68.         } else {
    
69.             i = ff_find_unused_picture(s, 0);
    
70.             if (i < 0)
    
71.                 return i;
    
72. 
    
73.             pic = &s->picture[i];
    
74.             pic->reference = 3;
    
75. 
    
76.             if (ff_alloc_picture(s, pic, 0) < 0) {
    
77.                 return -1;
    
78.             }
    
79. 
    
80.             if (pic->f.data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
    
81.                 pic->f.data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
    
82.                 pic->f.data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
    
83.                 // empty
    
84.             } else {
    
85.                int h_chroma_shift, v_chroma_shift;
    
86.                 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
    
87.                                                  &h_chroma_shift,
    
88.                                                  &v_chroma_shift);
    
89. 
    
90.                 for (i = 0; i < 3; i++) {
    
91.                     int src_stride = pic_arg->linesize[i];
    
92.                     int dst_stride = i ? s->uvlinesize : s->linesize;
    
93.                     int h_shift = i ? h_chroma_shift : 0;
    
94.                     int v_shift = i ? v_chroma_shift : 0;
    
95.                     int w = s->width  >> h_shift;
    
96.                     int h = s->height >> v_shift;
    
97.                     uint8_t *src = pic_arg->data[i];
    
98.                     uint8_t *dst = pic->f.data[i];
    
99. 
    
100.                     if (s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)) {
     
101.                         h = ((s->height + 15)/16*16) >> v_shift;
     
102.                     }
     
103. 
     
104.                     if (!s->avctx->rc_buffer_size)
     
105.                         dst += INPLACE_OFFSET;
     
106. 
     
107.                     if (src_stride == dst_stride)
     
108.                         memcpy(dst, src, src_stride * h);
     
109.                     else {
     
110.                         int h2 = h;
     
111.                         uint8_t *dst2 = dst;
     
112.                         while (h2--) {
     
113.                             memcpy(dst2, src, w);
     
114.                             dst2 += dst_stride;
     
115.                             src += src_stride;
     
116.                         }
     
117.                     }
     
118.                     if ((s->width & 15) || (s->height & 15)) {
     
119.                         s->dsp.draw_edges(dst, dst_stride,
     
120.                                           w, h,
     
121.                                           16>>h_shift,
     
122.                                           16>>v_shift,
     
123.                                           EDGE_BOTTOM);
     
124.                     }
     
125.                 }
     
126.             }
     
127.         }
     
128.         ret = av_frame_copy_props(&pic->f, pic_arg);
     
129.         if (ret < 0)
     
130.             return ret;
     
131. 
     
132.         pic->f.display_picture_number = display_picture_number;
     
133.         pic->f.pts = pts; // we set this here to avoid modifiying pic_arg
     
134.     }
     
135. 
     
136.     /* shift buffer entries */
     
137.     for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
     
138.         s->input_picture[i - 1] = s->input_picture[i];
     
139. 
     
140.     s->input_picture[encoding_delay] = (Picture*) pic;
     
141. 
     
142.     return 0;
     
143. }
     
144. 
     

复制代码

从这段代码中可以看到AVFrame的pts或得到了


至于你说的音视频同步，是通过一个flag
video_sync_method或者audio_sync_method

1. 
   
2.     format_video_sync = video_sync_method;
   
3.     if (format_video_sync == VSYNC_AUTO)
   
4.         format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : VSYNC_CFR;
   
5. 
   
6.     switch (format_video_sync) {
   
7.     case VSYNC_CFR:
   
8.         // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
   
9.         if (delta < -1.1)
   
10.             nb_frames = 0;
    
11.         else if (delta > 1.1)
    
12.             nb_frames = lrintf(delta);
    
13.         break;
    
14.     case VSYNC_VFR:
    
15.         if (delta <= -0.6)
    
16.             nb_frames = 0;
    
17.         else if (delta > 0.6)
    
18.             ost->sync_opts = lrint(sync_ipts);
    
19.         break;
    
20.     case VSYNC_DROP:
    
21.     case VSYNC_PASSTHROUGH:
    
22.         ost->sync_opts = lrint(sync_ipts);
    
23.         break;
    
24.     default:
    
25.         av_assert0(0);
    
26.     }
    
27. 
    

复制代码

这样来判断的

時桄゛

Mark一下

洛月

mark

keyix

MARK.

sansir

音视频同步的处理没看太明白