ffmpeg中av_read_frame阻塞的原因与解决方案

曾经终败给现在 2023-01-15 12:30 167阅读 0赞

最近用到ffmpeg，想要av\_read\_frame立即返回，但是看网上的博客，都没有详细的解说，那就自己看源码。  
两种方法：  
设置回调打断函数和设置超时

超时，但是如果只设置该参数，依然会在av_read_frame中阻塞，
     av_dict_set(&inputDic, "stimeout", "2*1000*1000", 0); // milliseconds
     
     //打断回调
      m_avformatCtx->interrupt_callback.callback = interrupt_cb;
      m_avformatCtx->interrupt_callback.opaque = this;
      //两者有什么区别吗?接着往下看

//这个参数只在读内存才有效，没啥卵用
        m_avformatCtx->avio_flags |= AVIO_FLAG_NONBLOCK;

关于这两个我把整个调用代码简化后，你一看就一目了然了；  
我这里采用的rsp tcp 方式

首先最外层循环，这里检测是否满足一帧，因为这个函数必须保证读取到的包不能是半帧，必须是一帧
    static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
    { 
        int ret = 0, i, got_packet = 0;
        AVDictionary *metadata = NULL;
    
        av_init_packet(pkt);
        while (!got_packet && !s->internal->parse_queue) { 
            AVStream *st;
    
            /* read next packet */
            //关键看这里，这里去读包
            ret = ff_read_packet(s, pkt);
            if (ret < 0) { 
            //注意这里不是系统错误变量，是ffmpeg自己的错误变量
                if (ret == AVERROR(EAGAIN))
                    return ret;
                /* flush the parsers */
                for (i = 0; i < s->nb_streams; i++) { 
                    st = s->streams[i];
                    if (st->parser && st->need_parsing)
                    //如果出错，将所有包全部发出去
                        parse_packet(s, pkt, st->index, 1);
                }
                /* all remaining packets are now in parse_queue => * really terminate parsing */
                break;
            }
            //只有ret>0才说明有数据进行下一步
            parse_packet（）；
    ........（检测是否满足一帧）
    
    }

接下来我们再看ff\_read\_packet这个函数

int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
    { 
        int ret, i, err;
        AVStream *st;
    
        pkt->data = NULL;
        pkt->size = 0;
        av_init_packet(pkt);
    
    //这个for循环读取失败后可以继续读，这里是进入死循环的源头
     //假设读取失败，返回值<0，一般都是TIMEDOUT那么在这里不断循环
        for (;;) { 
            AVPacketList *pktl = s->internal->raw_packet_buffer;
            const AVPacket *pkt1;
            //一般不会进到这里面pktl为null
     if (pktl) { 
                *pkt = pktl->pkt;
                st   = s->streams[pkt->stream_index];
                if (s->internal->raw_packet_buffer_remaining_size <= 0)
                    if ((err = probe_codec(s, st, NULL)) < 0)
                        return err;
                if (st->request_probe <= 0) { 
                    s->internal->raw_packet_buffer                 = pktl->next;
                    s->internal->raw_packet_buffer_remaining_size += pkt->size;
                    av_free(pktl);
                    return 0;
                }
            }
    
            pkt->data = NULL;
            pkt->size = 0;
            av_init_packet(pkt);
            //在这里执行rtsp_demux的read_packet
          
            ret = s->iformat->read_packet(s, pkt);
            if (ret < 0) { 
                av_packet_unref(pkt);
    
                /* Some demuxers return FFERROR_REDO when they consume data and discard it (ignored streams, junk, extradata). We must re-call the demuxer to get the real packet. */
                if (ret == FFERROR_REDO)
                    continue;
                    //这里直接返回，这里就是什么都没读到，比如recv 0 返回EOF
                    //这里一般都是pktl=0，出现这个的原因是上一次网络错误，但是ret(len>0)把pktl
                    //里面的内容清空了
                if (!pktl || ret == AVERROR(EAGAIN))
                    return ret;
                    
                for (i = 0; i < s->nb_streams; i++) { 
                    st = s->streams[i];
                    if (st->probe_packets || st->request_probe > 0)
                        if ((err = probe_codec(s, st, NULL)) < 0)
                            return err;
                    av_assert0(st->request_probe <= 0);
                }
                //注意这里的continue，即使read_packet返回-1，这里还是会再次进入循环
                //比如返回ETIMEDOUT
                continue;
            }
    err = av_packet_make_refcounted(pkt);
            if (err < 0)
                return err;
    
            if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
                (pkt->flags & AV_PKT_FLAG_CORRUPT)) { 
                av_log(s, AV_LOG_WARNING,
                       "Dropped corrupted packet (stream = %d)\n",
                       pkt->stream_index);
                av_packet_unref(pkt);
                continue;
            }
    
            if (pkt->stream_index >= (unsigned)s->nb_streams) { 
                av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
                continue;
            }
    
            st = s->streams[pkt->stream_index];
    
            if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) { 
                // correct first time stamps to negative values
                if (!is_relative(st->first_dts))
                    st->first_dts = wrap_timestamp(st, st->first_dts);
                if (!is_relative(st->start_time))
                    st->start_time = wrap_timestamp(st, st->start_time);
                if (!is_relative(st->cur_dts))
                    st->cur_dts = wrap_timestamp(st, st->cur_dts);
            }
    
            pkt->dts = wrap_timestamp(st, pkt->dts);
            pkt->pts = wrap_timestamp(st, pkt->pts);
    
            //printf("dts %d pts %d streams index %d\n",pkt->dts ,pkt->pts,pkt->stream_index);//CAI
            force_codec_ids(s, st);
            //printf("end\n");
            /* TODO: audio: time filter; video: frame reordering (pts != dts) */
            if (s->use_wallclock_as_timestamps)
                pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
    //正常读取的时候从这里就返回了
            if (!pktl && st->request_probe <= 0)
                return ret;
    //将数据从s->internal转到pkt中，正常不会到这里，在上一步就返回了
            err = ff_packet_list_put(&s->internal->raw_packet_buffer,
                                     &s->internal->raw_packet_buffer_end,
                                     pkt, 0);
            if (err)
                return err;
            s->internal->raw_packet_buffer_remaining_size -= pkt->size;
    
            if ((err = probe_codec(s, st, pkt)) < 0)
                return err;
        }
    }

