Recherche avancée

Sur d’autres sites (5216)

• Windows 8 Store Apps (IE 10/"MSAppHost" in UA) don’t support Flash or ActiveX, except for (at time of writing), three special ActiveX controls. Thus, new window.ActiveXObject(’ShockwaveFlash.ShockwaveFlash’) seems to work without error. However, an error is thrown if an with a Flash ActiveX CLSID is appended to the DOM. http://msdn.microsoft.com/en-us/library/windows/apps/hh465143.aspx

  30 septembre 2012, par Scott Schiller

  m script/soundmanager2-jsmin.js m script/soundmanager2-nodebug-jsmin.js m script/soundmanager2-nodebug.js m script/soundmanager2.js Windows 8 Store Apps (IE 10/"MSAppHost" in UA) don’t support Flash or ActiveX, except for (at time of writing), three special ActiveX controls. Thus, new (...)

• mp4 video plays from beginning while seeking to another time [on hold]

  13 août 2013, par user2649860

  i am using lighttpd and h264 with jwplayer. I am trying to stream the MP4 video.

  My problem is that the MP4 video downloads whole file before playing and i have another problem i.e. when i seek to another time/point the video plays from beginning and it plays after the end time also.

  i have already tried the ffmpeg tools to create the h264 video and qt-faststart.exe tool to fix the video index problem of the video. But it does not work.

  Any solution ?? THanks in advanced

