void VideoStream::play_proc()
{
    AVPacket packet;
    int skiped_frames = 0;
    uint64_t frame_delay_i = 0;
    m_current_dts = 0;
    m_frameIdx = 0;
    uint64_t next_ts;
    m_thread_runned = true;
    #if LIBAVCODEC_VERSION_MAJOR > 56
    int ret;
    #else
    int frameFinished = false;
    #endif

    InitNullPacket(&packet);

    do
    {
        if (m_seek_target)
        {
            if (!av_seek_frame(m_av_ctx, m_video_stream_idx, m_seek_target / (av_q2d(m_videoStream->time_base) * 1000.d),
                               AVSEEK_FLAG_BACKWARD))
                avcodec_flush_buffers(m_codec_ctx);
            m_paused = false;
        }
        while (m_paused)
            std::this_thread::sleep_for(std::chrono::milliseconds(100));

        while ((!m_stoped) && (!m_paused) && (m_frameIdx < m_frames_count))
        {
            bool readed = (av_read_frame(m_av_ctx, &packet)>=0);
            if (m_pause_start)
            {
                m_start_ts += m_pause_start;
                m_pause_start = 0;
            }

            if(packet.stream_index==m_video_stream_idx)
            {
                m_frame_mtx.lock();

                #if LIBAVCODEC_VERSION_MAJOR > 56
                if (avcodec_send_packet(m_codec_ctx, &packet) < 0)
                {
                    m_frame_mtx.unlock();
                    break;
                }

                ret = avcodec_receive_frame(m_codec_ctx, m_frame);
                if (ret == AVERROR(EAGAIN))
                {
                    av_packet_unref(&packet);
                    m_frame_mtx.unlock();
                    continue;
                }
                if ((ret < 0) && (ret != AVERROR_EOF))
                {
                    m_frame_mtx.unlock();
                    break;
                }
                #else
                avcodec_decode_video2(m_codec_ctx, m_frame, &frameFinished, &packet);
                #endif


                #if LIBAVCODEC_VERSION_MAJOR > 56
                if ((!readed) && (m_codec_ctx->has_b_frames))
                #else
                if ((!readed) && (!frameFinished) && (m_codec_ctx->has_b_frames))
                #endif
                {
                    AVPacket NullPacket;
                    InitNullPacket(&NullPacket);
                    #if LIBAVCODEC_VERSION_MAJOR > 56
                    if (avcodec_send_packet(m_codec_ctx, &NullPacket) < 0)
                    {
                        m_frame_mtx.unlock();
                        break;
                    }

                    ret = avcodec_receive_frame(m_codec_ctx, m_frame);
                    if ((ret < 0) && (ret != AVERROR(EAGAIN)) && (ret != AVERROR_EOF))
                    {
                        m_frame_mtx.unlock();
                        break;
                    }
                    #else
                    avcodec_decode_video2(m_codec_ctx, m_frame, &frameFinished, &NullPacket);
                    #endif
                }
                int64_t frame_dts = m_frame->pkt_dts;
                m_frame_mtx.unlock();

                if (is_preview)
                    pause();

                if (m_stoped)
                    break;

                m_frameIdx++;

                if (m_speed != 1)
                {
                    if (skiped_frames < (m_speed - 1))
                    {
                        skiped_frames++;
                        av_packet_unref(&packet);
                        continue;
                    }
                    skiped_frames = 0;
                }

                double frame_delay = 1.0f / av_q2d(m_videoStream->avg_frame_rate);
                if (frame_delay == 0.0d)
                    frame_delay_i =  m_frameIdx ? frame_dts / m_frameIdx : 0;
                else
                    frame_delay_i =  frame_delay * 1000;
                m_current_dts += frame_delay_i;

                if (m_seek_target)
                {
                    m_frameIdx = frame_dts * m_frames_count / m_duration_dts;
                    if ((m_start_ts + frame_delay_i * m_frameIdx) < m_seek_target)
                        continue;
                    else
                    {
                        if (m_current_dts > m_seek_target)
                            m_start_ts += m_current_dts;
                        else
                            m_start_ts -= m_seek_target;
                        m_current_dts = m_seek_target;
                        m_seek_target = 0;
                    }
                }

                next_ts = m_start_ts + m_current_dts;

                frame_present = (m_frameIdx < m_frames_count);
                first_frame_present = true;

                while ((!m_stoped) && (next_ts > Utils::get_ts()))
                    std::this_thread::sleep_for(std::chrono::milliseconds(frame_delay_i / 10));
            }
            av_packet_unref(&packet);
        }
        if ((!m_stoped) && (m_looped))
        {
            seek_to_ms(1);
            m_frameIdx = 0;
        }
        av_packet_unref(&packet);
    } while (!m_stoped);
    frame_present = false;
    ///av_packet_unref(&packet);
    m_thread_runned = false;
}