接下来看 ret = s->iformat->read\_packet(s, pkt)

static int rtsp_read_packet(AVFormatContext *s, AVPacket *pkt)
    { 
    //这个参数很重要，包含了AVIO_FLAG_NONBLOCK，但是在rtsp中，这个参数我们无法设置，当然设置了也没有用
        RTSPState *rt = s->priv_data;
        int ret;
        RTSPMessageHeader reply1, *reply = &reply1;
        char cmd[1024];
    retry:
    ................(略)
    略去的部分是rsp握手部分
    //在这里获取新的packet
        ret = ff_rtsp_fetch_packet(s, pkt);
        if (ret < 0) { 
            if (ret == AVERROR(ETIMEDOUT) && !rt->packets) { 
            //如果是UDP,TCP跳过
             if (rt->lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
                    rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_TCP)) { 
                    RTSPMessageHeader reply1, *reply = &reply1;
                    av_log(s, AV_LOG_WARNING, "UDP timeout, retrying with TCP\n");
                    if (rtsp_read_pause(s) != 0)
                        return -1;
                    // TEARDOWN is required on Real-RTSP, but might make
                    // other servers close the connection.
                    if (rt->server_type == RTSP_SERVER_REAL)
                        ff_rtsp_send_cmd(s, "TEARDOWN", rt->control_uri, NULL,
                                         reply, NULL);
                    rt->session_id[0] = '\0';
                    if (resetup_tcp(s) == 0) { 
                        rt->state = RTSP_STATE_IDLE;
                        rt->need_subscription = 1;
                        if (rtsp_read_play(s) != 0)
                            return -1;
                        goto retry;
                    }
                }
            }
            return ret;
        }
        rt->packets++;
        return 0;
    }

继续 ret = ff\_rtsp\_fetch\_packet(s, pkt)