• How to reduce time while writing to output stream

  9 février 2021, par Summit

  I am streaming the render ouput of a opengl application using mpegts.The issue that i am facing is that the time taken to encode the frame is quite long.

  


  The application renders at 60 fps with frame size of 1920 X 1080 , the frame data of the application is pushed to a std::queue.

  


  This is the process for ffmpeg.

  


  I  initialize the stream like this.&#xA;&#xA;   streamerUpd.InitUPD("udp://127.0.0.1:1234", 1920, 1080, rings_);&#xA;&#xA;int StreamUPD::InitUPD(const char* url, int width, int height, std::shared_ptr<ringbuffer2> rings)&#xA;{&#xA;&#xA;    rings_ = rings;&#xA;    width_ = width;&#xA;    height_ = height;&#xA;    filename = url;&#xA;    int ret;&#xA;    av_dict_set(&amp;opt, "pkt_size", "1316", 0);&#xA;    &#xA;        &#xA;    avformat_alloc_output_context2(&amp;oc, nullptr, "mpegts", filename);&#xA;    if (!oc) {&#xA;        return 1;&#xA;    }&#xA;&#xA;    fmt = oc->oformat;&#xA;    /* Add the audio and video streams using the default format codecs&#xA;     * and initialize the codecs. */&#xA;    if (fmt->video_codec != AV_CODEC_ID_NONE) {&#xA;        add_stream(&amp;video_st, oc, &amp;video_codec, fmt->video_codec);&#xA;        have_video = 1;&#xA;        encode_video = 1;&#xA;    }&#xA;&#xA;    /* Write the stream header, if any. */&#xA;    ret = avformat_write_header(oc, &amp;opt);&#xA;    if (ret &lt; 0) {&#xA;        fprintf(stderr, "Error occurred when opening output file: %s\n",&#xA;            av_err2str(ret));&#xA;        return 1;&#xA;    }&#xA;    thr = std::thread(&amp;StreamUPD::output_result, this);&#xA;    return 0;&#xA;}&#xA;</ringbuffer2>

  


  ////////////////////////////////////////////////////////////////////////////////////////

  


  // Add the output stream

  


  void StreamUPD::add_stream(OutputStream* ost, AVFormatContext* oc, AVCodec** codec, enum AVCodecID codec_id)
{
    AVCodecContext* c;
    int i;
    /* find the encoder */
    *codec = avcodec_find_encoder(codec_id);
    if (!(*codec)) {
        fprintf(stderr, "Could not find encoder for '%s'\n",
            avcodec_get_name(codec_id));
        exit(1);
    }
    ost->st = avformat_new_stream(oc, NULL);
    if (!ost->st) {
        fprintf(stderr, "Could not allocate stream\n");
        exit(1);
    }
    ost->st->id = oc->nb_streams - 1;
    c = avcodec_alloc_context3(*codec);
    if (!c) {
        fprintf(stderr, "Could not alloc an encoding context\n");
        exit(1);
    }
    ost->enc = c;
    switch ((*codec)->type) {
    case AVMEDIA_TYPE_VIDEO:
        c->codec_id = codec_id;
        c->bit_rate = 400000;

        /* Resolution must be a multiple of two. */
        c->width = width_;
        c->height = height_;
        /* timebase: This is the fundamental unit of time (in seconds) in terms
         * of which frame timestamps are represented. For fixed-fps content,
         * timebase should be 1/framerate and timestamp increments should be
         * identical to 1. */
        ost->st->time_base = { 1, STREAM_FRAME_RATE };
        c->time_base = ost->st->time_base;
        c->gop_size = 12; /* emit one intra frame every twelve frames at most */
        c->pix_fmt = STREAM_PIX_FMT;
        
        if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
            /* just for testing, we also add B-frames */
            qDebug() << "This is MPEG2VIDEO Frame";
            c->max_b_frames = 2;
            
        }
        if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
            /* Needed to avoid using macroblocks in which some coeffs overflow.
             * This does not happen with normal video, it just happens here as
             * the motion of the chroma plane does not match the luma plane. */
            c->mb_decision = 2;
        }
        break;
    default:
        break;
    }
    /* Some formats want stream headers to be separate. */
    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
        c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
}


  


  //////////////////////////////////////////////////////////////////////////////////

  


  // Open the video

  


  void StreamUPD::open_video(AVFormatContext* oc, AVCodec* codec, OutputStream* ost, AVDictionary* opt_arg)
    {
        int ret;
        AVCodecContext* c = ost->enc;
        AVDictionary* opt = NULL;
        av_dict_copy(&opt, opt_arg, 0);
        /* open the codec */
        ret = avcodec_open2(c, codec, &opt);
        av_dict_free(&opt);
        if (ret < 0) {
            fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));
            exit(1);
        }
        /* allocate and init a re-usable frame */
        ost->frame = alloc_picture(c->pix_fmt, c->width, c->height);
        if (!ost->frame) {
            fprintf(stderr, "Could not allocate video frame\n");
            exit(1);
        }
        /* If the output format is not YUV420P, then a temporary YUV420P
         * picture is needed too. It is then converted to the required
         * output format. */
        ost->tmp_frame = NULL;
        if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
            ost->tmp_frame = alloc_picture(AV_PIX_FMT_YUV420P, c->width, c->height);
            if (!ost->tmp_frame) {
                fprintf(stderr, "Could not allocate temporary picture\n");
                exit(1);
            }
        }
        /* copy the stream parameters to the muxer */
        ret = avcodec_parameters_from_context(ost->st->codecpar, c);
        if (ret < 0) {
            fprintf(stderr, "Could not copy the stream parameters\n");
            exit(1);
        }
    }


  


  Once i have setup the ffmpeg output stream this is how i am streaming the data.

  


  This function gets the frame data from the std::queue(pixelsQueue) and sends it for encoding.

  


  int StreamUPD::stream_video_frame()
{   
    ost = &video_st;
    c = ost->enc;   

    /* when we pass a frame to the encoder, it may keep a reference to it
     * internally; make sure we do not overwrite it here */
    if (av_frame_make_writable(ost->frame) < 0)
        exit(1);
    if (!ost->sws_ctx) {
        ost->sws_ctx = sws_getContext(c->width, c->height,
            AV_PIX_FMT_RGB24,
            c->width, c->height,
            c->pix_fmt,
            SWS_FAST_BILINEAR, NULL, NULL, NULL);
        if (!ost->sws_ctx) {
            fprintf(stderr,
                "Could not initialize the conversion context\n");
            exit(1);
        }
    }
    finished_ = true;

    if (pixelsQueue.size() > 0) {       
        if (pixelsQueue.pop(pixels)) {
            fill_yuv_image(ost->sws_ctx, frame_data->pixels_.get(), ost->frame, c->width, c->height);
            ost->frame->pts = ost->next_pts++;
            return write_frame(oc, ost->enc, ost->st, ost->frame);
        }
    }
    return 1;
}


  


  Writing the data to the output stream.

  


  The function avcodec_receive_packet is the one that takes lot of time.

  


  int StreamUPD::write_frame(AVFormatContext* fmt_ctx, AVCodecContext* c,
    AVStream* st, AVFrame* frame)
{
    int ret;
    // send the frame to the encoder
    AVPacket pkt = { 0 };
    ret = avcodec_send_frame(c, frame);
    ret = avcodec_receive_packet(c, &pkt);
    if (ret < 0) {
        fprintf(stderr, "Error sending a frame to the encoder: %s\n",
            av_err2str(ret));
        exit(1);
    }
    
    while (ret >= 0) {
        AVPacket pkt = { 0 };
        ret = avcodec_receive_packet(c, &pkt);  // This is the function that takes lot of time
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            break;
        else if (ret < 0) {
            fprintf(stderr, "Error encoding a frame: %s\n", av_err2str(ret));
            exit(1);
        }
        // rescale output packet timestamp values from codec to stream timebase 
        av_packet_rescale_ts(&pkt, c->time_base, st->time_base);
        pkt.stream_index = st->index;
        // Write the compressed frame to the media file. 
        ret = av_interleaved_write_frame(fmt_ctx, &pkt);
        av_packet_unref(&pkt);
        if (ret < 0) {
            fprintf(stderr, "Error while writing output packet: %s\n", av_err2str(ret));
            exit(1);
        }
    }
    return ret == AVERROR_EOF ? 1 : 0;
}


  


  How can i reduce the outputting time while writing the frames to the stream ?

  


  Currently i push more frames in the buffer and the outputting speed is less so the buffer starts to run out of memory in some time.