Recherche avancée

Sur d’autres sites (6600)

• Move SDL window in SDL 1.2

  6 mai 2015, par Dev Sam

  I am using SDL 1.2 with FFmpeg on MAC. I am trying to build a video player using both FFmpeg and SDL. I am viewing my video on SDL_Surface. My player is working fine. Now my problem is, i want to move SDL window without dragging it from title bar. Is there any function/method in SDL 1.2 framework for moving SDL_Surface.

• av_frame_free not freeing memory after av_frame_clone

  19 juillet 2020, par user2578525

  I want to implement zero delay frame step forward, backward. So I am maintaining a blocking queue of AVFrame. I copy (increase refcount)frame received form avcodec_receive_frame using av_frame_clone and add this cloned frame to my queue. A separate thread then dequeue this frame, display and free using av_frame_free. But somehow, this frame is not getting released, and ,my memory usage remains same after flushing whole queue. Snippets below.

  


  Decoder Thread :

  


  void *decoder(void *player) {
    // declarations
    AVFrame *decoded = av_frame_alloc();

    int read = 0;
    while((read = av_read_frame(fmt_ctx, packet)) >= 0) {
        if(packet->stream_index == vstream) {
            decode_packet(player, packet, decoded);
        }
    }
    av_frame_free(&decoded);
}

void decode_packet(Player *player, AVPacket *packet, AVFrame *decoded) {
    AVCodecContext *codec_ctx = player->vcodec_ctx;

    int ret = avcodec_send_packet(codec_ctx, packet);
    if (ret < 0) {
        log_error("avcodec_send_packet: %s", av_err2str(ret));
        return;
    }
    while(ret >= 0) {

        ret = avcodec_receive_frame(codec_ctx, decoded);
        if(ret < 0) {
            if(ret == AVERROR_EOF || ret == AVERROR(EAGAIN)) {
                break;
            }
            log_error("avcodec_receive_frame: %s", av_err2str(ret));
            av_packet_unref(packet);
            return;
        }
        AVFrame *cloned = av_frame_clone(decoded);
        queue_enqueue(player->decoder->frame_queue, cloned);

        av_frame_unref(decoded);
    }
}


  


  Render Thread :

  


  void *func_render(void *pPlayer) {
    Player *player = (Player *) pPlayer;
    Renderer *renderer = player->renderer;
    Decoder *decoder = player->decoder;

    while(!(player->state & STATE_PAUSE)) {
        AVFrame *decoded = queue_dequeue(decoder->frame_queue);

        convert_and_display_to_surface(player, decoded);

        av_frame_free(&decoded);
    }
}


  


  I am measuring memory usage after completing both threads and flushing whole queue (i.e calling av_frame_free for each frame in queue). Still I am seeing memory allocated for decoded frame are not released.

  


  If I deep copy frame instead of av_frame_clone using below snippet, everything works fine.

  


      AVFrame *copyFrame = av_frame_alloc();
    copyFrame->format = decoded->format;
    copyFrame->width = decoded->width;
    copyFrame->height = decoded->height;
    copyFrame->channels = decoded->channels;
    copyFrame->channel_layout = decoded->channel_layout;
    copyFrame->nb_samples = decoded->nb_samples;
    av_frame_get_buffer(copyFrame, 32);
    av_frame_copy(copyFrame, decoded);
    av_frame_copy_props(copyFrame, decoded);


  


  EDIT :
Debugged this problem a bit, and found that for some frame, even after calling av_frame_free, reference count to AVBufferRef remains non zero (i.e not decreasing after calling av_frame_free or av_frame_ref multiple times).

  


• How to record watching statistics in hls streaming

  5 juillet 2023, par qmksbp

  I implemented a vod streaming system that converts videos to hls with ffmpeg.

  


  And I made a Django program that gives playlists and ts files to the player so that the video can be played.

  


  But I don't know how to record the watching statistics.

  


  I used vediojs and I know that I can send the watching time from the client to the server and record it.

  


  But We are sure that this method is not accurate and the user can change the statistics.

  


  On the other hand, I have seen vod platforms that do not take the statistics from the player (client) at all, as if the statistics are calculated by the server.

  


  One option is to log the statistics for each ts file that is requested,
but the video buffering by the player means that these statistics are always wrong,
the player may buffer 10 minutes but the user still watches 1 minute.

  


  Any suggestion or experience

  


  I used vediojs and I know that I can send the watching time from the client to the server and record it.

  


  But We are sure that this method is not accurate and the user can change the statistics.