int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt){ 
    //在这里度packet
        len = read_packet(s, &rtsp_st, first_queue_st, wait_end);
        }
        
    static int read_packet(AVFormatContext *s,
                           RTSPStream **rtsp_st, RTSPStream *first_queue_st,
                           int64_t wait_end)
    { 
        RTSPState *rt = s->priv_data;
        int len;
    
        switch(rt->lower_transport) { 
        default:
    #if CONFIG_RTSP_DEMUXER
        case RTSP_LOWER_TRANSPORT_TCP:
        //如果设置为tcp的话，进入这个函数，错误返回-1，正确返回len
            len = ff_rtsp_tcp_read_packet(s, rtsp_st, rt->recvbuf, RECVBUF_SIZE);
            break;//返回直接打断出来
            .............(略)
    
            if (len == 0)
            return AVERROR_EOF;
    
        return len;
            }
    
    
    
    int ff_rtsp_tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
                                uint8_t *buf, int buf_size)
    { 
        RTSPState *rt = s->priv_data;
        int id, len, i, ret;
        RTSPStream *rtsp_st;
    
        av_log(s, AV_LOG_TRACE, "tcp_read_packet:\n");
    redo:
    //这个循环其是为了寻找rtp头，在tcp rtp 发包中rtp和rtcp在一个socket中，通过 '$'区分
        for (;;) { 
            RTSPMessageHeader reply;
    //EOF只能从这里返回
            ret = ff_rtsp_read_reply(s, &reply, NULL, 1, NULL);
            if (ret < 0)
                return ret;
            if (ret == 1) /* received '$' */
                break;
            /* XXX: parse message */
            if (rt->state != RTSP_STATE_STREAMING)
                return 0;
        }//for
        
       ret = ffurl_read_complete(rt->rtsp_hd, buf, 3);
        if (ret != 3)
            return -1;
        id  = buf[0];
        len = AV_RB16(buf + 1);
        av_log(s, AV_LOG_TRACE, "id=%d len=%d\n", id, len);
        if (len > buf_size || len < 8)
            goto redo;
        
         /* get the data */
        //在这里真正读取数据，返回错误码或者字节数，
        //如果网络差，长时间就会堵塞在这里，当然也不是严格意义上的堵塞，比如len=8688
        //那么每次读取2个或者3个字节，那么在这里的堵塞时间就相当长，如果是I帧那就更加长
        //如果上一次比如transfer_func ret=-541478725出错，那么这里ret不一定是541478725，
        //是前面多次读取的累加。
        //这次出错返回，那么下一次进入的时候，读取一个字节基本也就是读取不到，那么就会返回EOF
        
        ret = ffurl_read_complete(rt->rtsp_hd, buf, len);
        ret有可能大于0，但是不等于len,比如多次读取后，最后一次超时或者EOF
        if (ret != len)
            return -1;//如果不相等，直接返回错误-1
        if (rt->transport == RTSP_TRANSPORT_RDT &&
            ff_rdt_parse_header(buf, len, &id, NULL, NULL, NULL, NULL) < 0)
            return -1;
    
        /* find the matching stream */
        for (i = 0; i < rt->nb_rtsp_streams; i++) { 
            rtsp_st = rt->rtsp_streams[i];
            if (id >= rtsp_st->interleaved_min &&
                id <= rtsp_st->interleaved_max)
                goto found;
        }
        goto redo;
    found:
        *prtsp_st = rtsp_st;
        //返回
        return len;
    }

int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
                           unsigned char **content_ptr,
                           int return_on_interleaved_data, const char *method)
    { 
        RTSPState *rt = s->priv_data;
        char buf[4096], buf1[1024], *q;
        unsigned char ch;
        const char *p;
        int ret, content_length, line_count = 0, request = 0;
        unsigned char *content = NULL;
    
    start:
        line_count = 0;
        request = 0;
        content = NULL;
        memset(reply, 0, sizeof(*reply));
    
        /* parse reply (XXX: use buffers) */
        rt->last_reply[0] = '\0';
      
        for (;;) { 
            q = buf;
              //寻找头
            for (;;) { 
                ret = ffurl_read_complete(rt->rtsp_hd, &ch, 1);
                av_log(s, AV_LOG_TRACE, "ret=%d c=%02x [%c]\n", ret, ch, ch);
                //EOF从这里返回
                if (ret != 1)
                    return AVERROR_EOF;
                    //什么时候会得到这个值？
                if (ch == '\n')
                    break;
                if (ch == '$' && q == buf) { 
                    if (return_on_interleaved_data) { 
                        return 1;
                    } else
                        ff_rtsp_skip_packet(s);
                } else if (ch != '\r') { 
                    if ((q - buf) < sizeof(buf) - 1)
                        *q++ = ch;
                }
            }
            *q = '\0';
    
            av_log(s, AV_LOG_TRACE, "line='%s'\n", buf);
    
            /* test if last line */
            if (buf[0] == '\0')
                break;
            p = buf;
            if (line_count == 0) { 
                /* get reply code */
                get_word(buf1, sizeof(buf1), &p);
                if (!strncmp(buf1, "RTSP/", 5)) { 
                    get_word(buf1, sizeof(buf1), &p);
                    reply->status_code = atoi(buf1);
                    av_strlcpy(reply->reason, p, sizeof(reply->reason));
                } else { 
                    av_strlcpy(reply->reason, buf1, sizeof(reply->reason)); // method
                    get_word(buf1, sizeof(buf1), &p); // object
                    request = 1;
                }
            } else { 
                ff_rtsp_parse_line(s, reply, p, rt, method);
                av_strlcat(rt->last_reply, p,    sizeof(rt->last_reply));
                av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
            }
            line_count++;
        }
    
        if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0' && !request)
            av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
    
        content_length = reply->content_length;
        if (content_length > 0) { 
            /* leave some room for a trailing '\0' (useful for simple parsing) */
            content = av_malloc(content_length + 1);
            if (!content)
                return AVERROR(ENOMEM);
            ffurl_read_complete(rt->rtsp_hd, content, content_length);
            content[content_length] = '\0';
        }
        if (content_ptr)
            *content_ptr = content;
        else
            av_freep(&content);
    
        if (request) { 
            char buf[1024];
            char base64buf[AV_BASE64_SIZE(sizeof(buf))];
            const char* ptr = buf;
    
            if (!strcmp(reply->reason, "OPTIONS")) { 
                snprintf(buf, sizeof(buf), "RTSP/1.0 200 OK\r\n");
                if (reply->seq)
                    av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", reply->seq);
                if (reply->session_id[0])
                    av_strlcatf(buf, sizeof(buf), "Session: %s\r\n",
                                                  reply->session_id);
            } else { 
                snprintf(buf, sizeof(buf), "RTSP/1.0 501 Not Implemented\r\n");
            }
            av_strlcat(buf, "\r\n", sizeof(buf));
    
            if (rt->control_transport == RTSP_MODE_TUNNEL) { 
                av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
                ptr = base64buf;
            }
            ffurl_write(rt->rtsp_hd_out, ptr, strlen(ptr));
    
            rt->last_cmd_time = av_gettime_relative();
            /* Even if the request from the server had data, it is not the data * that the caller wants or expects. The memory could also be leaked * if the actual following reply has content data. */
            if (content_ptr)
                av_freep(content_ptr);
            /* If method is set, this is called from ff_rtsp_send_cmd, * where a reply to exactly this request is awaited. For * callers from within packet receiving, we just want to * return to the caller and go back to receiving packets. */
            if (method)
                goto start;
            return 0;
        }
    
        if (rt->seq != reply->seq) { 
            av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",
                rt->seq, reply->seq);
        }
    
        /* EOS */
        if (reply->notice == 2101 /* End-of-Stream Reached */      ||
            reply->notice == 2104 /* Start-of-Stream Reached */    ||
            reply->notice == 2306 /* Continuous Feed Terminated */) { 
            rt->state = RTSP_STATE_IDLE;
        } else if (reply->notice >= 4400 && reply->notice < 5500) { 
            return AVERROR(EIO); /* data or server error */
        } else if (reply->notice == 2401 /* Ticket Expired */ ||
                 (reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
            return AVERROR(EPERM);
    
        return 0;
    }

真正重要的在这里：  
//只要超时或者没有读到，返回Etimeout 或者EOF

int ffurl_read_complete(URLContext *h, unsigned char *buf, int size)
    { 
    //必须保证可读
        if (!(h->flags & AVIO_FLAG_READ))
            return AVERROR(EIO);
            //注意这里的 h->prot->url_read是tcp read
        return retry_transfer_wrapper(h, buf, size, size, h->prot->url_read);
    }
    
    
    static inline int retry_transfer_wrapper(URLContext *h, uint8_t *buf,
                                             int size, int size_min,
                                             int (*transfer_func)(URLContext *h,
                                                                  uint8_t *buf,
                                                                  int size))
    { 
        int ret, len;
        int fast_retries = 5;
        int64_t wait_since = 0;
    
        len = 0;
        //这个地方很特别，如果网络比较差的时候，每次只能读取到len=1/2/3比较少的字节
        //那么就会在这里地方不停的读取，直到recv出错
        while (len < size_min) { 
        //在这里执行打断回调函数
            if (ff_check_interrupt(&h->interrupt_callback))
                return AVERROR_EXIT;
       //tcp read 回调,错误返回错误码，正确返回接受的字节数
       //ret<0有两种可能性，第一种超时ETIMEDOUT，第二种recv<)EOF
            ret = transfer_func(h, buf + len, size - len);
            if (ret == AVERROR(EINTR))
                continue;
                //如果是非阻塞字节返回，
                //h->flag是不能手动设置传入的，在代码中写死了
                //但是如果设置了非阻塞，不管返回的是错误码还是字节数，都返回。
            if (h->flags & AVIO_FLAG_NONBLOCK)
                return ret;
                //非阻塞，当返回EAGAIN时循环五次，一般情况不返还Eagain
            if (ret == AVERROR(EAGAIN)) { 
                ret = 0;
                //循环5次
                if (fast_retries) { 
                    fast_retries--;
                } else { 
                //第六次当fast_retries=0的时候
                //这里的rw_timeout也是你stimeout中传入的
                    if (h->rw_timeout) { 
                        if (!wait_since)
                            wait_since = av_gettime_relative();
                        else if (av_gettime_relative() > wait_since + h->rw_timeout)
                            return AVERROR(EIO);
                    }
                    av_usleep(1000);
                }
                //网络出错，那么返回AVERROR_EOF，因为这里多次读取len>0，所这里返回len
                //这就是为毛有些包要耗费好几秒才能获取到的原因，这次是返回len<name 下一次就直接跑到ret<0的
                //地方去了
            } else if (ret == AVERROR_EOF)
                return (len > 0) ? len : AVERROR_EOF;
                //正常从这里返回ETIMEDOUT,或者第二次的EOF
            else if (ret < 0)//比如返回ETIMEDOUT
                return ret;
            if (ret) { 
                fast_retries = FFMAX(fast_retries, 2);
                wait_since = 0;
            }
            //len不一定一次读到，或许n多次才能读取到。
            len += ret;
        }
        return len;
    }
    
    static int tcp_read(URLContext *h, uint8_t *buf, int size)
    { 
        TCPContext *s = h->priv_data;
        int ret;
    //这里设置非阻塞后就不会执行了，直接去recv
    /** * Use non-blocking mode. * If this flag is set, operations on the context will return * AVERROR(EAGAIN) if they can not be performed immediately. * If this flag is not set, operations on the context will never return * AVERROR(EAGAIN). * Note that this flag does not affect the opening/connecting of the * context. Connecting a protocol will always block if necessary (e.g. on * network protocols) but never hang (e.g. on busy devices). * Warning: non-blocking protocols is work-in-progress; this flag may be * silently ignored. */
    //#define AVIO_FLAG_NONBLOCK 8
        if (!(h->flags & AVIO_FLAG_NONBLOCK)) { 
        //返回只有错误码和0，0表示有数据过来
            ret = ff_network_wait_fd_timeout(s->fd, 0, h->rw_timeout, &h->interrupt_callback);
            if (ret)
                return ret;
        }
    //失败返回-1，并将errno设置
    //EAGAIN：套接字已标记为非阻塞，而接收操作被阻塞或者接收超时 
    //EBADF：sock不是有效的描述词 
        ret = recv(s->fd, buf, size, 0);
        //当rtsp关闭后recv返回0
        if (ret == 0)
            return AVERROR_EOF;
        return ret < 0 ? ff_neterrno() : ret;
    }
    
    int ff_network_wait_fd_timeout(int fd, int write, int64_t timeout, AVIOInterruptCB *int_cb)
    { 
        int ret;
        int64_t wait_start = 0;
    
        while (1) { 
        //如果你想退出来，在这里设置中断函数即可中断，中断函数中返回1即可，中断函数返回AVERROR_EXIT
        //你在av_read_frame中获取到的就是ret < 0，那么就看你怎么去处理av_read_frame()<0 了。
            if (ff_check_interrupt(int_cb))
                return AVERROR_EXIT;//负数
            ret = ff_network_wait_fd(fd, write);
            //超时返回WAGAIN
            if (ret != AVERROR(EAGAIN))//-10
                return ret;
               //相当于执行若干次pool循环，timeout就是我们传入的时间stimeout
               //也就是你传入的stimeout是每个tcp的超时，假设你传入了20*1000*1000，那么这里最长就是20秒
               //那么在上次5个循环的过程中假设每次都是最长的超时，那么就是20*5s,返回去再回到第一步检测包是否是完整，不完整再次进来
               //这里就变成死循环了，所以你感觉设置了stimeout好像也没什么用的原因
               //只有当其返回EOF的时候才能退出来，
               //如果返回EAGAIN执行这里，也就是返回0的时候执行这里，再将进入循环
            if (timeout > 0) { 
                if (!wait_start)
                    wait_start = av_gettime_relative();
                else if (av_gettime_relative() - wait_start > timeout)
                //在stimeout设置的时间内没有数据收到，返回ETIMEDOUT
                    return AVERROR(ETIMEDOUT);
            }
        }
    }
    
    int ff_network_wait_fd(int fd, int write)
    { 
        int ev = write ? POLLOUT : POLLIN;
        struct pollfd p = {  .fd = fd, .events = ev, .revents = 0 };
        int ret;
        //关于poll返回看这里
        //https://blog.csdn.net/qq_32642107/article/details/107291535?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-0&spm=1001.2101.3001.4242
    //#define ff_neterrno() AVERROR(errno)
    //这里是定义错误码，填入值的负数
    //#define AVERROR(e) (-(e)) ///< Returns a negative error code from a POSIX error code, to return from library //functions.
        ret = poll(&p, 1, POLLING_TIME);
        //如果小于0直接返回错误码，否则返回0或者EAGAIN
       // 当一个socket出现错误时（例如 连接断开/拒绝/超时），epoll()会返回POLLERR加上注册时的POLLIN/POLLOUT事件。所以，如果监听的是 //POLLOUT，那epoll_wait()会返回POLLOUT|POLLERR；如果监听的是POLLIN，那epoll_wait()会返回POLLIN|POLLERR。
       //总之poll返回POLLERR | POLLHUP是socket出问题了，超时返回0,然后映射为-10
        return ret < 0 ? ff_neterrno() : p.revents & (ev | POLLERR | POLLHUP) ? 0 : AVERROR(EAGAIN);
    }

events 和 revents 结合下列常数值(宏)指定即将唤醒的事件或调查已结束的 poll() 函数被唤醒的原因，这些宏常数如下：  
POLLIN  
events 中使用该宏常数，能够在折本文件的可读情况下，结束 poll() 函数。相反，revents 上使用该宏常数，在检查 poll() 函数结束后，可依此判断设备文件是否处于可读状态(即使消息长度是 0)。

POLLPRI  
在 events 域中使用该宏常数，能够在设备文件的高优先级数据读取状态下，结束 poll() 函数。相反，revents 上使用该宏常数，在检查 poll() 函数结束后，可依此判断设备文件是否处于可读高优先级数据的状态(即使消息长度是 0)。该宏常数用于处理网络信息包(packet) 的数据传递。

POLLOUT  
在 events 域中使用该宏常数，能够在设备文件的写入状态下，结束 poll() 函数。相反，revents 域上使用该宏常数，在检查 poll() 结束后，可依此判断设备文件是否处于可写状态。

POLLERR  
在 events 域中使用该宏常数，能够在设备文件上发生错误时，结束 poll()　函数。相反，revents　域上使用该宏函数，在检查 poll()　函数结束后，可依此判断设备文件是否出错。

POLLHUP  
在 events　域中使用该宏常数，能够在设备文件中发生 hungup　时，结束 poll() 函数 。相反，在检查 poll() 结束后，可依此判断设备文件是否发生 hungup 。

POLLNVAL  
在 events 域中使用该宏函数，能够在文件描述符的值无效时，结束 poll() 。相反，在 revents 域上使用该宏函数时，在检查 poll() 函数后，文件描述符是否有效。可用于处理网络信息时，检查 socket handler 是否已经无效。

和 select 一样，最后一个参数 timeout 指定 poll() 将在超时前等待一个事件多长事件。这里有 3 种情况：

1.  timeout 为 -1  
    这会造成 poll 永远等待。poll() 只有在一个描述符就绪时返回，或者在调用进程捕捉到信号时返回(在这里，poll 返回 -1)，并且设置 errno 值为 EINTR 。-1 可以用宏定义常量 INFTIM 来代替(在 pth.h 中有定义) 。
2.  timeout 等于0  
    在这种情况下，测试所有的描述符，并且 poll() 立刻返回。这允许在 poll 中没有阻塞的情况下找出多个文件描述符的状态。
3.  time > 0 这将以毫秒为单位指定 timeout 的超时周期。poll() 只有在超时到期时返回，除非一个描述符变为就绪，在这种情况下，它立刻返回。如果超时周期到齐，poll() 返回 0。这里也可能会因为某个信号而中断该等待。 和 select 一样，文件描述符是否阻塞对 poll 是否阻塞没有任何影响  
    这里有错误码：

/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
    #ifndef _ASM_GENERIC_ERRNO_BASE_H
    #define _ASM_GENERIC_ERRNO_BASE_H
    
    #define EPERM 1 /* Operation not permitted */
    #define ENOENT 2 /* No such file or directory */
    #define ESRCH 3 /* No such process */
    #define EINTR 4 /* Interrupted system call */
    #define EIO 5 /* I/O error */
    #define ENXIO 6 /* No such device or address */
    #define E2BIG 7 /* Argument list too long */
    #define ENOEXEC 8 /* Exec format error */
    #define EBADF 9 /* Bad file number */
    #define ECHILD 10 /* No child processes */
    #define EAGAIN 11 /* Try again */
    #define ENOMEM 12 /* Out of memory */
    #define EACCES 13 /* Permission denied */
    #define EFAULT 14 /* Bad address */
    #define ENOTBLK 15 /* Block device required */
    #define EBUSY 16 /* Device or resource busy */
    #define EEXIST 17 /* File exists */
    #define EXDEV 18 /* Cross-device link */
    #define ENODEV 19 /* No such device */
    #define ENOTDIR 20 /* Not a directory */
    #define EISDIR 21 /* Is a directory */
    #define EINVAL 22 /* Invalid argument */
    #define ENFILE 23 /* File table overflow */
    #define EMFILE 24 /* Too many open files */
    #define ENOTTY 25 /* Not a typewriter */
    #define ETXTBSY 26 /* Text file busy */
    #define EFBIG 27 /* File too large */
    #define ENOSPC 28 /* No space left on device */
    #define ESPIPE 29 /* Illegal seek */
    #define EROFS 30 /* Read-only file system */
    #define EMLINK 31 /* Too many links */
    #define EPIPE 32 /* Broken pipe */
    #define EDOM 33 /* Math argument out of domain of func */
    #define ERANGE 34 /* Math result not representable */
    
    #endif